@litmers/cursorflow-orchestrator 0.1.37 → 0.1.40

package/src/types/task.ts

@@ -17,6 +17,7 @@ export interface Task {
 
 export interface RunnerConfig {
   tasks: Task[];
+  dependsOn?: string[];
   pipelineBranch?: string;
   worktreeDir?: string;
   branchPrefix?: string;
@@ -25,21 +26,15 @@ export interface RunnerConfig {
   model?: string;
   dependencyPolicy: DependencyPolicy;
   /** Output format for cursor-agent (default: 'json') */
-  agentOutputFormat?: 'json' | 'plain';
+  agentOutputFormat?: 'json' | 'plain' | 'stream-json';
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
   timeout?: number;
   /** 
    * Enable intervention feature (stdin piping for message injection).
    * Warning: May cause stdout buffering issues on some systems.
-   * Default: false
+   * Default: true
    */
   enableIntervention?: boolean;
-  /**
-   * Disable Git operations (worktree, branch, push, commit).
-   * Useful for testing or environments without Git remote.
-   * Default: false
-   */
-  noGit?: boolean;
   /**
    * Enable verbose Git logging.
    * Default: false

package/src/utils/config.ts

@@ -60,6 +60,9 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     allowDependencyChange: false,
     lockfileReadOnly: true,
     
+    // Intervention
+    enableIntervention: true,
+    
     // Lane defaults
     defaultLaneConfig: {
       devPort: 3001,
@@ -193,6 +196,9 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   allowDependencyChange: false,
   lockfileReadOnly: true,
   
+  // Intervention - allows sending messages to running agents
+  enableIntervention: true,
+  
   // Lane configuration
   defaultLaneConfig: {
     devPort: 3001,           // 3000 + laneNumber

package/src/utils/doctor.ts

@@ -618,7 +618,7 @@ function validateBranchNames(
 /**
  * Status file to track when doctor was last run successfully.
  */
-const DOCTOR_STATUS_FILE = '.cursorflow/doctor-status.json';
+const DOCTOR_STATUS_FILE = '_cursorflow/doctor-status.json';
 
 export function saveDoctorStatus(repoRoot: string, report: DoctorReport): void {
   const statusPath = safeJoin(repoRoot, DOCTOR_STATUS_FILE);
@@ -720,6 +720,10 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
     }
   }
 
+  const repoRoot = resolveRepoRoot(cwd) || undefined;
+  context.repoRoot = repoRoot;
+  const gitCwd = repoRoot || cwd;
+
   // 1) Git repository checks
   if (!isInsideGitWorktree(cwd)) {
     addIssue(issues, {
@@ -736,10 +740,6 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
     return { ok: false, issues, context };
   }
 
-  const repoRoot = resolveRepoRoot(cwd) || undefined;
-  context.repoRoot = repoRoot;
-  const gitCwd = repoRoot || cwd;
-
   if (!hasAtLeastOneCommit(gitCwd)) {
     addIssue(issues, {
       id: 'git.no_commits',

package/src/utils/enhanced-logger.ts

@@ -131,13 +131,13 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Get lane-task label like [L1-T2-lanename10]
+   * Get lane-task label like [1-1-lanename10]
    */
   private getLaneTaskLabel(): string {
     const laneNum = (this.session.laneIndex ?? 0) + 1;
     const taskNum = (this.session.taskIndex ?? 0) + 1;
     const shortLaneName = this.session.laneName.substring(0, 10);
-    return `L${laneNum}-T${taskNum}-${shortLaneName}`;
+    return `${laneNum}-${taskNum}-${shortLaneName}`.substring(0, 18).padEnd(18);
   }
 
   /**
@@ -267,7 +267,7 @@ export class EnhancedLogManager {
    */
   public writeReadableMessage(msg: ParsedMessage): void {
     // Use formatMessageForConsole for consistent formatting
-    // Use short lane-task label like [L01-T02]
+    // Use short lane-task label like [1-1-lanename10]
     const formatted = formatMessageForConsole(msg, {
       laneLabel: `[${this.getLaneTaskLabel()}]`,
       includeTimestamp: false, // We'll add our own short timestamp

package/src/utils/flow.ts

@@ -40,3 +40,4 @@ export function findFlowDir(flowsDir: string, flowName: string): string | null {
 }
 
 
+

package/src/utils/git.ts

@@ -156,6 +156,7 @@ export function runGit(args: string[], options: GitRunOptions = {}): string {
       cwd: cwd || process.cwd(),
       encoding: 'utf8',
       stdio: stdioMode as any,
+      timeout: 30000, // 30 second timeout for all git operations
     });
     
     if (result.error) {
@@ -206,6 +207,7 @@ export function runGitResult(args: string[], options: GitRunOptions = {}): GitRe
     cwd: cwd || process.cwd(),
     encoding: 'utf8',
     stdio: 'pipe',
+    timeout: 30000, // 30 second timeout
   });
   
   const gitResult = {
@@ -263,7 +265,7 @@ export function isGitRepo(cwd?: string): boolean {
 }
 
 /**
- * Check if worktree exists
+ * Check if worktree exists in Git's worktree list
  */
 export function worktreeExists(worktreePath: string, cwd?: string): boolean {
   const result = runGitResult(['worktree', 'list'], { cwd });
@@ -272,6 +274,64 @@ export function worktreeExists(worktreePath: string, cwd?: string): boolean {
   return result.stdout.includes(worktreePath);
 }
 
+/**
+ * Check if a directory is a valid Git worktree (not just a regular directory)
+ * This prevents accidental checkout in the main repository when the worktree
+ * directory exists but is not properly registered as a worktree.
+ */
+export function isValidWorktree(dirPath: string): boolean {
+  // 1. Directory must exist
+  if (!fs.existsSync(dirPath)) {
+    return false;
+  }
+  
+  // 2. Check if Git recognizes this as a worktree by checking .git file
+  // In a worktree, .git is a file (not a directory) pointing to the main repo's .git/worktrees/
+  const dotGitPath = path.join(dirPath, '.git');
+  if (!fs.existsSync(dotGitPath)) {
+    return false;
+  }
+  
+  try {
+    const stat = fs.statSync(dotGitPath);
+    
+    // In worktrees, .git is a FILE containing "gitdir: /path/to/.git/worktrees/..."
+    // In the main repo, .git is a DIRECTORY
+    if (stat.isDirectory()) {
+      // This is the main repository, not a worktree
+      return false;
+    }
+    
+    // Read the .git file to verify it points to a valid worktree
+    const content = fs.readFileSync(dotGitPath, 'utf8').trim();
+    if (!content.startsWith('gitdir:')) {
+      return false;
+    }
+    
+    // Verify the gitdir path exists
+    const gitdirPath = content.replace('gitdir:', '').trim();
+    return fs.existsSync(gitdirPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Remove a directory that was supposed to be a worktree but isn't valid
+ * Used to clean up orphaned/corrupted worktree directories before recreation
+ */
+export function cleanupInvalidWorktreeDir(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) return;
+  
+  // Only remove if it's NOT a valid worktree (safety check)
+  if (isValidWorktree(dirPath)) {
+    throw new Error(`Cannot cleanup: ${dirPath} is a valid worktree`);
+  }
+  
+  // Remove the directory recursively
+  fs.rmSync(dirPath, { recursive: true, force: true });
+}
+
 /**
  * Create worktree
  */

package/src/utils/health.ts

@@ -455,14 +455,6 @@ export async function preflightCheck(options: {
     blockers.push(`Git: ${gitHealth.message}`);
   }
 
-  // Check authentication
-  if (options.requireAuth !== false) {
-    const authHealth = await checkAuthHealth();
-    if (!authHealth.ok) {
-      blockers.push(`Authentication: ${authHealth.message}`);
-    }
-  }
-
   // Check Git remote (warning only unless required)
   const remoteHealth = await checkGitRemoteHealth(options.cwd);
   if (!remoteHealth.ok) {
@@ -473,6 +465,21 @@ export async function preflightCheck(options: {
     }
   }
 
+  // Check worktrees
+  const worktreeHealth = await checkWorktrees(options.cwd);
+  if (!worktreeHealth.ok) {
+    warnings.push(`Worktrees: ${worktreeHealth.message}`);
+    recommendations.push('Run `cursorflow clean worktrees` to clean up orphaned worktrees');
+  }
+
+  // Check authentication
+  if (options.requireAuth !== false) {
+    const authHealth = await checkAuthHealth();
+    if (!authHealth.ok) {
+      blockers.push(`Authentication: ${authHealth.message}`);
+    }
+  }
+
   // Check disk space
   const diskHealth = await checkDiskSpace();
   if (!diskHealth.ok) {
@@ -486,13 +493,6 @@ export async function preflightCheck(options: {
     recommendations.push('Run `cursorflow clean locks` to remove stale locks');
   }
 
-  // Check worktrees
-  const worktreeHealth = await checkWorktrees(options.cwd);
-  if (!worktreeHealth.ok) {
-    warnings.push(`Worktrees: ${worktreeHealth.message}`);
-    recommendations.push('Run `cursorflow clean worktrees` to clean up orphaned worktrees');
-  }
-
   // Check system resources
   const resourceHealth = await checkSystemResources();
   if (!resourceHealth.ok) {

package/src/utils/log-formatter.ts

@@ -7,7 +7,7 @@
  * - Box format only for: user, assistant, system, result
  * - Compact format for: tool, tool_result, thinking (gray/dim)
  * - Tool names simplified: ShellToolCall → Shell
- * - Lane labels max 16 chars: [01-types-tests]
+ * - Lane labels fixed 20 chars: [1-1-backend       ]
  */
 
 import { COLORS } from './log-constants';
@@ -44,12 +44,17 @@ export function formatMessageForConsole(
   const ts = includeTimestamp ? new Date(msg.timestamp).toLocaleTimeString('en-US', { hour12: false }) : '';
   const tsPrefix = ts ? `${COLORS.gray}[${ts}]${COLORS.reset} ` : '';
   
-  // Handle context (e.g. from logger.info) - max 16 chars
-  const effectiveLaneLabel = laneLabel || (context ? `[${context}]` : '');
-  const truncatedLabel = effectiveLaneLabel.length > 16 
-    ? effectiveLaneLabel.substring(0, 16) 
-    : effectiveLaneLabel;
-  const labelPrefix = truncatedLabel ? `${COLORS.magenta}${truncatedLabel.padEnd(16)}${COLORS.reset} ` : '';
+  // Handle context (e.g. from logger.info) - max 18 chars inside brackets
+  // Format: [1-1-lanename1234] padded to fixed width 20 (including brackets)
+  let effectiveLaneLabel = laneLabel || (context ? `[${context.substring(0, 18).padEnd(18)}]` : '');
+  
+  // Smart truncation: ensure it always ends with ]
+  if (effectiveLaneLabel.length > 20) {
+    effectiveLaneLabel = effectiveLaneLabel.substring(0, 19) + ']';
+  }
+  
+  // Fixed width 20 chars for consistent alignment
+  const labelPrefix = effectiveLaneLabel ? `${COLORS.magenta}${effectiveLaneLabel.padEnd(20)}${COLORS.reset} ` : '';
   
   let typePrefix = '';
   let content = msg.content;
@@ -155,6 +160,44 @@ export function formatMessageForConsole(
   
   if (!typePrefix) return `${tsPrefix}${labelPrefix}${content}`;
 
+  // Avoid double prefixes (e.g. INFO INFO)
+  const plainTypePrefix = stripAnsi(typePrefix).replace(/[^\x00-\x7F]/g, '').trim(); // "INFO", "DONE", etc.
+  const plainContent = stripAnsi(content);
+  if (plainContent.includes(` ${plainTypePrefix} `) || plainContent.startsWith(`${plainTypePrefix} `)) {
+    // If content already has the prefix, try to strip it from content or just use content as is
+    // For simplicity, if it's already there, we can just skip adding our typePrefix
+    // but we still want the colors. This is tricky. 
+    // Usually it's better to just return the content if it looks already formatted.
+  }
+
+  // A better way: if content starts with an emoji that matches our type, skip typePrefix
+  const emojiMap: Record<string, string> = {
+    'info': 'ℹ️',
+    'success': '✅',
+    'result': '✅',
+    'warn': '⚠️',
+    'error': '❌',
+    'tool': '🔧',
+    'thinking': '🤔',
+    'user': '🧑',
+    'assistant': '🤖'
+  };
+  
+  const targetEmoji = emojiMap[msg.type];
+  if (targetEmoji && plainContent.trim().startsWith(targetEmoji)) {
+    return `${tsPrefix}${labelPrefix}${content}`;
+  }
+
+  // Handle separator lines - if content is just a repeat of ━ or ─, extend it
+  const separatorMatch = content.match(/^([━─=]+)$/);
+  if (separatorMatch) {
+    const char = separatorMatch[1]![0]!;
+    // Use a fixed width for now (80 is a good standard)
+    // In a real terminal we could use process.stdout.columns
+    const targetWidth = 80;
+    content = char.repeat(targetWidth);
+  }
+
   // Compact format (single line)
   if (!useBox) {
     return `${tsPrefix}${labelPrefix}${typePrefix.padEnd(12)} ${content}`;
@@ -169,7 +212,7 @@ export function formatMessageForConsole(
   const emojiCount = (strippedPrefix.match(/[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]|[\u{1F600}-\u{1F64F}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2300}-\u{23FF}]|[\u{2B50}-\u{2B55}]|[\u{231A}-\u{231B}]|[\u{23E9}-\u{23F3}]|[\u{23F8}-\u{23FA}]|✅|❌|⚙️|ℹ️|⚠️|🔧|📄|🤔|🧑|🤖/gu) || []).length;
   const visualWidth = strippedPrefix.length + emojiCount; // emoji adds 1 extra width
   
-  const boxWidth = 60;
+  const boxWidth = 80;
   const header = `${typePrefix}┌${'─'.repeat(boxWidth)}`;
   let result = `${fullPrefix}${header}\n`;
   

package/src/utils/logger.ts

@@ -144,9 +144,9 @@ export function withContext(context: string) {
  */
 export function section(message: string): void {
   console.log('');
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
   console.log(`${COLORS.cyan}  ${message}${COLORS.reset}`);
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
   console.log('');
 }
 

package/commands/cursorflow-add.md

@@ -1,159 +0,0 @@
-# cursorflow add
-
-Lane에 Task를 추가합니다.
-
-## 사용법
-
-```bash
-cursorflow add <FlowName> <LaneName> --task "name=...|model=...|prompt=..." [--after ...]
-```
-
-## 설명
-
-지정된 Flow의 Lane에 Task를 추가합니다.
-`--task` 옵션은 여러 번 사용하여 여러 태스크를 순차적으로 추가할 수 있습니다.
-
-## --task 형식
-
-```
-"name=<이름>|model=<모델>|prompt=<프롬프트>"
-```
-
-### 필수 필드
-
-| 필드 | 설명 | 예시 |
-|------|------|------|
-| `name` | 태스크 이름 (영문, 숫자, -, _) | `name=implement` |
-| `prompt` | 태스크 프롬프트/지시사항 | `prompt=API 구현` |
-
-### 선택 필드
-
-| 필드 | 설명 | 예시 |
-|------|------|------|
-| `model` | AI 모델 (생략 시 기본 모델 사용) | `model=<your-model>` |
-
-기본 모델 설정: `cursorflow config defaultModel <model-name>`
-
-## --after 형식 (의존성 설정)
-
-첫 번째 태스크가 시작되기 전에 완료되어야 할 태스크를 지정합니다.
-
-| 형식 | 설명 |
-|------|------|
-| `"lane"` | 해당 레인의 **마지막 태스크** 완료 후 시작 |
-| `"lane:task"` | 특정 태스크 완료 후 시작 |
-| `"a:t1, b:t2"` | **여러 태스크가 모두 완료**된 후 시작 |
-
-## 예시
-
-### 기본 사용: 단일 태스크 추가 (기본 모델 사용)
-
-```bash
-cursorflow add SearchFeature api \
-  --task "name=implement|prompt=검색 API 구현"
-```
-
-### 여러 태스크 추가
-
-```bash
-cursorflow add SearchFeature api \
-  --task "name=plan|prompt=API 설계" \
-  --task "name=implement|prompt=검색 API 구현" \
-  --task "name=test|prompt=테스트 코드 작성"
-```
-
-### 의존성 설정: 특정 태스크 완료 후 시작
-
-```bash
-# api 레인의 implement 태스크 완료 후 시작
-cursorflow add SearchFeature web \
-  --task "name=ui|prompt=검색 UI 구현" \
-  --after "api:implement"
-```
-
-### 의존성 설정: 레인 전체 완료 후 시작
-
-```bash
-# api 레인의 마지막 태스크 완료 후 시작
-cursorflow add SearchFeature web \
-  --task "name=ui|prompt=검색 UI 구현" \
-  --after "api"
-```
-
-### 다중 의존성: 여러 태스크 완료 후 시작
-
-```bash
-# web과 mobile 모두 완료된 후 시작
-cursorflow add SearchFeature e2e \
-  --task "name=verify|prompt=E2E 테스트" \
-  --after "web:ui, mobile:app"
-```
-
-## 출력 예시
-
-```
-✅ 3개 태스크 추가 완료
-
-  📄 01-api.json
-
-  ├── plan (<default-model>)
-  ├── implement (<default-model>)
-  └── test (<default-model>)
-
-전체 태스크 목록:
-  1. plan (new)
-  2. implement (new)
-  3. test (new)
-
-다음 단계:
-  cursorflow run SearchFeature    # Flow 실행
-  cursorflow doctor SearchFeature # 설정 검증
-```
-
-## 생성되는 Lane 파일 구조
-
-```json
-{
-  "laneName": "api",
-  "tasks": [
-    {
-      "name": "plan",
-      "model": "<your-model>",
-      "prompt": "API 설계"
-    },
-    {
-      "name": "implement",
-      "model": "<your-model>",
-      "prompt": "검색 API 구현"
-    },
-    {
-      "name": "test",
-      "model": "<your-model>",
-      "prompt": "테스트 코드 작성"
-    }
-  ]
-}
-```
-
-### 의존성이 있는 경우
-
-```json
-{
-  "laneName": "web",
-  "tasks": [
-    {
-      "name": "ui",
-      "model": "<your-model>",
-      "prompt": "검색 UI 구현",
-      "dependsOn": ["01-api:implement"]
-    }
-  ]
-}
-```
-
-## 관련 명령어
-
-- [cursorflow new](cursorflow-new.md) - Flow와 Lane 생성
-- [cursorflow run](cursorflow-run.md) - Flow 실행
-- [cursorflow doctor](cursorflow-doctor.md) - 설정 검증
-

package/commands/cursorflow-clean.md

@@ -1,84 +0,0 @@
-# CursorFlow Clean
-
-## Overview
-Clean up temporary resources created by CursorFlow, including Git worktrees, feature branches, log files, and task definitions.
-
-## Usage
-
-```bash
-cursorflow clean <type> [options]
-```
-
-## Clean Types
-
-| Type | Description |
-|------|------|
-| `branches` | Remove local feature branches created by CursorFlow |
-| `worktrees` | Remove temporary Git worktrees |
-| `logs` | Clear all run and terminal logs |
-| `tasks` | Remove task definition directories (keeps `example/`) |
-| `all` | Clean everything (branches, worktrees, logs, and tasks) |
-
-## Options
-
-| Option | Description |
-|------|------|
-| `--run <id>` | Clean resources linked to a specific run |
-| `--older-than <time>` | Clean resources older than a specific time (e.g., `24h`, `7d`) |
-| `--orphaned` | Clean orphaned resources (worktrees without runs, etc.) |
-| `--dry-run` | Show what would be removed without actually deleting anything |
-| `--force` | Force removal (ignore uncommitted changes in worktrees) |
-| `--include-latest` | Also remove the most recent item (by default, latest is kept) |
-| `--help`, `-h` | Show help |
-
-## Examples
-
-### Review before deleting (latest is kept by default)
-```bash
-cursorflow clean all --dry-run
-```
-
-### Clean only worktrees (keeps the latest worktree)
-```bash
-cursorflow clean worktrees
-```
-
-### Force clean everything including the latest
-```bash
-cursorflow clean all --force --include-latest
-```
-
-### Remove all worktrees including the latest
-```bash
-cursorflow clean worktrees --include-latest
-```
-
-### Clean resources for a specific run
-```bash
-cursorflow clean all --run run-1734873132
-```
-
-### Clean logs and tasks older than 7 days
-```bash
-cursorflow clean logs --older-than 7d
-cursorflow clean tasks --older-than 7d
-```
-
-### Clean orphaned worktrees and branches
-```bash
-cursorflow clean all --orphaned
-```
-
-## Notes
-
-1. **Safety**: It is highly recommended to run with `--dry-run` first to see exactly what will be deleted.
-2. **Worktrees**: The command identifies CursorFlow worktrees by their location (usually in `_cursorflow/worktrees/`) or their prefix.
-3. **Branches**: Only branches starting with the configured `branchPrefix` (default: `cursorflow/`) are targeted.
-4. **Irreversible**: Once logs are deleted, they cannot be recovered.
-5. **Default Behavior**: By default, the most recent item is preserved. The "most recent" is determined by:
-   - **Worktrees**: Directory modification time
-   - **Branches**: Latest commit timestamp
-   - **Logs**: File/directory modification time
-   - **Tasks**: Directory modification time
-   
-   Use `--include-latest` to remove everything including the most recent item.