@litmers/cursorflow-orchestrator 0.1.34 → 0.1.36

package/dist/utils/flow.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFlowDir = findFlowDir;
+const fs = __importStar(require("fs"));
+const path_1 = require("./path");
+/**
+ * Find flow directory by name in the flows directory.
+ * Matches by exact name or by suffix (ignoring ID prefix like '001_').
+ *
+ * @param flowsDir The base flows directory (e.g., _cursorflow/flows)
+ * @param flowName The name of the flow to find
+ * @returns The absolute path to the flow directory, or null if not found
+ */
+function findFlowDir(flowsDir, flowName) {
+    if (!fs.existsSync(flowsDir)) {
+        return null;
+    }
+    const dirs = fs.readdirSync(flowsDir)
+        .filter(name => {
+        const dirPath = (0, path_1.safeJoin)(flowsDir, name);
+        try {
+            return fs.statSync(dirPath).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .filter(name => {
+        // Match by exact name or by suffix (ignoring ID prefix)
+        const match = name.match(/^\d+_(.+)$/);
+        return match ? match[1] === flowName : name === flowName;
+    });
+    if (dirs.length === 0) {
+        return null;
+    }
+    // Return the most recent one (highest ID / alphabetical)
+    dirs.sort((a, b) => b.localeCompare(a));
+    return (0, path_1.safeJoin)(flowsDir, dirs[0]);
+}
+//# sourceMappingURL=flow.js.map

package/dist/utils/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../src/utils/flow.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,kCA2BC;AAvCD,uCAAyB;AAEzB,iCAAkC;AAElC;;;;;;;GAOG;AACH,SAAgB,WAAW,CAAC,QAAgB,EAAE,QAAgB;IAC5D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,IAAI,GAAG,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC;SAClC,MAAM,CAAC,IAAI,CAAC,EAAE;QACb,MAAM,OAAO,GAAG,IAAA,eAAQ,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACzC,IAAI,CAAC;YACH,OAAO,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC,CAAC;SACD,MAAM,CAAC,IAAI,CAAC,EAAE;QACb,wDAAwD;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QACvC,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEL,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yDAAyD;IACzD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACxC,OAAO,IAAA,eAAQ,EAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAE,CAAC,CAAC;AACtC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litmers/cursorflow-orchestrator",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Git worktree-based parallel AI agent orchestration system for Cursor",
   "main": "dist/cli/index.js",
   "bin": {

package/src/cli/doctor.ts

@@ -13,12 +13,18 @@
  */
 
 import * as logger from '../utils/logger';
+import * as path from 'path';
+import * as fs from 'fs';
 import { runDoctor, saveDoctorStatus } from '../utils/doctor';
 import { runInteractiveAgentTest } from '../utils/cursor-agent';
+import { loadConfig, findProjectRoot } from '../utils/config';
+import { safeJoin } from '../utils/path';
+import { findFlowDir } from '../utils/flow';
 
 interface DoctorCliOptions {
   json: boolean;
   tasksDir: string | null;
+  flowOrTaskName: string | null;
   executor: string | null;
   includeCursorAgentChecks: boolean;
   testAgent: boolean;
@@ -26,13 +32,16 @@ interface DoctorCliOptions {
 
 function printHelp(): void {
   console.log(`
-Usage: cursorflow doctor [options]
+Usage: cursorflow doctor [flow-name] [options]
 
 Verify your environment is ready for CursorFlow runs.
 
+Arguments:
+  [flow-name]            Flow or task name to validate (optional)
+
 Options:
   --json                 Output machine-readable JSON
-  --tasks-dir <path>     Also validate lane files (run preflight)
+  --tasks-dir <path>     Validate specific directory (legacy)
   --executor <type>      cursor-agent | cloud
   --no-cursor            Skip Cursor Agent install/auth checks
   --test-agent           Run interactive agent test (to approve MCP/permissions)
@@ -40,18 +49,30 @@ Options:
 
 Examples:
   cursorflow doctor
+  cursorflow doctor TestFeature
   cursorflow doctor --test-agent
-  cursorflow doctor --tasks-dir _cursorflow/tasks/demo-test/
+  cursorflow doctor --tasks-dir _cursorflow/flows/001_TestFeature
   `);
 }
 
 function parseArgs(args: string[]): DoctorCliOptions {
   const tasksDirIdx = args.indexOf('--tasks-dir');
   const executorIdx = args.indexOf('--executor');
+  
+  // Find positional argument (flow/task name)
+  // Exclude args that are values for options
+  const optionValueIndices = new Set<number>();
+  if (tasksDirIdx >= 0 && tasksDirIdx + 1 < args.length) optionValueIndices.add(tasksDirIdx + 1);
+  if (executorIdx >= 0 && executorIdx + 1 < args.length) optionValueIndices.add(executorIdx + 1);
+  
+  const flowOrTaskName = args.find((arg, idx) => 
+    !arg.startsWith('--') && !optionValueIndices.has(idx)
+  ) || null;
 
   const options: DoctorCliOptions = {
     json: args.includes('--json'),
     tasksDir: tasksDirIdx >= 0 ? (args[tasksDirIdx + 1] || null) : null,
+    flowOrTaskName,
     executor: executorIdx >= 0 ? (args[executorIdx + 1] || null) : null,
     includeCursorAgentChecks: !args.includes('--no-cursor'),
     testAgent: args.includes('--test-agent'),
@@ -117,9 +138,32 @@ async function doctor(args: string[]): Promise<void> {
     process.exit(success ? 0 : 1);
   }
 
+  // Resolve tasksDir from flow name if provided
+  let tasksDir = options.tasksDir;
+  if (!tasksDir && options.flowOrTaskName) {
+    try {
+      const config = loadConfig();
+      const flowsDir = safeJoin(config.projectRoot, config.flowsDir);
+      const foundFlow = findFlowDir(flowsDir, options.flowOrTaskName);
+      if (foundFlow) {
+        tasksDir = foundFlow;
+      } else {
+        // Try as a direct path
+        const directPath = path.resolve(process.cwd(), options.flowOrTaskName);
+        if (fs.existsSync(directPath)) {
+          tasksDir = directPath;
+        } else {
+          tasksDir = options.flowOrTaskName;
+        }
+      }
+    } catch {
+      tasksDir = options.flowOrTaskName;
+    }
+  }
+
   const report = runDoctor({
     cwd: process.cwd(),
-    tasksDir: options.tasksDir || undefined,
+    tasksDir: tasksDir || undefined,
     executor: options.executor || undefined,
     includeCursorAgentChecks: options.includeCursorAgentChecks,
   });

package/src/cli/logs.ts

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as logger from '../utils/logger';
-import { loadConfig } from '../utils/config';
+import { loadConfig, getLogsDir } from '../utils/config';
 import { safeJoin } from '../utils/path';
 import { 
   readJsonLog, 
@@ -808,11 +808,22 @@ async function logs(args: string[]): Promise<void> {
   }
   
   const config = loadConfig();
+  const originalCwd = process.cwd();
+
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
   
   // Find run directory
   let runDir = options.runDir;
+  if (runDir && runDir !== 'latest' && !path.isAbsolute(runDir)) {
+    runDir = path.resolve(originalCwd, runDir);
+  }
+
   if (!runDir || runDir === 'latest') {
-    runDir = findLatestRunDir(config.logsDir) || undefined;
+    runDir = findLatestRunDir(getLogsDir(config)) || undefined;
   }
   
   if (!runDir || !fs.existsSync(runDir)) {

package/src/cli/monitor.ts

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import { loadState, readLog } from '../utils/state';
 import { LaneState, ConversationEntry } from '../utils/types';
-import { loadConfig } from '../utils/config';
+import { loadConfig, getLogsDir } from '../utils/config';
 import { safeJoin } from '../utils/path';
 import { getLaneProcessStatus, getFlowSummary, LaneProcessStatus } from '../services/process';
 import { LogBufferService, BufferedLogEntry } from '../services/logging/buffer';
@@ -142,6 +142,13 @@ class InteractiveMonitor {
   }
 
   constructor(runDir: string, interval: number, logsDir?: string, initialView: View = View.LIST) {
+    const config = loadConfig();
+    
+    // Change current directory to project root for consistent path handling
+    if (config.projectRoot !== process.cwd()) {
+      process.chdir(config.projectRoot);
+    }
+
     this.runDir = runDir;
     this.interval = interval;
     this.view = initialView;
@@ -150,8 +157,7 @@ class InteractiveMonitor {
     if (logsDir) {
       this.logsDir = logsDir;
     } else {
-      const config = loadConfig();
-      this.logsDir = safeJoin(config.logsDir, 'runs');
+      this.logsDir = safeJoin(getLogsDir(config), 'runs');
     }
     
     // Initialize unified log buffer
@@ -1775,15 +1781,20 @@ async function monitor(args: string[]): Promise<void> {
   const interval = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1] || '2') || 2 : 2;
   
   const runDirArg = args.find(arg => !arg.startsWith('--') && args.indexOf(arg) !== intervalIdx + 1);
+  const originalCwd = process.cwd();
   const config = loadConfig();
   
   let runDir = runDirArg;
+  if (runDir && runDir !== 'latest' && !path.isAbsolute(runDir)) {
+    runDir = path.resolve(originalCwd, runDir);
+  }
+
   if (!runDir || runDir === 'latest') {
-    runDir = findLatestRunDir(config.logsDir) || undefined;
+    runDir = findLatestRunDir(getLogsDir(config)) || undefined;
     if (!runDir && !list) throw new Error('No run directories found');
     if (!runDir && list) {
       // Create a dummy runDir if none exists but we want to see the list (dashboard will handle empty list)
-      runDir = path.join(config.logsDir, 'runs', 'empty');
+      runDir = path.join(getLogsDir(config), 'runs', 'empty');
     }
   }
   

package/src/cli/resume.ts

@@ -11,6 +11,7 @@ import { loadState, saveState } from '../utils/state';
 import { LaneState } from '../types';
 import { runDoctor } from '../utils/doctor';
 import { safeJoin } from '../utils/path';
+import { findFlowDir } from '../utils/flow';
 import { 
   EnhancedLogManager, 
   createLogManager, 
@@ -431,9 +432,10 @@ function spawnLaneResume(
     runnerArgs.push('--executor', options.executor);
   }
 
+  const shortLaneName = laneName.substring(0, 10);
   const logManager = createLogManager(laneDir, laneName, options.enhancedLogConfig || {}, (msg) => {
     const formatted = formatMessageForConsole(msg, { 
-      laneLabel: `[${laneName}]`,
+      laneLabel: `[${shortLaneName}]`,
       includeTimestamp: true 
     });
     process.stdout.write(formatted + '\n');
@@ -632,8 +634,19 @@ async function resume(args: string[]): Promise<void> {
 
   const config = loadConfig();
   const logsDir = getLogsDir(config);
+  const originalCwd = process.cwd();
+
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
   
   let runDir = options.runDir;
+  if (runDir && !path.isAbsolute(runDir)) {
+    runDir = path.resolve(originalCwd, runDir);
+  }
+
   if (!runDir) {
     runDir = findLatestRunDir(logsDir);
   }
@@ -645,30 +658,45 @@ async function resume(args: string[]): Promise<void> {
   const allLanes = getAllLaneStatuses(runDir);
   let lanesToResume: LaneInfo[] = [];
 
-  // Check if the lane argument is actually a tasks directory
-  if (options.lane && fs.existsSync(options.lane) && fs.statSync(options.lane).isDirectory()) {
-    const tasksDir = path.resolve(options.lane);
-    lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile && path.resolve(l.state.tasksFile).startsWith(tasksDir));
+  // Check if the lane argument is actually a tasks directory or a flow name
+  if (options.lane) {
+    let tasksDir = '';
+    const lanePathAbs = path.resolve(originalCwd, options.lane);
     
-    if (lanesToResume.length > 0) {
-      logger.info(`📂 Task directory detected: ${options.lane}`);
-      logger.info(`Resuming ${lanesToResume.length} lane(s) from this directory.`);
+    if (fs.existsSync(lanePathAbs) && fs.statSync(lanePathAbs).isDirectory()) {
+      tasksDir = lanePathAbs;
     } else {
-      logger.warn(`No incomplete lanes found using tasks from directory: ${options.lane}`);
-      return;
+      // Try finding in flowsDir
+      const flowsDir = safeJoin(config.projectRoot, config.flowsDir);
+      const foundFlow = findFlowDir(flowsDir, options.lane);
+      if (foundFlow) {
+        tasksDir = foundFlow;
+      }
+    }
+
+    if (tasksDir) {
+      lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile && path.resolve(l.state.tasksFile).startsWith(tasksDir));
+      
+      if (lanesToResume.length > 0) {
+        logger.info(`📂 Flow/Task directory detected: ${options.lane}`);
+        logger.info(`Resuming ${lanesToResume.length} lane(s) from this directory.`);
+      } else {
+        logger.warn(`No incomplete lanes found using tasks from directory: ${options.lane}`);
+        return;
+      }
+    } else {
+      const lane = allLanes.find(l => l.name === options.lane);
+      if (!lane) {
+        throw new Error(`Lane '${options.lane}' not found in run directory.`);
+      }
+      if (!lane.needsResume) {
+        logger.success(`Lane '${options.lane}' is already completed.`);
+        return;
+      }
+      lanesToResume = [lane];
     }
   } else if (options.all) {
     lanesToResume = allLanes.filter(l => l.needsResume && l.state?.tasksFile);
-  } else if (options.lane) {
-    const lane = allLanes.find(l => l.name === options.lane);
-    if (!lane) {
-      throw new Error(`Lane '${options.lane}' not found in run directory.`);
-    }
-    if (!lane.needsResume) {
-      logger.success(`Lane '${options.lane}' is already completed.`);
-      return;
-    }
-    lanesToResume = [lane];
   }
 
   // Check for zombie lanes

package/src/cli/run.ts

@@ -10,6 +10,7 @@ import { getLogsDir, loadConfig } from '../utils/config';
 import { runDoctor, getDoctorStatus } from '../utils/doctor';
 import { areCommandsInstalled, setupCommands } from './setup-commands';
 import { safeJoin } from '../utils/path';
+import { findFlowDir } from '../utils/flow';
 import { loadState } from '../utils/state';
 import { LaneState } from '../types';
 
@@ -191,19 +192,40 @@ async function run(args: string[]): Promise<void> {
   
   const config = loadConfig();
   const logsDir = getLogsDir(config);
+  const originalCwd = process.cwd();
+
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
 
   // Resolve tasks dir:
-  // - Prefer the exact path if it exists relative to cwd
-  // - Otherwise, fall back to projectRoot-relative path for better ergonomics
-  const tasksDir =
-    path.isAbsolute(options.tasksDir)
-      ? options.tasksDir
-      : (fs.existsSync(options.tasksDir)
-        ? path.resolve(process.cwd(), options.tasksDir) // nosemgrep
-        : safeJoin(config.projectRoot, options.tasksDir));
+  // 1. Prefer the exact path if it exists relative to original cwd
+  // 2. Search in flowsDir by name
+  // 3. Fall back to projectRoot-relative tasksDir for backward compatibility
+  let tasksDir = '';
+  if (path.isAbsolute(options.tasksDir)) {
+    tasksDir = options.tasksDir;
+  } else {
+    const relPath = path.resolve(originalCwd, options.tasksDir);
+    if (fs.existsSync(relPath)) {
+      tasksDir = relPath;
+    } else {
+      // Try finding in flowsDir
+      const flowsDir = safeJoin(config.projectRoot, config.flowsDir);
+      const foundFlow = findFlowDir(flowsDir, options.tasksDir);
+      if (foundFlow) {
+        tasksDir = foundFlow;
+      } else {
+        // Fallback to legacy tasksDir
+        tasksDir = safeJoin(config.projectRoot, options.tasksDir);
+      }
+    }
+  }
 
   if (!fs.existsSync(tasksDir)) {
-    throw new Error(`Tasks directory not found: ${tasksDir}`);
+    throw new Error(`Tasks or Flow directory not found: ${options.tasksDir} (resolved to: ${tasksDir})`);
   }
 
   // Check for existing incomplete run and auto-resume

package/src/cli/stop.ts

@@ -86,7 +86,15 @@ async function stop(args: string[]): Promise<void> {
     return;
   }
   
+  const originalCwd = process.cwd();
   const config = loadConfig();
+  
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
+
   const logsDir = getLogsDir(config);
   const runsDir = safeJoin(logsDir, 'runs');
   const runService = new RunService(runsDir);