@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

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';
@@ -56,13 +56,13 @@ const UI = {
 interface LaneWithDeps {
   name: string;
   path: string;
-  dependsOn: string[];
 }
 
 interface MonitorOptions {
   runDir?: string;
   interval: number;
   help: boolean;
+  list: boolean;
 }
 
 function printHelp(): void {
@@ -73,8 +73,14 @@ Interactive lane dashboard to track progress and dependencies.
 
 Options:
   [run-dir]              Run directory to monitor (default: latest)
+  --list, -l             List all runs (multiple flows dashboard)
   --interval <seconds>   Refresh interval (default: 2)
   --help, -h             Show help
+
+Examples:
+  cursorflow monitor             # Monitor latest run
+  cursorflow monitor --list      # Show all runs dashboard
+  cursorflow monitor run-123     # Monitor specific run
   `);
 }
 
@@ -135,16 +141,23 @@ class InteractiveMonitor {
     return process.stdout.rows || 24;
   }
 
-  constructor(runDir: string, interval: number, logsDir?: string) {
+  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;
     
     // Set logs directory for multiple flows discovery
     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
@@ -152,6 +165,21 @@ class InteractiveMonitor {
   }
 
   public async start() {
+    // Non-interactive mode for CI/pipes
+    if (!process.stdout.isTTY || !process.stdin.isTTY) {
+      this.discoverFlows();
+      this.refresh();
+      // Print summary and exit
+      if (this.view === View.FLOWS_DASHBOARD) {
+        console.log(`\nFound ${this.allFlows.length} flows`);
+      } else {
+        console.log(`\nMonitoring run: ${path.basename(this.runDir)}`);
+        const flowSummary = getFlowSummary(this.runDir);
+        console.log(`Status: ${flowSummary.running} running, ${flowSummary.completed} completed, ${flowSummary.failed} failed`);
+      }
+      return;
+    }
+
     this.setupTerminal();
     
     // Start unified log streaming
@@ -999,14 +1027,12 @@ class InteractiveMonitor {
       // Next action
       let nextAction = '-';
       if (status.status === 'completed') {
-        const dependents = this.lanes.filter(l => laneStatuses[l.name]?.dependsOn?.includes(lane.name));
-        nextAction = dependents.length > 0 ? `→ ${dependents.map(d => d.name).join(', ')}` : '✓ Done';
+        nextAction = '✓ Done';
       } else if (status.status === 'waiting') {
         if (status.waitingFor?.length > 0) {
           nextAction = `⏳ ${status.waitingFor.join(', ')}`;
         } else {
-          const missingDeps = status.dependsOn.filter((d: string) => laneStatuses[d]?.status !== 'completed');
-          nextAction = missingDeps.length > 0 ? `⏳ ${missingDeps.join(', ')}` : '⏳ waiting';
+          nextAction = '⏳ waiting';
         }
       } else if (processStatus?.actualStatus === 'running') {
         nextAction = '🚀 working...';
@@ -1063,9 +1089,6 @@ class InteractiveMonitor {
     process.stdout.write(` ${UI.COLORS.dim}Duration${UI.COLORS.reset}   ${this.formatDuration(processStatus?.duration || status.duration)}\n`);
     process.stdout.write(` ${UI.COLORS.dim}Branch${UI.COLORS.reset}     ${status.pipelineBranch}\n`);
     
-    if (status.dependsOn && status.dependsOn.length > 0) {
-      process.stdout.write(` ${UI.COLORS.dim}Depends${UI.COLORS.reset}    ${status.dependsOn.join(', ')}\n`);
-    }
     if (status.waitingFor && status.waitingFor.length > 0) {
       process.stdout.write(` ${UI.COLORS.yellow}Waiting${UI.COLORS.reset}    ${status.waitingFor.join(', ')}\n`);
     }
@@ -1075,7 +1098,7 @@ class InteractiveMonitor {
 
     // Live terminal preview
     this.renderSectionTitle('Live Terminal', 'last 10 lines');
-    const logPath = safeJoin(lane.path, 'terminal.log');
+    const logPath = safeJoin(lane.path, 'terminal-readable.log');
     if (fs.existsSync(logPath)) {
       const content = fs.readFileSync(logPath, 'utf8');
       const lines = content.split('\n').slice(-10);
@@ -1132,7 +1155,6 @@ class InteractiveMonitor {
     const colors: Record<string, string> = {
       user: UI.COLORS.yellow,
       assistant: UI.COLORS.green,
-      reviewer: UI.COLORS.magenta,
       intervention: UI.COLORS.red,
       system: UI.COLORS.cyan,
     };
@@ -1243,9 +1265,9 @@ class InteractiveMonitor {
         const nodeText = `${statusIcon} ${laneName}`;
         process.stdout.write(`   ${statusColor}${nodeText.padEnd(20)}${UI.COLORS.reset}`);
         
-        // Render dependencies
-        if (status?.dependsOn?.length > 0) {
-          process.stdout.write(` ${UI.COLORS.dim}←${UI.COLORS.reset} ${UI.COLORS.yellow}${status.dependsOn.join(', ')}${UI.COLORS.reset}`);
+        // Show task-level dependencies if waiting
+        if (status?.waitingFor?.length > 0) {
+          process.stdout.write(` ${UI.COLORS.dim}←${UI.COLORS.reset} ${UI.COLORS.yellow}${status.waitingFor.join(', ')}${UI.COLORS.reset}`);
         }
         process.stdout.write('\n');
       }
@@ -1256,54 +1278,21 @@ class InteractiveMonitor {
       }
     }
 
-    process.stdout.write(`\n ${UI.COLORS.dim}Lanes wait for dependencies to complete before starting${UI.COLORS.reset}\n`);
+    process.stdout.write(`\n ${UI.COLORS.dim}Tasks can wait for other tasks using task-level dependencies${UI.COLORS.reset}\n`);
     
     this.renderFooter(['[←/Esc] Back']);
   }
   
   /**
-   * Calculate dependency levels for visualization
+   * Calculate levels for visualization (all lanes run in parallel now)
    */
   private calculateDependencyLevels(): string[][] {
-    const levels: string[][] = [];
-    const assigned = new Set<string>();
-    
-    // First, find lanes with no dependencies
-    const noDeps = this.lanes.filter(l => !l.dependsOn || l.dependsOn.length === 0);
-    if (noDeps.length > 0) {
-      levels.push(noDeps.map(l => l.name));
-      noDeps.forEach(l => assigned.add(l.name));
-    }
-    
-    // Then assign remaining lanes by dependency completion
-    let maxIterations = 10;
-    while (assigned.size < this.lanes.length && maxIterations-- > 0) {
-      const nextLevel: string[] = [];
-      
-      for (const lane of this.lanes) {
-        if (assigned.has(lane.name)) continue;
-        
-        // Check if all dependencies are assigned
-        const allDepsAssigned = lane.dependsOn.every(d => assigned.has(d));
-        if (allDepsAssigned) {
-          nextLevel.push(lane.name);
-        }
-      }
-      
-      if (nextLevel.length === 0) {
-        // Remaining lanes have circular deps or missing deps
-        const remaining = this.lanes.filter(l => !assigned.has(l.name)).map(l => l.name);
-        if (remaining.length > 0) {
-          levels.push(remaining);
-        }
-        break;
-      }
-      
-      levels.push(nextLevel);
-      nextLevel.forEach(n => assigned.add(n));
+    // Since lane-level dependencies are removed, all lanes can run in parallel
+    // Group them into a single level
+    if (this.lanes.length === 0) {
+      return [];
     }
-    
-    return levels;
+    return [this.lanes.map(l => l.name)];
   }
 
   private renderTerminal() {
@@ -1326,8 +1315,8 @@ class InteractiveMonitor {
       logLines = this.getReadableLogLines(jsonlPath, lane.name);
       totalLines = logLines.length;
     } else {
-      // Use raw log
-      const logPath = safeJoin(lane.path, 'terminal.log');
+      // Use readable log
+      const logPath = safeJoin(lane.path, 'terminal-readable.log');
       if (fs.existsSync(logPath)) {
         const content = fs.readFileSync(logPath, 'utf8');
         logLines = content.split('\n');
@@ -1689,39 +1678,33 @@ class InteractiveMonitor {
     return fs.readdirSync(lanesDir)
       .filter(d => fs.statSync(safeJoin(lanesDir, d)).isDirectory())
       .map(name => {
-        const config = laneConfigs.find(c => c.name === name);
         return {
           name,
           path: safeJoin(lanesDir, name),
-          dependsOn: config?.dependsOn || [],
         };
       });
   }
 
-  private listLaneFilesFromDir(tasksDir: string): { name: string; dependsOn: string[] }[] {
+  private listLaneFilesFromDir(tasksDir: string): { name: string }[] {
     if (!fs.existsSync(tasksDir)) return [];
     return fs.readdirSync(tasksDir)
       .filter(f => f.endsWith('.json'))
       .map(f => {
         const filePath = safeJoin(tasksDir, f);
         try {
-          const config = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-          return { name: path.basename(f, '.json'), dependsOn: config.dependsOn || [] };
+          return { name: path.basename(f, '.json') };
         } catch {
-          return { name: path.basename(f, '.json'), dependsOn: [] };
+          return { name: path.basename(f, '.json') };
         }
       });
   }
 
-  private getLaneStatus(lanePath: string, laneName: string) {
+  private getLaneStatus(lanePath: string, _laneName: string) {
     const statePath = safeJoin(lanePath, 'state.json');
     const state = loadState<LaneState & { chatId?: string }>(statePath);
     
-    const laneInfo = this.lanes.find(l => l.name === laneName);
-    const dependsOn = state?.dependsOn || laneInfo?.dependsOn || [];
-    
     if (!state) {
-      return { status: 'pending', currentTask: 0, totalTasks: '?', progress: '0%', dependsOn, duration: 0, pipelineBranch: '-', chatId: '-' };
+      return { status: 'pending', currentTask: 0, totalTasks: '?', progress: '0%', duration: 0, pipelineBranch: '-', chatId: '-' };
     }
     
     const progress = state.totalTasks > 0 ? Math.round((state.currentTaskIndex / state.totalTasks) * 100) : 0;
@@ -1737,7 +1720,6 @@ class InteractiveMonitor {
       progress: `${progress}%`,
       pipelineBranch: state.pipelineBranch || '-',
       chatId: state.chatId || '-',
-      dependsOn,
       duration,
       error: state.error,
       pid: state.pid,
@@ -1788,6 +1770,8 @@ function findLatestRunDir(logsDir: string): string | null {
  */
 async function monitor(args: string[]): Promise<void> {
   const help = args.includes('--help') || args.includes('-h');
+  const list = args.includes('--list') || args.includes('-l');
+  
   if (help) {
     printHelp();
     return;
@@ -1797,17 +1781,28 @@ 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;
-    if (!runDir) throw new Error('No run directories found');
+    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(getLogsDir(config), 'runs', 'empty');
+    }
   }
   
-  if (!fs.existsSync(runDir)) throw new Error(`Run directory not found: ${runDir}`);
+  if (runDir && !fs.existsSync(runDir) && !list) {
+    throw new Error(`Run directory not found: ${runDir}`);
+  }
   
-  const monitor = new InteractiveMonitor(runDir, interval);
+  const monitor = new InteractiveMonitor(runDir!, interval, undefined, list ? View.FLOWS_DASHBOARD : View.LIST);
   await monitor.start();
 }
 

package/src/cli/new.ts

@@ -0,0 +1,235 @@
+/**
+ * CursorFlow 'new' command
+ * 
+ * Creates a new Flow with empty Lane files
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as logger from '../utils/logger';
+import { loadConfig, findProjectRoot } from '../utils/config';
+import { FlowMeta, LaneConfig } from '../types/flow';
+import { safeJoin } from '../utils/path';
+import * as git from '../utils/git';
+
+interface NewOptions {
+  flowName: string;
+  lanes: string[];
+  help: boolean;
+}
+
+function printHelp(): void {
+  console.log(`
+\x1b[1mcursorflow new\x1b[0m - Flow와 Lane 생성
+
+\x1b[1m사용법:\x1b[0m
+  cursorflow new <FlowName> --lanes "lane1,lane2,..."
+
+\x1b[1m설명:\x1b[0m
+  새로운 Flow 디렉토리를 생성하고, 지정된 Lane 파일들의 뼈대를 만듭니다.
+  각 Lane에 실제 Task를 추가하려면 'cursorflow add' 명령을 사용하세요.
+
+\x1b[1m옵션:\x1b[0m
+  --lanes <names>    콤마로 구분된 레인 이름 목록 (필수)
+                     예: --lanes "backend,frontend,mobile"
+
+\x1b[1m예시:\x1b[0m
+  # 백엔드와 프론트엔드 2개 레인 생성
+  cursorflow new ShopFeature --lanes "backend,frontend"
+
+  # API, Web, Mobile 3개 레인 생성
+  cursorflow new SearchFeature --lanes "api,web,mobile"
+
+\x1b[1m생성 결과:\x1b[0m
+  _cursorflow/flows/001_ShopFeature/
+  ├── flow.meta.json       # Flow 메타데이터
+  ├── 01-backend.json      # Lane 1 (빈 상태)
+  └── 02-frontend.json     # Lane 2 (빈 상태)
+  `);
+}
+
+function parseArgs(args: string[]): NewOptions {
+  const result: NewOptions = {
+    flowName: '',
+    lanes: [],
+    help: false,
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--lanes' && args[i + 1]) {
+      result.lanes = args[++i].split(',').map(l => l.trim()).filter(l => l);
+    } else if (!arg.startsWith('--') && !result.flowName) {
+      result.flowName = arg;
+    }
+    
+    i++;
+  }
+
+  return result;
+}
+
+/**
+ * Get next flow ID by scanning existing flows
+ */
+function getNextFlowId(flowsDir: string): string {
+  if (!fs.existsSync(flowsDir)) {
+    return '001';
+  }
+
+  const dirs = fs.readdirSync(flowsDir)
+    .filter(name => {
+      const dirPath = safeJoin(flowsDir, name);
+      return fs.statSync(dirPath).isDirectory();
+    })
+    .filter(name => /^\d+_/.test(name));
+
+  if (dirs.length === 0) {
+    return '001';
+  }
+
+  const maxId = Math.max(...dirs.map(name => {
+    const match = name.match(/^(\d+)_/);
+    return match ? parseInt(match[1], 10) : 0;
+  }));
+
+  return String(maxId + 1).padStart(3, '0');
+}
+
+/**
+ * Create flow.meta.json
+ */
+function createFlowMeta(flowId: string, flowName: string, lanes: string[], baseBranch: string): FlowMeta {
+  return {
+    id: flowId,
+    name: flowName,
+    createdAt: new Date().toISOString(),
+    createdBy: 'user',
+    baseBranch,
+    status: 'pending',
+    lanes,
+  };
+}
+
+/**
+ * Create empty lane config
+ */
+function createEmptyLaneConfig(laneName: string): LaneConfig {
+  return {
+    laneName,
+    tasks: [],
+  };
+}
+
+async function newFlow(args: string[]): Promise<void> {
+  const options = parseArgs(args);
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  // Validate inputs
+  if (!options.flowName) {
+    logger.error('Flow 이름이 필요합니다.');
+    console.log('\n사용법: cursorflow new <FlowName> --lanes "lane1,lane2"');
+    console.log('도움말: cursorflow new --help');
+    process.exit(1);
+  }
+
+  if (options.lanes.length === 0) {
+    logger.error('최소 하나의 레인이 필요합니다.');
+    console.log('\n예: cursorflow new ' + options.flowName + ' --lanes "backend,frontend"');
+    process.exit(1);
+  }
+
+  // Validate lane names (alphanumeric, dash, underscore only)
+  const invalidLanes = options.lanes.filter(l => !/^[a-zA-Z0-9_-]+$/.test(l));
+  if (invalidLanes.length > 0) {
+    logger.error(`잘못된 레인 이름: ${invalidLanes.join(', ')}`);
+    console.log('레인 이름은 영문, 숫자, 대시(-), 언더스코어(_)만 사용 가능합니다.');
+    process.exit(1);
+  }
+
+  // Check for duplicate lane names
+  const uniqueLanes = new Set(options.lanes);
+  if (uniqueLanes.size !== options.lanes.length) {
+    logger.error('중복된 레인 이름이 있습니다.');
+    process.exit(1);
+  }
+
+  // Load config and determine paths
+  const projectRoot = findProjectRoot();
+  const config = loadConfig(projectRoot);
+  const flowsDir = safeJoin(projectRoot, config.flowsDir);
+
+  // Ensure flows directory exists
+  if (!fs.existsSync(flowsDir)) {
+    fs.mkdirSync(flowsDir, { recursive: true });
+  }
+
+  // Get next flow ID
+  const flowId = getNextFlowId(flowsDir);
+  const flowDirName = `${flowId}_${options.flowName}`;
+  const flowDir = safeJoin(flowsDir, flowDirName);
+
+  // Check if flow already exists
+  if (fs.existsSync(flowDir)) {
+    logger.error(`Flow 디렉토리가 이미 존재합니다: ${flowDirName}`);
+    process.exit(1);
+  }
+
+  // Get current branch as base branch
+  let baseBranch = 'main';
+  try {
+    baseBranch = git.getCurrentBranch(projectRoot);
+  } catch {
+    logger.warn('현재 브랜치를 가져올 수 없어 main을 기본값으로 사용합니다.');
+  }
+
+  // Create flow directory
+  fs.mkdirSync(flowDir, { recursive: true });
+
+  // Create flow.meta.json
+  const flowMeta = createFlowMeta(flowId, options.flowName, options.lanes, baseBranch);
+  const metaPath = safeJoin(flowDir, 'flow.meta.json');
+  fs.writeFileSync(metaPath, JSON.stringify(flowMeta, null, 2));
+
+  // Create lane files
+  options.lanes.forEach((laneName, index) => {
+    const laneNumber = String(index + 1).padStart(2, '0');
+    const laneFileName = `${laneNumber}-${laneName}.json`;
+    const lanePath = safeJoin(flowDir, laneFileName);
+    
+    const laneConfig = createEmptyLaneConfig(laneName);
+    fs.writeFileSync(lanePath, JSON.stringify(laneConfig, null, 2));
+  });
+
+  // Print success message
+  logger.section(`✅ Flow 생성 완료: ${flowDirName}`);
+  console.log('');
+  console.log(`  📁 ${flowDir}`);
+  console.log(`     ├── flow.meta.json`);
+  options.lanes.forEach((laneName, index) => {
+    const laneNumber = String(index + 1).padStart(2, '0');
+    const isLast = index === options.lanes.length - 1;
+    const prefix = isLast ? '└──' : '├──';
+    console.log(`     ${prefix} ${laneNumber}-${laneName}.json  (빈 상태)`);
+  });
+  
+  console.log('');
+  logger.info('다음 단계: 각 레인에 태스크를 추가하세요.');
+  console.log('');
+  options.lanes.forEach((laneName) => {
+    console.log(`  cursorflow add ${options.flowName} ${laneName} \\`);
+    console.log(`    --task "name=implement|model=sonnet-4.5|prompt=..."`);
+    console.log('');
+  });
+}
+
+export = newFlow;
+