A simple gulpfile I use for some of my projects. Some more thought could be done on the task order. I've found that the task dependencies do not work as expected (most likely because deferreds aren't being used in the lib or by hand in this script).

Basic Gulp File

// Apache2 License
// Author: Jason Giedymin

// ### Requires
var packageFile = require('./package');
var gulp = require('gulp');
var rimraf = require('gulp-rimraf');
var zip = require('gulp-zip');
var docco = require("gulp-docco");
var mocha = require('gulp-mocha');
var pandoc = require('gulp-pandoc');
var istanbul = require('gulp-istanbul');
var runSequence = require('run-sequence');
var _ = require('lodash');

// ### Vars
// Files and dirs to clean
var clean_files = [
  './docs/**',
  './wiki/**',
  './dist/**'
];

// Source files use in distribution task
var dist_files = [
  './app.js',
  './lib/**/*.js',
  './package.json',
  './README.md',
  './changelog.md',
  './wiki/*',
  './wiki/coverage/**'
];

var src_files = [
  './app.js',
  './lib/**/*.js'
];

var spec_files = [
  './specs/**/*-spec.js'
];

// Files to docco parse for documentation
var docable_files = [
  '*.js',
  './lib/**/*.js',
  './specs/lib/**/*.js'
];

// Files to convert to markdown (from pandoc)
var wikiable_files = [
  './docs/*.html',
  './docs/**/*.html',
  '!./docs/**/*.js.html'
];

// ### Clean task
// Cleans all files specified in `clean_files` glob
function clean() {
  return gulp.src(clean_files, { read: false })
      .pipe(rimraf());
}

// ### Distribution task
// Task that zip up all files from `dist_files` and sends them to:
// - `dist/`
function dist() {
  return gulp.src(_.flatten([dist_files]))
    // here we grab the version straight from the `package.json` file
    // and use it as part of the zip name
      .pipe(zip(packageFile.name + '-v' + packageFile.version + '.zip'))
    // send to `dist/` folder
      .pipe(gulp.dest('dist'));
}

// ### Docs task
// Task that generates html formated markdown via docco.
function docs() {
  return gulp.src(docable_files)
      .pipe(docco({layout:'parallel'}))
      .pipe(gulp.dest('./docs'));
}

// ### Wiki task
// Task that generates wiki markdown from html created by the `docs` task
function wiki(callback) {
  return gulp.src(wikiable_files)
      .pipe(pandoc({
        from: 'html',
        to: 'markdown',
        ext: '.md',
        args: ['--smart']
      }))
      .pipe(gulp.dest('wiki/'))
      .on('end', function(){
        if(callback) callback();
      })
}

// ### Test task
// Task that runs tests, feeding it `spec_files`, and currently only using the mocha plugin
// declared above in the imports.
function test() {
  return gulp.src(spec_files)
      .pipe(mocha({reporter: 'spec', growl: true, bail: true}));
}

// ### Test coverage
// Task that runs `istanbul` for test coverage. This task also runs
// the tests.
function cov(callback) {
  return gulp.src(src_files)
      .pipe(istanbul()) // Covering files
      .on('end', function () {
        gulp.src(spec_files)
            .pipe(test())
            .pipe(istanbul.writeReports('./docs/coverage'))
            .on('end', function(){
              if(callback) callback();
            });
      });
}

// ### Watch dist task
// Watch for any changes required to re-execute the `dist` task.
function watchDist() {
  return gulp.watch(_.flatten([src_files, spec_files]), function() {
    runSequence(['clean', 'docs']);
    cov(function(){
      wiki(dist);
    });
  } );
}

// ### Watch test task
// Watch for any changes required to re-execute the `test` task.
function watchTest() {
  return gulp.watch(_.flatten([src_files, spec_files]), ['test']);
}

// ### Task binding
// Define all the gulp tasks here, calling the functions created above.
// Tasks are defined as single methods without dependencies specified
// because gulpjs dependencies are not fully sync (see Issue #1).
// To make build tasks run in sequence, they are prefixed with `build-`.
gulp.task('clean', clean);
gulp.task('test', test);

// Clean out dirs first before generating docs
gulp.task('docs', docs);

// Note that running coverage will run `test` task implicitly, and it
// also requires that the `doc` task run prior so that coverage
// reports can be piped to the `docs/` dir.
gulp.task('cov', function(){ cov() });

// warning, if nothing to wiki-ize then nothing will be created
gulp.task('wiki', function(){ wiki() });

// This is a hack, where first runSequence is called with identity
// functions (zero param), and then we pass a function to be called
// when `runSequence completes`. The function passed in will run
// `wiki` which passes another function to be called back as `dist`.
// This could be done with async, or Q. Will tackle later.
gulp.task('dist', function() {
  runSequence(['clean', 'docs']);
  cov(function(){
    wiki(dist);
  });
});

// Default task depends on the `dist` task
gulp.task('default', ['dist']);

// Watch tasks
gulp.task('watch-test', watchTest);
gulp.task('watch-dist', watchDist);
// Default Watch task
gulp.task('watch', watchTest);