@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/src/cli/clean.ts

@@ -9,6 +9,8 @@ import * as path from 'path';
 import * as logger from '../utils/logger';
 import * as git from '../utils/git';
 import { loadConfig, getLogsDir, getTasksDir } from '../utils/config';
+import { safeJoin } from '../utils/path';
+import { RunService } from '../utils/run-service';
 
 interface CleanOptions {
   type?: string;
@@ -19,6 +21,9 @@ interface CleanOptions {
   help: boolean;
   keepLatest: boolean;
   includeLatest: boolean;
+  run?: string;
+  olderThan?: number;
+  orphaned: boolean;
 }
 
 function printHelp(): void {
@@ -35,6 +40,9 @@ Types:
   all                    Remove all of the above (default)
 
 Options:
+  --run <id>             Clean resources linked to a specific run
+  --older-than <days>    Clean resources older than N days
+  --orphaned             Clean orphaned resources (not linked to any run)
   --dry-run              Show what would be removed without deleting
   --force                Force removal (ignore uncommitted changes)
   --include-latest       Also remove the most recent item (by default, latest is kept)
@@ -44,6 +52,9 @@ Options:
 
 function parseArgs(args: string[]): CleanOptions {
   const includeLatest = args.includes('--include-latest');
+  const runIdx = args.indexOf('--run');
+  const olderThanIdx = args.indexOf('--older-than');
+
   return {
     type: args.find(a => ['branches', 'worktrees', 'logs', 'tasks', 'all'].includes(a)),
     pattern: null,
@@ -53,6 +64,9 @@ function parseArgs(args: string[]): CleanOptions {
     help: args.includes('--help') || args.includes('-h'),
     keepLatest: !includeLatest, // Default: keep latest, unless --include-latest is specified
     includeLatest,
+    run: runIdx >= 0 ? args[runIdx + 1] : undefined,
+    olderThan: olderThanIdx >= 0 ? parseInt(args[olderThanIdx + 1] || '0') : undefined,
+    orphaned: args.includes('--orphaned'),
   };
 }
 
@@ -78,9 +92,33 @@ async function clean(args: string[]): Promise<void> {
 
   const config = loadConfig();
   const repoRoot = git.getRepoRoot();
+  const logsDir = getLogsDir(config);
+  const runsDir = safeJoin(logsDir, 'runs');
+  const runService = new RunService(runsDir);
 
   logger.section('🧹 Cleaning CursorFlow Resources');
 
+  // Handle specific run cleanup
+  if (options.run) {
+    await cleanRunResources(runService, options.run, repoRoot, options);
+    logger.success('\n✨ Run cleaning complete!');
+    return;
+  }
+
+  // Handle older-than cleanup
+  if (options.olderThan !== undefined) {
+    await cleanOlderRuns(runService, options.olderThan, repoRoot, options);
+    logger.success(`\n✨ Older than ${options.olderThan} days cleaning complete!`);
+    return;
+  }
+
+  // Handle orphaned cleanup
+  if (options.orphaned) {
+    await cleanOrphanedResources(runService, config, repoRoot, options);
+    logger.success('\n✨ Orphaned resources cleaning complete!');
+    return;
+  }
+
   const type = options.type || 'all';
 
   if (type === 'all') {
@@ -105,7 +143,7 @@ async function cleanWorktrees(config: any, repoRoot: string, options: CleanOptio
   logger.info('\nChecking worktrees...');
   const worktrees = git.listWorktrees(repoRoot);
   
-  const worktreeRoot = path.join(repoRoot, config.worktreeRoot || '_cursorflow/worktrees');
+  const worktreeRoot = safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/worktrees');
   let toRemove = worktrees.filter(wt => {
     // Skip main worktree
     if (wt.path === repoRoot) return false;
@@ -226,9 +264,9 @@ async function cleanLogs(config: any, options: CleanOptions) {
     const entries = fs.readdirSync(logsDir, { withFileTypes: true });
     let items = entries.map(entry => ({
       name: entry.name,
-      path: path.join(logsDir, entry.name),
+      path: safeJoin(logsDir, entry.name),
       isDir: entry.isDirectory(),
-      mtime: getModTime(path.join(logsDir, entry.name))
+      mtime: getModTime(safeJoin(logsDir, entry.name))
     }));
 
     if (items.length <= 1) {
@@ -288,9 +326,9 @@ async function cleanTasks(config: any, options: CleanOptions) {
       .filter(entry => entry.name !== 'example')
       .map(entry => ({
         name: entry.name,
-        path: path.join(tasksDir, entry.name),
+        path: safeJoin(tasksDir, entry.name),
         isDir: entry.isDirectory(),
-        mtime: getModTime(path.join(tasksDir, entry.name))
+        mtime: getModTime(safeJoin(tasksDir, entry.name))
       }));
 
     if (items.length <= 1) {
@@ -325,7 +363,7 @@ async function cleanTasks(config: any, options: CleanOptions) {
         const entries = fs.readdirSync(tasksDir, { withFileTypes: true });
         for (const entry of entries) {
           if (entry.name === 'example') continue;
-          const itemPath = path.join(tasksDir, entry.name);
+          const itemPath = safeJoin(tasksDir, entry.name);
           logger.info(`  Removing task: ${entry.name}...`);
           fs.rmSync(itemPath, { recursive: true, force: true });
         }
@@ -337,4 +375,147 @@ async function cleanTasks(config: any, options: CleanOptions) {
   }
 }
 
+async function cleanRunResources(runService: RunService, runId: string, repoRoot: string, options: CleanOptions) {
+  const run = runService.getRunInfo(runId);
+  if (!run) {
+    logger.warn(`Run not found: ${runId}`);
+    return;
+  }
+
+  logger.info(`\nCleaning resources for run: ${runId} (${run.taskName})`);
+
+  // Clean branches
+  if (run.branches.length > 0) {
+    logger.info('  Cleaning branches...');
+    for (const branch of run.branches) {
+      if (options.dryRun) {
+        logger.info(`    [DRY RUN] Would delete branch: ${branch}`);
+      } else {
+        try {
+          git.deleteBranch(branch, { cwd: repoRoot, force: true });
+          logger.info(`    Deleted branch: ${branch}`);
+        } catch (e: any) {
+          logger.warn(`    Could not delete branch ${branch}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Clean worktrees
+  if (run.worktrees.length > 0) {
+    logger.info('  Cleaning worktrees...');
+    for (const wtPath of run.worktrees) {
+      if (options.dryRun) {
+        logger.info(`    [DRY RUN] Would remove worktree: ${wtPath}`);
+      } else {
+        try {
+          git.removeWorktree(wtPath, { cwd: repoRoot, force: true });
+          if (fs.existsSync(wtPath)) {
+            fs.rmSync(wtPath, { recursive: true, force: true });
+          }
+          logger.info(`    Removed worktree: ${wtPath}`);
+        } catch (e: any) {
+          logger.warn(`    Could not remove worktree ${wtPath}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Delete run directory
+  if (options.dryRun) {
+    logger.info(`  [DRY RUN] Would delete run directory: ${run.path}`);
+  } else {
+    try {
+      runService.deleteRun(runId, { force: options.force });
+      logger.info(`  Deleted run directory: ${run.path}`);
+    } catch (e: any) {
+      logger.error(`  Failed to delete run ${runId}: ${e.message}`);
+    }
+  }
+}
+
+async function cleanOlderRuns(runService: RunService, days: number, repoRoot: string, options: CleanOptions) {
+  const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
+  const runs = runService.listRuns();
+  const olderRuns = runs.filter(run => run.startTime < cutoff);
+
+  if (olderRuns.length === 0) {
+    logger.info(`No runs found older than ${days} days.`);
+    return;
+  }
+
+  logger.info(`Found ${olderRuns.length} runs older than ${days} days.`);
+  for (const run of olderRuns) {
+    await cleanRunResources(runService, run.id, repoRoot, options);
+  }
+}
+
+async function cleanOrphanedResources(runService: RunService, config: any, repoRoot: string, options: CleanOptions) {
+  const runs = runService.listRuns();
+  const linkedWorktrees = new Set(runs.flatMap(r => r.worktrees));
+  const linkedBranches = new Set(runs.flatMap(r => r.branches));
+
+  // Clean orphaned worktrees
+  logger.info('\nChecking for orphaned worktrees...');
+  const worktrees = git.listWorktrees(repoRoot);
+  const worktreeRoot = safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/worktrees');
+  
+  const orphanedWorktrees = worktrees.filter(wt => {
+    if (wt.path === repoRoot) return false;
+    const isInsideRoot = wt.path.startsWith(worktreeRoot);
+    const hasPrefix = path.basename(wt.path).startsWith(config.worktreePrefix || 'cursorflow-');
+    return (isInsideRoot || hasPrefix) && !linkedWorktrees.has(wt.path);
+  });
+
+  if (orphanedWorktrees.length === 0) {
+    logger.info('  No orphaned worktrees found.');
+  } else {
+    for (const wt of orphanedWorktrees) {
+      if (options.dryRun) {
+        logger.info(`  [DRY RUN] Would remove orphaned worktree: ${wt.path}`);
+      } else {
+        try {
+          git.removeWorktree(wt.path, { cwd: repoRoot, force: true });
+          if (fs.existsSync(wt.path)) {
+            fs.rmSync(wt.path, { recursive: true, force: true });
+          }
+          logger.info(`  Removed orphaned worktree: ${wt.path}`);
+        } catch (e: any) {
+          logger.warn(`  Could not remove orphaned worktree ${wt.path}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Clean orphaned branches
+  logger.info('\nChecking for orphaned branches...');
+  const result = git.runGitResult(['branch', '--list'], { cwd: repoRoot });
+  if (result.success) {
+    const branches = result.stdout
+      .split('\n')
+      .map(b => b.replace(/\*/g, '').trim())
+      .filter(b => b && b !== 'main' && b !== 'master');
+
+    const prefix = config.branchPrefix || 'feature/';
+    const orphanedBranches = branches.filter(b => b.startsWith(prefix) && !linkedBranches.has(b));
+
+    if (orphanedBranches.length === 0) {
+      logger.info('  No orphaned branches found.');
+    } else {
+      for (const branch of orphanedBranches) {
+        if (options.dryRun) {
+          logger.info(`  [DRY RUN] Would delete orphaned branch: ${branch}`);
+        } else {
+          try {
+            git.deleteBranch(branch, { cwd: repoRoot, force: true });
+            logger.info(`  Deleted orphaned branch: ${branch}`);
+          } catch (e: any) {
+            logger.warn(`  Could not delete orphaned branch ${branch}: ${e.message}`);
+          }
+        }
+      }
+    }
+  }
+}
+
 export = clean;

package/src/cli/index.ts

@@ -21,6 +21,9 @@ const COMMANDS: Record<string, CommandFn> = {
   signal: require('./signal'),
   models: require('./models'),
   logs: require('./logs'),
+  runs: require('./runs'),
+  tasks: require('./tasks'),
+  stop: require('./stop'),
   setup: require('./setup-commands').main,
   'setup-commands': require('./setup-commands').main,
 };
@@ -34,10 +37,14 @@ function printHelp(): void {
 
 \x1b[1mCOMMANDS\x1b[0m
   \x1b[33minit\x1b[0m [options]              Initialize CursorFlow in project
+  \x1b[33msetup\x1b[0m [options]             Install Cursor IDE commands
   \x1b[33mprepare\x1b[0m <feature> [opts]    Prepare task directory and JSON files
   \x1b[33mrun\x1b[0m <tasks-dir> [options]   Run orchestration (DAG-based)
   \x1b[33mmonitor\x1b[0m [run-dir] [options] \x1b[36mInteractive\x1b[0m lane dashboard
-  \x1b[33mclean\x1b[0m <type> [options]      Clean branches/worktrees/logs
+  \x1b[33mtasks\x1b[0m [name] [options]      Browse and validate prepared tasks
+  \x1b[33mruns\x1b[0m [run-id] [options]     List and view run details
+  \x1b[33mstop\x1b[0m [run-id] [options]     Stop running workflows
+  \x1b[33mclean\x1b[0m <type> [options]      Clean branches/worktrees/logs/tasks
   \x1b[33mresume\x1b[0m [lane] [options]     Resume lane(s) - use --all for batch resume
   \x1b[33mdoctor\x1b[0m [options]            Check environment and preflight
   \x1b[33msignal\x1b[0m <lane> <msg>         Directly intervene in a running lane
@@ -54,6 +61,10 @@ function printHelp(): void {
   $ \x1b[32mcursorflow prepare NewFeature --lanes 3\x1b[0m
   $ \x1b[32mcursorflow run _cursorflow/tasks/MyFeature/\x1b[0m
   $ \x1b[32mcursorflow monitor latest\x1b[0m
+  $ \x1b[32mcursorflow logs --all --follow\x1b[0m
+  $ \x1b[32mcursorflow runs --running\x1b[0m
+  $ \x1b[32mcursorflow resume --all\x1b[0m
+  $ \x1b[32mcursorflow doctor\x1b[0m
   $ \x1b[32mcursorflow models\x1b[0m
 
 \x1b[1mDOCUMENTATION\x1b[0m

package/src/cli/init.ts

@@ -9,6 +9,7 @@ import * as path from 'path';
 import * as logger from '../utils/logger';
 import { findProjectRoot, createDefaultConfig, CursorFlowConfig } from '../utils/config';
 import { setupCommands } from './setup-commands';
+import { safeJoin } from '../utils/path';
 
 interface InitOptions {
   example: boolean;
@@ -84,8 +85,8 @@ Examples:
 }
 
 function createDirectories(projectRoot: string, config: CursorFlowConfig): void {
-  const tasksDir = path.join(projectRoot, config.tasksDir);
-  const logsDir = path.join(projectRoot, config.logsDir);
+  const tasksDir = safeJoin(projectRoot, config.tasksDir);
+  const logsDir = safeJoin(projectRoot, config.logsDir);
   
   if (!fs.existsSync(tasksDir)) {
     fs.mkdirSync(tasksDir, { recursive: true });
@@ -103,7 +104,7 @@ function createDirectories(projectRoot: string, config: CursorFlowConfig): void
 }
 
 function createExampleTasks(projectRoot: string, config: CursorFlowConfig): void {
-  const exampleDir = path.join(projectRoot, config.tasksDir, 'example');
+  const exampleDir = safeJoin(projectRoot, config.tasksDir, 'example');
   
   if (!fs.existsSync(exampleDir)) {
     fs.mkdirSync(exampleDir, { recursive: true });
@@ -111,7 +112,7 @@ function createExampleTasks(projectRoot: string, config: CursorFlowConfig): void
   
   const exampleTask = {
     repository: "https://github.com/your-org/your-repo",
-    baseBranch: "main",
+    // baseBranch is auto-detected from current branch at runtime
     branchPrefix: "cursorflow/example-",
     executor: "cursor-agent",
     autoCreatePr: false,
@@ -134,13 +135,13 @@ Create a simple hello.txt file with a greeting message.
     ]
   };
   
-  const taskPath = path.join(exampleDir, '01-hello.json');
+  const taskPath = safeJoin(exampleDir, '01-hello.json');
   fs.writeFileSync(taskPath, JSON.stringify(exampleTask, null, 2) + '\n', 'utf8');
   
   logger.success(`Created example task: ${path.relative(projectRoot, taskPath)}`);
   
   // Create README
-  const readmePath = path.join(exampleDir, 'README.md');
+  const readmePath = safeJoin(exampleDir, 'README.md');
   const readme = `# Example Task
 
 This is an example CursorFlow task to help you get started.
@@ -172,7 +173,7 @@ cursorflow run ${config.tasksDir}/example/
  * Add _cursorflow to .gitignore
  */
 function updateGitignore(projectRoot: string): void {
-  const gitignorePath = path.join(projectRoot, '.gitignore');
+  const gitignorePath = safeJoin(projectRoot, '.gitignore');
   const entry = '_cursorflow/';
   
   // Try to read existing .gitignore (avoid TOCTOU by reading directly)