@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

package/src/cli/runs.ts

@@ -1,212 +0,0 @@
-/**
- * CursorFlow runs command - List and view run details
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as logger from '../utils/logger';
-import { loadConfig, getLogsDir } from '../utils/config';
-import { RunService } from '../utils/run-service';
-import { RunStatus, RunInfo } from '../utils/types';
-import { safeJoin } from '../utils/path';
-
-interface RunsOptions {
-  status?: RunStatus;
-  json: boolean;
-  help: boolean;
-  runId?: string;
-}
-
-function printHelp(): void {
-  console.log(`
-Usage: cursorflow runs [run-id] [options]
-
-List all runs or view details of a specific run.
-
-Options:
-  [run-id]               View details of a specific run
-  --running              Filter to show only running runs
-  --status <status>      Filter by status: running, completed, failed, partial, pending
-  --json                 Output in JSON format
-  --help, -h             Show help
-
-Examples:
-  cursorflow runs              # List all runs
-  cursorflow runs --running    # List only running runs
-  cursorflow runs run-123      # View details of run-123
-  `);
-}
-
-function parseArgs(args: string[]): RunsOptions {
-  const statusIdx = args.indexOf('--status');
-  const running = args.includes('--running');
-  
-  // Find run ID (first non-option argument)
-  const runId = args.find((arg, i) => {
-    if (arg.startsWith('--') || arg.startsWith('-')) return false;
-    // Skip values for options
-    const prevArg = args[i - 1];
-    if (prevArg && ['--status'].includes(prevArg)) {
-      return false;
-    }
-    return true;
-  });
-
-  return {
-    runId,
-    status: running ? 'running' : (statusIdx >= 0 ? args[statusIdx + 1] as RunStatus : undefined),
-    json: args.includes('--json'),
-    help: args.includes('--help') || args.includes('-h'),
-  };
-}
-
-/**
- * Format duration in a human-readable way
- */
-function formatDuration(ms: number): string {
-  if (ms < 1000) return `${ms}ms`;
-  const seconds = Math.floor(ms / 1000);
-  if (seconds < 60) return `${seconds}s`;
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  if (minutes < 60) return `${minutes}m ${remainingSeconds}s`;
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return `${hours}h ${remainingMinutes}m`;
-}
-
-/**
- * Get status color and emoji
- */
-function getStatusDisplay(status: RunStatus): string {
-  switch (status) {
-    case 'running':
-      return `${logger.COLORS.blue}🔄 running${logger.COLORS.reset}`;
-    case 'completed':
-      return `${logger.COLORS.green}✅ done   ${logger.COLORS.reset}`;
-    case 'failed':
-      return `${logger.COLORS.red}❌ failed ${logger.COLORS.reset}`;
-    case 'partial':
-      return `${logger.COLORS.yellow}⚠️ partial${logger.COLORS.reset}`;
-    case 'pending':
-      return `${logger.COLORS.gray}⏳ pending${logger.COLORS.reset}`;
-    default:
-      return status;
-  }
-}
-
-/**
- * Display list of runs
- */
-function displayRunList(runs: RunInfo[]): void {
-  if (runs.length === 0) {
-    console.log('No runs found.');
-    return;
-  }
-
-  console.log(`    Run ID              Task            Status     Lanes     Duration`);
-  console.log(`${logger.COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${logger.COLORS.reset}`);
-
-  for (const run of runs) {
-    const isRunning = run.status === 'running';
-    const prefix = isRunning ? `${logger.COLORS.blue}  ▶${logger.COLORS.reset}` : '   ';
-    
-    const id = run.id.padEnd(20);
-    const task = (run.taskName || 'unnamed').substring(0, 15).padEnd(15);
-    const status = getStatusDisplay(run.status);
-    
-    const completedLanes = run.lanes.filter(l => l.status === 'completed').length;
-    const totalLanes = run.lanes.length;
-    const lanes = `${completedLanes}/${totalLanes}`.padEnd(10);
-    
-    const duration = formatDuration(run.duration);
-    
-    console.log(`${prefix} ${id} ${task} ${status} ${lanes} ${duration}`);
-  }
-}
-
-/**
- * Display detailed information for a single run
- */
-function displayRunDetail(run: RunInfo): void {
-  logger.section(`Run Details: ${run.id}`);
-  
-  console.log(`${logger.COLORS.bold}Task:${logger.COLORS.reset}      ${run.taskName}`);
-  console.log(`${logger.COLORS.bold}Status:${logger.COLORS.reset}    ${getStatusDisplay(run.status)}`);
-  console.log(`${logger.COLORS.bold}Start Time:${logger.COLORS.reset} ${new Date(run.startTime).toLocaleString()}`);
-  console.log(`${logger.COLORS.bold}Duration:${logger.COLORS.reset}   ${formatDuration(run.duration)}`);
-  console.log(`${logger.COLORS.bold}Path:${logger.COLORS.reset}       ${run.path}`);
-  
-  console.log(`\n${logger.COLORS.bold}Lanes:${logger.COLORS.reset}`);
-  for (const lane of run.lanes) {
-    const statusColor = lane.status === 'completed' ? logger.COLORS.green : 
-                       lane.status === 'failed' ? logger.COLORS.red : 
-                       lane.status === 'running' ? logger.COLORS.blue : logger.COLORS.reset;
-    
-    console.log(`  - ${lane.name.padEnd(20)} [${statusColor}${lane.status.toUpperCase()}${logger.COLORS.reset}] Task ${lane.currentTask}/${lane.totalTasks} (PID: ${lane.pid || 'N/A'})`);
-  }
-  
-  if (run.branches.length > 0) {
-    console.log(`\n${logger.COLORS.bold}Branches:${logger.COLORS.reset}`);
-    for (const branch of run.branches) {
-      console.log(`  - ${branch}`);
-    }
-  }
-  
-  if (run.worktrees.length > 0) {
-    console.log(`\n${logger.COLORS.bold}Worktrees:${logger.COLORS.reset}`);
-    for (const wt of run.worktrees) {
-      console.log(`  - ${wt}`);
-    }
-  }
-  
-  console.log(`\nView logs: ${logger.COLORS.cyan}cursorflow logs ${run.id} --all${logger.COLORS.reset}`);
-}
-
-async function runs(args: string[]): Promise<void> {
-  const options = parseArgs(args);
-  
-  if (options.help) {
-    printHelp();
-    return;
-  }
-  
-  const config = loadConfig();
-  const logsDir = getLogsDir(config);
-  const runsDir = safeJoin(logsDir, 'runs');
-  
-  if (!fs.existsSync(runsDir)) {
-    if (options.json) {
-      console.log('[]');
-    } else {
-      console.log('No runs found. (Runs directory does not exist)');
-    }
-    return;
-  }
-  
-  const runService = new RunService(runsDir);
-  
-  if (options.runId) {
-    const run = runService.getRunInfo(options.runId);
-    if (!run) {
-      throw new Error(`Run not found: ${options.runId}`);
-    }
-    
-    if (options.json) {
-      console.log(JSON.stringify(run, null, 2));
-    } else {
-      displayRunDetail(run);
-    }
-    return;
-  }
-  
-  const runsList = runService.listRuns({ status: options.status });
-  
-  if (options.json) {
-    console.log(JSON.stringify(runsList, null, 2));
-  } else {
-    displayRunList(runsList);
-  }
-}
-
-export = runs;

package/src/core/reviewer.ts

@@ -1,285 +0,0 @@
-/**
- * Reviewer - Code review agent
- * 
- * Adapted from reviewer-agent.js
- */
-
-import * as logger from '../utils/logger';
-import { appendLog, createConversationEntry } from '../utils/state';
-import * as path from 'path';
-import { ReviewResult, ReviewIssue, TaskResult, RunnerConfig, AgentSendResult } from '../utils/types';
-import { events } from '../utils/events';
-
-/**
- * Build review prompt
- */
-export function buildReviewPrompt({ taskName, taskBranch, acceptanceCriteria = [] }: { taskName: string; taskBranch: string; acceptanceCriteria?: string[] }): string {
-  const criteriaList = acceptanceCriteria.length > 0
-    ? acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join('\n')
-    : 'Work should be completed properly.';
-  
-  return `# Code Review: ${taskName}
-
-## Role
-You are a senior code reviewer. Please review the results of this task.
-
-## Task Details
-- Name: ${taskName}
-- Branch: ${taskBranch}
-
-## Acceptance Criteria
-${criteriaList}
-
-## Review Checklist
-1. **Build Success**: Does \`pnpm build\` complete without errors?
-2. **Code Quality**: Are there no linting or TypeScript type errors?
-3. **Completeness**: Are all acceptance criteria met?
-4. **Bugs**: Are there any obvious bugs or logic errors?
-5. **Commit Status**: Are changes properly committed and pushed?
-
-## Output Format (MUST follow exactly)
-\`\`\`json
-{
-  "status": "approved" | "needs_changes",
-  "buildSuccess": true | false,
-  "issues": [
-    {
-      "severity": "critical" | "major" | "minor",
-      "description": "...",
-      "file": "...",
-      "suggestion": "..."
-    }
-  ],
-  "suggestions": ["..."],
-  "summary": "One-line summary"
-}
-\`\`\`
-
-IMPORTANT: You MUST respond in the exact JSON format above. "status" must be either "approved" or "needs_changes".
-`;
-}
-
-/**
- * Parse review result
- */
-export function parseReviewResult(text: string): ReviewResult {
-  const t = String(text || '');
-  
-  // Try JSON block
-  const jsonMatch = t.match(/```json\n([\s\S]*?)\n```/);
-  if (jsonMatch) {
-    try {
-      const parsed = JSON.parse(jsonMatch[1]!);
-      return {
-        status: parsed.status || 'needs_changes',
-        buildSuccess: parsed.buildSuccess !== false,
-        issues: Array.isArray(parsed.issues) ? (parsed.issues as ReviewIssue[]) : [],
-        suggestions: Array.isArray(parsed.suggestions) ? (parsed.suggestions as string[]) : [],
-        summary: parsed.summary || '',
-        raw: t,
-      };
-    } catch (err: any) {
-      logger.warn(`JSON parse failed: ${err.message}`);
-    }
-  }
-  
-  // Fallback parsing
-  const hasApproved = t.toLowerCase().includes('approved');
-  const hasIssues = t.toLowerCase().includes('needs_changes') ||
-                    t.toLowerCase().includes('error') ||
-                    t.toLowerCase().includes('failed');
-  
-  return {
-    status: hasApproved && !hasIssues ? 'approved' : 'needs_changes',
-    buildSuccess: !t.toLowerCase().includes('build') || !t.toLowerCase().includes('fail'),
-    issues: hasIssues ? [{ severity: 'major', description: 'Parse failed, see logs' }] : [],
-    suggestions: [],
-    summary: 'Auto-parsed - check original response',
-    raw: t,
-  };
-}
-
-/**
- * Build feedback prompt
- */
-export function buildFeedbackPrompt(review: ReviewResult): string {
-  const lines: string[] = [];
-  lines.push('# Code Review Feedback');
-  lines.push('');
-  lines.push('The reviewer found the following issues. Please fix them:');
-  lines.push('');
-  
-  if (!review.buildSuccess) {
-    lines.push('## CRITICAL: Build Failed');
-    lines.push('- \`pnpm build\` failed. Fix build errors first.');
-    lines.push('');
-  }
-  
-  for (const issue of review.issues || []) {
-    const severity = (issue.severity || 'major').toUpperCase();
-    lines.push(`## ${severity}: ${issue.description}`);
-    if (issue.file) lines.push(`- File: ${issue.file}`);
-    if (issue.suggestion) lines.push(`- Suggestion: ${issue.suggestion}`);
-    lines.push('');
-  }
-  
-  if (review.suggestions && review.suggestions.length > 0) {
-    lines.push('## Additional Suggestions');
-    for (const s of review.suggestions) {
-      lines.push(`- ${s}`);
-    }
-    lines.push('');
-  }
-  
-  lines.push('## Requirements');
-  lines.push('1. Fix all issues listed above');
-  lines.push('2. Ensure \`pnpm build\` succeeds');
-  lines.push('3. Commit and push your changes');
-  lines.push('');
-  lines.push('**Let me know when fixes are complete.**');
-  
-  return lines.join('\n');
-}
-
-/**
- * Review task
- */
-export async function reviewTask({ taskResult, worktreeDir, runDir, config, model, cursorAgentSend, cursorAgentCreateChat }: { 
-  taskResult: TaskResult; 
-  worktreeDir: string; 
-  runDir: string; 
-  config: RunnerConfig; 
-  model?: string;
-  cursorAgentSend: (options: { 
-    workspaceDir: string; 
-    chatId: string; 
-    prompt: string; 
-    model?: string;
-    outputFormat?: 'stream-json' | 'json' | 'plain';
-    taskName?: string;
-  }) => Promise<AgentSendResult>; 
-  cursorAgentCreateChat: () => string; 
-}): Promise<ReviewResult> {
-  const reviewPrompt = buildReviewPrompt({
-    taskName: taskResult.taskName,
-    taskBranch: taskResult.taskBranch,
-    acceptanceCriteria: taskResult.acceptanceCriteria || config.acceptanceCriteria || [],
-  });
-  
-  logger.info(`Reviewing: ${taskResult.taskName}`);
-  
-  events.emit('review.started', {
-    taskName: taskResult.taskName,
-    taskBranch: taskResult.taskBranch,
-  });
-
-  const reviewChatId = cursorAgentCreateChat();
-  const reviewModel = model || config.reviewModel || config.model || 'sonnet-4.5';
-  
-  const reviewResult = await cursorAgentSend({
-    workspaceDir: worktreeDir,
-    chatId: reviewChatId,
-    prompt: reviewPrompt,
-    model: reviewModel,
-    outputFormat: config.agentOutputFormat,
-    taskName: `review:${taskResult.taskName}`,
-  });
-  
-  const review = parseReviewResult(reviewResult.resultText || '');
-  
-  // Log review
-  const convoPath = path.join(runDir, 'conversation.jsonl');
-  appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText || 'No result', {
-    task: taskResult.taskName,
-    model: reviewModel,
-  }));
-  
-  logger.info(`Review result: ${review.status} (${review.issues?.length || 0} issues)`);
-  
-  events.emit('review.completed', {
-    taskName: taskResult.taskName,
-    status: review.status,
-    issueCount: review.issues?.length || 0,
-    summary: review.summary,
-  });
-
-  return review;
-}
-
-/**
- * Review loop with feedback
- */
-export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, model, cursorAgentSend, cursorAgentCreateChat }: {
-  taskResult: TaskResult;
-  worktreeDir: string;
-  runDir: string;
-  config: RunnerConfig;
-  workChatId: string;
-  model?: string;
-  cursorAgentSend: (options: { 
-    workspaceDir: string; 
-    chatId: string; 
-    prompt: string; 
-    model?: string;
-    outputFormat?: 'stream-json' | 'json' | 'plain';
-    taskName?: string;
-  }) => Promise<AgentSendResult>; 
-  cursorAgentCreateChat: () => string; 
-}): Promise<{ approved: boolean; review: ReviewResult; iterations: number; error?: string }> {
-  const maxIterations = config.maxReviewIterations || 3;
-  let iteration = 0;
-  let currentReview: ReviewResult | null = null;
-  
-  while (iteration < maxIterations) {
-    currentReview = await reviewTask({
-      taskResult,
-      worktreeDir,
-      runDir,
-      config,
-      model,
-      cursorAgentSend,
-      cursorAgentCreateChat,
-    });
-
-    if (currentReview.status === 'approved') {
-      logger.success(`Review passed: ${taskResult.taskName} (iteration ${iteration + 1})`);
-      events.emit('review.approved', {
-        taskName: taskResult.taskName,
-        iterations: iteration + 1,
-      });
-      return { approved: true, review: currentReview, iterations: iteration + 1 };
-    }
-    
-    iteration++;
-    
-    if (iteration >= maxIterations) {
-      logger.warn(`Max review iterations (${maxIterations}) reached: ${taskResult.taskName}`);
-      events.emit('review.rejected', {
-        taskName: taskResult.taskName,
-        reason: 'Max iterations reached',
-        iterations: iteration,
-      });
-      break;
-    }
-    
-    // Send feedback
-    logger.info(`Sending feedback (iteration ${iteration}/${maxIterations})`);
-    const feedbackPrompt = buildFeedbackPrompt(currentReview);
-    
-    const fixResult = await cursorAgentSend({
-      workspaceDir: worktreeDir,
-      chatId: workChatId,
-      prompt: feedbackPrompt,
-      model: config.model,
-      outputFormat: config.agentOutputFormat,
-      taskName: taskResult.taskName,
-    });
-    
-    if (!fixResult.ok) {
-      logger.error(`Feedback application failed: ${fixResult.error}`);
-      return { approved: false, review: currentReview, iterations: iteration, error: fixResult.error };
-    }
-  }
-  
-  return { approved: false, review: currentReview!, iterations: iteration };
-}