It's available for download at http://www.agendaless.com/Members/chrism/software/buildit/

From the Readme, here's the basics:

  Buildit makes it easier to create a repeatable deployment of
  software in a particular configuration.  With it, you can perform
  conditional complilation of source code, install software, run
  scripts, or perform any repeatable sequence of tasks that ends up
  creating a known set files on your filesystem.  On subsequent runs
  of the same set of tasks, Buildit performs the least amount of work
  possible to create the same set of files, only performing the work
  that it detects has not already been performed by earlier runs.

 Rationale

  Buildit was created to allow me to write "buildout" profiles which
  need to perform arbitrary tasks in the service of setting up a
  client operating system environment with software and data specific
  to running applications I helped create.  For instance, in one case,
  it is currently used to build multiple "instances" of Zope, ZEO,
  Apache/PHP, Squid, Python, and MySQL on a single machine, forming a
  software "profile" particular to that machine.  The same buildout
  files are rearranged to create different instances of software on
  different machines at the same site.  The same software is used to
  perform incremental upgrades to existing buildouts.

  Why Not Make?

    We had previously been using GNU Make for the same task, but my
    clients couldn't maintain the makefiles easily after the
    engagement ended because they were not willing to learn GNU Make's
    automatic variables and pattern rules which I used somewhat
    gratuitously to make my life easier.  I also realized that even I
    could barely read the makefiles after I had been away from them
    for some time.

    Although make's fundamental behavior is very simple, it has a few
    problems.  Because its basic feature set is so simple, and because
    it has been proven to need to do some reasonably complex things,
    many make versions have also accreted features over the years to
    allow for this complexity.  Unfortunately, it was never meant to
    be a full-blown programming language, and the additions made to
    make syntax to support complex tasks are fairly mystifying.
    Additionally, if advanced make features are used within a
    Makefile, it is difficult to create, debug and maintain makefiles
    for those with little "make-fu".  Even simple failing makefiles
    can be difficult to debug.

  Why Not Ant?

    I a big fan of neither Java nor hand-writing XML.  Ant requires I
    use one and do the other.

  Why Not SCons?

    SCons is all about solving problems specific to the domain of
    source code recompilation.  Buildit is much smaller, and more
    general.

  Why Not A-A-P?

    A-A-P was designed from the perspective of someone wanting to
    develop and install a software package on many different
    platforms.  It does this very well, but loses some generality in
    the process.  A-A-P also uses a make-like syntax for describing
    tasks, whereas Buildit uses Python.

  Why not zc.buildout?

    zc.buildout was released after Buildit was already mature.
    Additionally, zc.buildout appears to have a focus on Python eggs
    which Buildit does not.

I hope to be able to release a set of example buildit recipes for building Zope, Postgres, and various other things shortly. EDIT: Those are available now .