Core Task System

/**
 * Creates a Jake Task
 * @param {string} name - The name of the Task
 * @param {string[]} [prereqs] - Prerequisites to be run before this task
 * @param {Function} [action] - The action to perform for this task
 * @param {Object} [opts] - Task options
 * @param {boolean} [opts.async=false] - Perform this task asynchronously
 * @param {number} [opts.concurrency=1] - Number of prereqs to run concurrently
 * @returns {Task} The created task instance
 */
function task(name, prereqs, action, opts);

// Simple task
desc('This is the default task.');
task('default', function () {
  console.log('This is the default task.');
});

// Task with prerequisites
desc('This task has prerequisites.');
task('hasPrereqs', ['foo', 'bar', 'baz'], function () {
  console.log('Ran some prereqs first.');
});

// Asynchronous task
desc('This is an asynchronous task.');
task('asyncTask', function () {
  setTimeout(complete, 1000);
}, { async: true });

// Task with parameters from command line
task('greet', function (name, greeting) {
  console.log(greeting + ', ' + name + '!');
});
// Usage: jake greet[John,Hello]

/**
 * Creates a Jake FileTask
 * @param {string} name - The file path this task represents
 * @param {string[]} [prereqs] - Prerequisites to be run before this task
 * @param {Function} [action] - The action to create this file, if it doesn't exist
 * @param {Object} [opts] - Task options
 * @param {boolean} [opts.async=false] - Perform this task asynchronously
 * @returns {FileTask} The created file task instance
 */
function file(name, prereqs, action, opts);

// File task that compiles TypeScript
file('dist/app.js', ['src/app.ts'], function () {
  jake.exec(['tsc src/app.ts --outDir dist'], function () {
    complete();
  });
}, { async: true });

// File task with multiple dependencies
file('build/bundle.min.js', ['build/bundle.js'], function () {
  jake.exec(['uglifyjs build/bundle.js -o build/bundle.min.js'], function () {
    complete();
  });
}, { async: true });

// File task that only runs if source is newer
file('docs/api.html', ['src/**/*.js'], function () {
  jake.exec(['jsdoc src -d docs'], function () {
    complete();
  });
}, { async: true });

/**
 * Creates a Jake DirectoryTask that ensures a directory exists
 * @param {string} name - The directory path to create
 * @returns {DirectoryTask} The created directory task instance
 */
function directory(name);

// Create directories for build output
directory('dist');
directory('build/assets');
directory('tmp/cache');

// Use directory as prerequisite
file('dist/app.js', ['dist', 'src/app.js'], function () {
  // dist directory is guaranteed to exist
  jake.cpR('src/app.js', 'dist/app.js');
});

/**
 * Creates a description for a Jake Task
 * @param {string} description - The description for the Task
 */
function desc(description);

desc('Compile all TypeScript files');
task('compile', ['clean'], function () {
  jake.exec(['tsc']);
});

desc('Run all tests');
task('test', ['compile'], function () {
  jake.exec(['mocha test/**/*.js']);
});

desc('Clean build directory');
task('clean', function () {
  jake.rmRf('dist');
});

/**
 * Completes an asynchronous task
 * @param {Task} [task] - Specific task to complete (optional)
 * @param {*} [value] - Return value for the task (optional)
 */
function complete(task, value);

// Complete the current task
task('asyncTask', function () {
  setTimeout(function () {
    console.log('Async work done');
    complete();
  }, 1000);
}, { async: true });

// Complete with a return value
task('getData', function () {
  fetchData(function (err, data) {
    if (err) {
      fail(err);
    } else {
      complete(null, data);
    }
  });
}, { async: true });

// Complete a specific task (for parallel execution)
task('parallelTask', ['taskA', 'taskB'], function () {
  // Both taskA and taskB run in parallel
  setTimeout(function () {
    complete(this, 'result');
  }.bind(this), 500);
}, { async: true });

/**
 * Causes Jake execution to abort with an error
 * @param {Error|string} err - The error to throw when aborting execution
 * @param {number} [code] - Optional exit code for the process
 */
function fail(err, code);

task('checkEnv', function () {
  if (!process.env.NODE_ENV) {
    fail('NODE_ENV environment variable is required');
  }
});

task('validateConfig', function () {
  try {
    const config = JSON.parse(fs.readFileSync('config.json'));
    if (!config.apiKey) {
      fail('API key is missing from config', 1);
    }
  } catch (e) {
    fail(e, 2);
  }
});

// Fail with multi-line error
task('complexValidation', function () {
  const errors = validateProject();
  if (errors.length > 0) {
    const errorMsg = 'Validation failed:\n' + errors.join('\n');
    fail(errorMsg);
  }
});

task('build', ['clean', 'compile', 'bundle'], function () {
  console.log('Build complete');
});
// Execution order: clean → compile → bundle → build action

task('test', ['unit-tests', 'integration-tests'], function () {
  console.log('All tests complete');
}, { concurrency: 2 }); // Run both test tasks in parallel

file('output.txt', ['input1.txt', 'input2.txt'], function () {
  // Only runs if input files are newer than output.txt
  jake.exec(['cat input1.txt input2.txt > output.txt']);
});

// Using callbacks
task('fetchData', function () {
  https.get('https://api.example.com/data', function (res) {
    // Process response
    complete();
  });
}, { async: true });

// Using promises
task('processFiles', function () {
  processFilesAsync()
    .then(function (result) {
      console.log('Processing complete');
      complete();
    })
    .catch(function (err) {
      fail(err);
    });
}, { async: true });

// Using async/await (Node.js 8+)
task('modernAsync', async function () {
  try {
    const result = await processFilesAsync();
    console.log('Result:', result);
    complete();
  } catch (err) {
    fail(err);
  }
}, { async: true });

/**
 * Creates a sequential execution function from multiple tasks
 * @param {...Function} tasks - Functions representing tasks to run in series
 * @returns {Function} Function that returns a Promise when called
 */
function series(...tasks);

// Define tasks as functions
const cleanTask = function() {
  jake.rmRf('dist');
};

const buildTask = function() {
  jake.exec(['webpack --mode=production'], { printStdout: true });
};

const testTask = function() {
  jake.exec(['npm test'], { printStdout: true });
};

// Create series execution function
const buildPipeline = series(cleanTask, buildTask, testTask);

// Execute the series
task('pipeline', async function() {
  await buildPipeline();
  console.log('Pipeline complete');
});

/**
 * Sets the global timeout for all tasks
 * @param {number} timeout - Timeout in milliseconds
 */
function setTaskTimeout(timeout);

// Set 5 minute timeout for all tasks
setTaskTimeout(300000);

// Set different timeout for specific environments
if (process.env.NODE_ENV === 'ci') {
  setTaskTimeout(600000); // 10 minutes for CI
} else {
  setTaskTimeout(120000); // 2 minutes for development
}

/**
 * Sets an automatic prefix for series-generated task names
 * @param {string} prefix - Prefix to add to task names
 */
function setSeriesAutoPrefix(prefix);

// Set prefix for series tasks
setSeriesAutoPrefix('auto:');

const taskSeries = series(cleanTask, buildTask);
// Generated internal tasks will have names like 'auto:cleanTask', 'auto:buildTask'