@litmers/cursorflow-orchestrator 0.1.15 → 0.1.20

package/src/cli/prepare.ts

@@ -9,6 +9,8 @@ import * as path from 'path';
 import * as logger from '../utils/logger';
 import { loadConfig, getTasksDir } from '../utils/config';
 import { Task, RunnerConfig } from '../utils/types';
+import { safeJoin } from '../utils/path';
+import { resolveTemplate } from '../utils/template';
 
 // Preset template types
 type PresetType = 'complex' | 'simple' | 'merge';
@@ -97,20 +99,24 @@ Prepare task files for a new feature - Terminal-first workflow.
     --prompt <text>           Task prompt (uses preset or single task)
     --criteria <list>         Comma-separated acceptance criteria
     --model <model>           Model to use (default: sonnet-4.5)
-    --task <spec>             Full task spec: "name|model|prompt|criteria" (repeatable)
+    --task <spec>             Full task spec: "name|model|prompt|criteria|dependsOn|timeout" (repeatable)
 
   Dependencies:
     --sequential              Chain lanes: 1 → 2 → 3
     --deps <spec>             Custom dependencies: "2:1;3:1,2"
     --depends-on <lanes>      Dependencies for --add-lane: "01-lane-1,02-lane-2"
+    Task-level deps:          In --task, add "lane:task" at the end.
+                              Example: "test|sonnet-4.5|Run tests|All pass|01-lane-1:setup"
+    Task-level timeout:       In --task, add milliseconds at the end.
+                              Example: "heavy|sonnet-4.5|Big task|Done||1200000"
 
   Incremental (add to existing):
     --add-lane <dir>          Add a new lane to existing task directory
     --add-task <file>         Append task(s) to existing lane JSON file
 
   Advanced:
-    --template <path>         Custom template JSON file
-    --force                   Overwrite existing files
+    --template <path|url|name>  External template JSON file, URL, or built-in name
+    --force                     Overwrite existing files
 
 ═══════════════════════════════════════════════════════════════════════════════
 
@@ -203,23 +209,31 @@ function parseArgs(args: string[]): PrepareOptions {
 }
 
 function parseTaskSpec(spec: string): Task {
-  // Format: "name|model|prompt|criteria1,criteria2"
+  // Format: "name|model|prompt|criteria1,criteria2|lane:task1,lane:task2|timeoutMs"
   const parts = spec.split('|');
   
   if (parts.length < 3) {
-    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria1,criteria2]"`);
+    throw new Error(`Invalid task spec: "${spec}". Expected format: "name|model|prompt[|criteria[|dependsOn[|timeout]]]"`);
   }
   
-  const [name, model, prompt, criteriaStr] = parts;
+  const [name, model, prompt, criteriaStr, depsStr, timeoutStr] = parts;
   const acceptanceCriteria = criteriaStr 
     ? criteriaStr.split(',').map(c => c.trim()).filter(c => c)
     : undefined;
   
+  const dependsOn = depsStr
+    ? depsStr.split(',').map(d => d.trim()).filter(d => d)
+    : undefined;
+
+  const timeout = timeoutStr ? parseInt(timeoutStr) : undefined;
+  
   return {
     name: name.trim(),
     model: model.trim() || 'sonnet-4.5',
     prompt: prompt.trim(),
     ...(acceptanceCriteria && acceptanceCriteria.length > 0 ? { acceptanceCriteria } : {}),
+    ...(dependsOn && dependsOn.length > 0 ? { dependsOn } : {}),
+    ...(timeout ? { timeout } : {}),
   };
 }
 
@@ -600,7 +614,7 @@ function getFeatureNameFromDir(taskDir: string): string {
 }
 
 async function addLaneToDir(options: PrepareOptions): Promise<void> {
-  const taskDir = path.resolve(process.cwd(), options.addLane!);
+  const taskDir = path.resolve(process.cwd(), options.addLane!); // nosemgrep
   
   if (!fs.existsSync(taskDir)) {
     throw new Error(`Task directory not found: ${taskDir}`);
@@ -610,29 +624,56 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
   const laneNumber = getNextLaneNumber(taskDir);
   const laneName = `lane-${laneNumber}`;
   const fileName = `${laneNumber.toString().padStart(2, '0')}-${laneName}.json`;
-  const filePath = path.join(taskDir, fileName);
-  
-  if (fs.existsSync(filePath) && !options.force) {
-    throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
-  }
+  const filePath = safeJoin(taskDir, fileName);
   
   const hasDependencies = options.dependsOnLanes.length > 0;
   
-  // Build tasks from options (auto-detects merge preset if has dependencies)
-  const tasks = buildTasksFromOptions(options, laneNumber, featureName, hasDependencies);
-  const config = getDefaultConfig(laneNumber, featureName, tasks);
+  // Load template if provided
+  let template = null;
+  if (options.template) {
+    template = await resolveTemplate(options.template);
+  }
+
+  let taskConfig;
+  let effectivePreset: EffectivePresetType = options.preset || (hasDependencies ? 'merge' : 'complex');
+
+  if (template) {
+    taskConfig = { ...template, laneNumber, devPort: 3000 + laneNumber };
+    effectivePreset = 'custom';
+  } else {
+    // Build tasks from options (auto-detects merge preset if has dependencies)
+    const tasks = buildTasksFromOptions(options, laneNumber, featureName, hasDependencies);
+    taskConfig = getDefaultConfig(laneNumber, featureName, tasks);
+  }
+
+  // Replace placeholders
+  const processedConfig = replacePlaceholders(taskConfig, {
+    featureName,
+    laneNumber,
+    devPort: 3000 + laneNumber,
+  });
   
   // Add dependencies if specified
   const finalConfig = {
-    ...config,
+    ...processedConfig,
     ...(hasDependencies ? { dependsOn: options.dependsOnLanes } : {}),
   };
   
-  fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', 'utf8');
+  // Use atomic write with wx flag to avoid TOCTOU race condition (unless force is set)
+  try {
+    const writeFlag = options.force ? 'w' : 'wx';
+    fs.writeFileSync(filePath, JSON.stringify(finalConfig, null, 2) + '\n', { encoding: 'utf8', flag: writeFlag });
+  } catch (err: any) {
+    if (err.code === 'EEXIST') {
+      throw new Error(`Lane file already exists: ${filePath}. Use --force to overwrite.`);
+    }
+    throw err;
+  }
   
-  const taskSummary = tasks.map(t => t.name).join(' → ');
+  const tasksList = finalConfig.tasks || [];
+  const taskSummary = tasksList.map((t: any) => t.name).join(' → ');
   const depsInfo = hasDependencies ? ` (depends: ${options.dependsOnLanes.join(', ')})` : '';
-  const presetInfo = options.preset ? ` [${options.preset}]` : (hasDependencies ? ' [merge]' : '');
+  const presetInfo = options.preset ? ` [${options.preset}]` : (hasDependencies ? ' [merge]' : (template ? ' [template]' : ''));
   
   logger.success(`Added lane: ${fileName} [${taskSummary}]${presetInfo}${depsInfo}`);
   logger.info(`Directory: ${taskDir}`);
@@ -643,18 +684,22 @@ async function addLaneToDir(options: PrepareOptions): Promise<void> {
 }
 
 async function addTaskToLane(options: PrepareOptions): Promise<void> {
-  const laneFile = path.resolve(process.cwd(), options.addTask!);
-  
-  if (!fs.existsSync(laneFile)) {
-    throw new Error(`Lane file not found: ${laneFile}`);
-  }
+  const laneFile = path.resolve(process.cwd(), options.addTask!); // nosemgrep
   
   if (options.taskSpecs.length === 0) {
     throw new Error('No task specified. Use --task "name|model|prompt|criteria" to define a task.');
   }
   
-  // Read existing config
-  const existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  // Read existing config - let the error propagate if file doesn't exist (avoids TOCTOU)
+  let existingConfig: any;
+  try {
+    existingConfig = JSON.parse(fs.readFileSync(laneFile, 'utf8'));
+  } catch (err: any) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`Lane file not found: ${laneFile}`);
+    }
+    throw err;
+  }
   
   if (!existingConfig.tasks || !Array.isArray(existingConfig.tasks)) {
     existingConfig.tasks = [];
@@ -687,7 +732,7 @@ async function createNewFeature(options: PrepareOptions): Promise<void> {
   const now = new Date();
   const timestamp = now.toISOString().replace(/[-T:]/g, '').substring(2, 12);
   const taskDirName = `${timestamp}_${options.featureName}`;
-  const taskDir = path.join(tasksBaseDir, taskDirName);
+  const taskDir = safeJoin(tasksBaseDir, taskDirName);
 
   if (fs.existsSync(taskDir) && !options.force) {
     throw new Error(`Task directory already exists: ${taskDir}. Use --force to overwrite.`);
@@ -702,12 +747,7 @@ async function createNewFeature(options: PrepareOptions): Promise<void> {
   // Load template if provided (overrides --prompt/--task/--preset)
   let template = null;
   if (options.template) {
-    const templatePath = path.resolve(process.cwd(), options.template);
-    if (!fs.existsSync(templatePath)) {
-      throw new Error(`Template file not found: ${templatePath}`);
-    }
-    template = JSON.parse(fs.readFileSync(templatePath, 'utf8'));
-    logger.info(`Using template: ${options.template}`);
+    template = await resolveTemplate(options.template);
   }
 
   // Calculate dependencies
@@ -720,7 +760,7 @@ async function createNewFeature(options: PrepareOptions): Promise<void> {
   for (let i = 1; i <= options.lanes; i++) {
     const laneName = `lane-${i}`;
     const fileName = `${i.toString().padStart(2, '0')}-${laneName}.json`;
-    const filePath = path.join(taskDir, fileName);
+    const filePath = safeJoin(taskDir, fileName);
     
     const depNums = dependencyMap.get(i) || [];
     const dependsOn = depNums.map(n => {
@@ -767,7 +807,7 @@ async function createNewFeature(options: PrepareOptions): Promise<void> {
   }
 
   // Create README
-  const readmePath = path.join(taskDir, 'README.md');
+  const readmePath = safeJoin(taskDir, 'README.md');
   const readme = `# Task: ${options.featureName}
 
 Prepared at: ${now.toISOString()}