@litmers/cursorflow-orchestrator 0.1.0

package/src/cli/setup-commands.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Setup Cursor commands
+ * 
+ * Installs CursorFlow commands to .cursor/commands/cursorflow/
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+const { findProjectRoot } = require('../utils/config');
+
+function parseArgs(args) {
+  const options = {
+    force: false,
+    uninstall: false,
+    silent: false,
+  };
+  
+  for (const arg of args) {
+    switch (arg) {
+      case '--force':
+        options.force = true;
+        break;
+      case '--uninstall':
+        options.uninstall = true;
+        break;
+      case '--silent':
+        options.silent = true;
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        process.exit(0);
+        break;
+    }
+  }
+  
+  return options;
+}
+
+function printHelp() {
+  console.log(`
+Usage: cursorflow-setup [options]
+
+Install CursorFlow commands to Cursor IDE
+
+Options:
+  --force             Overwrite existing commands
+  --uninstall         Remove installed commands
+  --silent            Suppress output
+  --help, -h          Show help
+
+Examples:
+  cursorflow-setup
+  cursorflow-setup --force
+  cursorflow-setup --uninstall
+  `);
+}
+
+function getCommandsSourceDir() {
+  // Commands are in the package directory
+  return path.join(__dirname, '..', '..', 'commands');
+}
+
+function setupCommands(options = {}) {
+  const projectRoot = findProjectRoot();
+  const targetDir = path.join(projectRoot, '.cursor', 'commands', 'cursorflow');
+  const sourceDir = getCommandsSourceDir();
+  
+  if (!options.silent) {
+    logger.info(`Installing commands to: ${path.relative(projectRoot, targetDir)}`);
+  }
+  
+  // Create target directory
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  
+  // Get list of command files
+  if (!fs.existsSync(sourceDir)) {
+    throw new Error(`Commands directory not found: ${sourceDir}`);
+  }
+  
+  const commandFiles = fs.readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+  
+  if (commandFiles.length === 0) {
+    throw new Error(`No command files found in ${sourceDir}`);
+  }
+  
+  let installed = 0;
+  let backed = 0;
+  let skipped = 0;
+  
+  for (const file of commandFiles) {
+    const sourcePath = path.join(sourceDir, file);
+    const targetPath = path.join(targetDir, file);
+    
+    // Check if file exists
+    if (fs.existsSync(targetPath)) {
+      if (options.force) {
+        // Backup existing file
+        const backupPath = `${targetPath}.backup`;
+        fs.copyFileSync(targetPath, backupPath);
+        backed++;
+        if (!options.silent) {
+          logger.info(`📦 Backed up: ${file}`);
+        }
+      } else {
+        skipped++;
+        if (!options.silent) {
+          logger.info(`⏭️  Skipped (exists): ${file}`);
+        }
+        continue;
+      }
+    }
+    
+    // Copy file
+    fs.copyFileSync(sourcePath, targetPath);
+    installed++;
+    if (!options.silent) {
+      logger.success(`Installed: ${file}`);
+    }
+  }
+  
+  if (!options.silent) {
+    logger.section('🎉 Setup complete!');
+    console.log(`   Installed: ${installed} commands`);
+    if (backed > 0) {
+      console.log(`   Backed up: ${backed} existing commands`);
+    }
+    if (skipped > 0) {
+      console.log(`   Skipped: ${skipped} commands (use --force to overwrite)`);
+    }
+    console.log(`\n📍 Location: ${targetDir}`);
+    console.log('\n💡 Usage: Type "/" in Cursor chat to see commands');
+  }
+  
+  return { installed, backed, skipped };
+}
+
+function uninstallCommands(options = {}) {
+  const projectRoot = findProjectRoot();
+  const targetDir = path.join(projectRoot, '.cursor', 'commands', 'cursorflow');
+  
+  if (!fs.existsSync(targetDir)) {
+    if (!options.silent) {
+      logger.info('Commands directory not found, nothing to uninstall');
+    }
+    return { removed: 0 };
+  }
+  
+  const commandFiles = fs.readdirSync(targetDir).filter(f => f.endsWith('.md'));
+  let removed = 0;
+  
+  for (const file of commandFiles) {
+    const filePath = path.join(targetDir, file);
+    fs.unlinkSync(filePath);
+    removed++;
+    if (!options.silent) {
+      logger.info(`Removed: ${file}`);
+    }
+  }
+  
+  // Remove directory if empty
+  const remainingFiles = fs.readdirSync(targetDir);
+  if (remainingFiles.length === 0) {
+    fs.rmdirSync(targetDir);
+    if (!options.silent) {
+      logger.info(`Removed directory: ${targetDir}`);
+    }
+  }
+  
+  if (!options.silent) {
+    logger.success(`Uninstalled ${removed} commands`);
+  }
+  
+  return { removed };
+}
+
+async function main(args) {
+  const options = parseArgs(args);
+  
+  try {
+    if (options.uninstall) {
+      return uninstallCommands(options);
+    } else {
+      return setupCommands(options);
+    }
+  } catch (error) {
+    if (!options.silent) {
+      logger.error(error.message);
+    }
+    throw error;
+  }
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2)).catch(error => {
+    console.error('❌ Error:', error.message);
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  });
+}
+
+module.exports = setupCommands;
+module.exports.setupCommands = setupCommands;
+module.exports.uninstallCommands = uninstallCommands;

package/src/core/orchestrator.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Orchestrator - Parallel lane execution with dependency management
+ * 
+ * Adapted from admin-domains-orchestrator.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const logger = require('../utils/logger');
+const { loadState, saveState } = require('../utils/state');
+const { runTasks } = require('./runner');
+
+/**
+ * Spawn a lane process
+ */
+function spawnLane({ laneName, tasksFile, laneRunDir, executor }) {
+  fs.mkdirSync(laneRunDir, { recursive: true});
+  const logPath = path.join(laneRunDir, 'terminal.log');
+  const logFd = fs.openSync(logPath, 'a');
+  
+  const args = [
+    require.resolve('./runner.js'),
+    tasksFile,
+    '--run-dir', laneRunDir,
+    '--executor', executor,
+  ];
+  
+  const child = spawn('node', args, {
+    stdio: ['ignore', logFd, logFd],
+    env: process.env,
+    detached: false,
+  });
+  
+  try {
+    fs.closeSync(logFd);
+  } catch {
+    // Ignore
+  }
+  
+  return { child, logPath };
+}
+
+/**
+ * Wait for child process to exit
+ */
+function waitChild(proc) {
+  return new Promise((resolve) => {
+    if (proc.exitCode !== null) {
+      resolve(proc.exitCode);
+      return;
+    }
+    
+    proc.once('exit', (code) => resolve(code ?? 1));
+    proc.once('error', () => resolve(1));
+  });
+}
+
+/**
+ * List lane task files in directory
+ */
+function listLaneFiles(tasksDir) {
+  if (!fs.existsSync(tasksDir)) {
+    return [];
+  }
+  
+  const files = fs.readdirSync(tasksDir);
+  return files
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .map(f => ({
+      name: path.basename(f, '.json'),
+      path: path.join(tasksDir, f),
+    }));
+}
+
+/**
+ * Monitor lane states
+ */
+function printLaneStatus(lanes, laneRunDirs) {
+  const rows = lanes.map(lane => {
+    const statePath = path.join(laneRunDirs[lane.name], 'state.json');
+    const state = loadState(statePath);
+    
+    if (!state) {
+      return { lane: lane.name, status: '(no state)', task: '-' };
+    }
+    
+    const idx = state.currentTaskIndex + 1;
+    return {
+      lane: lane.name,
+      status: state.status || 'unknown',
+      task: `${idx}/${state.totalTasks || '?'}`,
+    };
+  });
+  
+  logger.section('📡 Lane Status');
+  for (const r of rows) {
+    console.log(`- ${r.lane}: ${r.status} (${r.task})`);
+  }
+}
+
+/**
+ * Run orchestration
+ */
+async function orchestrate(tasksDir, options = {}) {
+  const lanes = listLaneFiles(tasksDir);
+  
+  if (lanes.length === 0) {
+    throw new Error(`No lane task files found in ${tasksDir}`);
+  }
+  
+  const runRoot = options.runDir || `_cursorflow/logs/runs/run-${Date.now()}`;
+  fs.mkdirSync(runRoot, { recursive: true });
+  
+  const laneRunDirs = {};
+  for (const lane of lanes) {
+    laneRunDirs[lane.name] = path.join(runRoot, 'lanes', lane.name);
+  }
+  
+  logger.section('🧭 Starting Orchestration');
+  logger.info(`Tasks directory: ${tasksDir}`);
+  logger.info(`Run directory: ${runRoot}`);
+  logger.info(`Lanes: ${lanes.length}`);
+  
+  // Spawn all lanes
+  const running = [];
+  
+  for (const lane of lanes) {
+    const { child, logPath } = spawnLane({
+      laneName: lane.name,
+      tasksFile: lane.path,
+      laneRunDir: laneRunDirs[lane.name],
+      executor: options.executor || 'cursor-agent',
+    });
+    
+    running.push({ lane: lane.name, child, logPath });
+    logger.info(`Lane started: ${lane.name}`);
+  }
+  
+  // Monitor lanes
+  const monitorInterval = setInterval(() => {
+    printLaneStatus(lanes, laneRunDirs);
+  }, options.pollInterval || 60000);
+  
+  // Wait for all lanes
+  const exitCodes = {};
+  
+  for (const r of running) {
+    exitCodes[r.lane] = await waitChild(r.child);
+  }
+  
+  clearInterval(monitorInterval);
+  printLaneStatus(lanes, laneRunDirs);
+  
+  // Check for failures
+  const failed = Object.entries(exitCodes).filter(([, code]) => code !== 0 && code !== 2);
+  
+  if (failed.length > 0) {
+    logger.error(`Lanes failed: ${failed.map(([l, c]) => `${l}(${c})`).join(', ')}`);
+    process.exit(1);
+  }
+  
+  // Check for blocked lanes
+  const blocked = Object.entries(exitCodes)
+    .filter(([, code]) => code === 2)
+    .map(([lane]) => lane);
+  
+  if (blocked.length > 0) {
+    logger.warn(`Lanes blocked on dependency: ${blocked.join(', ')}`);
+    logger.info('Handle dependency changes manually and resume lanes');
+    process.exit(2);
+  }
+  
+  logger.success('All lanes completed successfully!');
+  return { lanes, exitCodes, runRoot };
+}
+
+module.exports = {
+  orchestrate,
+  spawnLane,
+  listLaneFiles,
+};

package/src/core/reviewer.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+/**
+ * Reviewer - Code review agent
+ * 
+ * Adapted from reviewer-agent.js
+ */
+
+const logger = require('../utils/logger');
+const { appendLog, createConversationEntry } = require('../utils/state');
+const path = require('path');
+
+/**
+ * Build review prompt
+ */
+function buildReviewPrompt({ taskName, taskBranch, acceptanceCriteria = [] }) {
+  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
+ */
+function parseReviewResult(text) {
+  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 : [],
+        suggestions: Array.isArray(parsed.suggestions) ? parsed.suggestions : [],
+        summary: parsed.summary || '',
+        raw: t,
+      };
+    } catch (err) {
+      logger.warn(`JSON parse failed: ${err.message}`);
+    }
+  }
+  
+  // Fallback parsing
+  const hasApproved = t.toLowerCase().includes('"status": "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
+ */
+function buildFeedbackPrompt(review) {
+  const lines = [];
+  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
+ */
+async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgentSend, cursorAgentCreateChat }) {
+  const reviewPrompt = buildReviewPrompt({
+    taskName: taskResult.taskName,
+    taskBranch: taskResult.taskBranch,
+    acceptanceCriteria: config.acceptanceCriteria || [],
+  });
+  
+  logger.info(`Reviewing: ${taskResult.taskName}`);
+  
+  const reviewChatId = cursorAgentCreateChat();
+  const reviewResult = cursorAgentSend({
+    workspaceDir: worktreeDir,
+    chatId: reviewChatId,
+    prompt: reviewPrompt,
+    model: config.reviewModel || 'sonnet-4.5-thinking',
+  });
+  
+  const review = parseReviewResult(reviewResult.resultText);
+  
+  // Log review
+  const convoPath = path.join(runDir, 'conversation.jsonl');
+  appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText, {
+    task: taskResult.taskName,
+    model: config.reviewModel,
+  }));
+  
+  logger.info(`Review result: ${review.status} (${review.issues?.length || 0} issues)`);
+  
+  return review;
+}
+
+/**
+ * Review loop with feedback
+ */
+async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, cursorAgentSend, cursorAgentCreateChat }) {
+  const maxIterations = config.maxReviewIterations || 3;
+  let iteration = 0;
+  let currentReview = null;
+  
+  while (iteration < maxIterations) {
+    currentReview = await reviewTask({
+      taskResult,
+      worktreeDir,
+      runDir,
+      config,
+      cursorAgentSend,
+      cursorAgentCreateChat,
+    });
+    
+    if (currentReview.status === 'approved') {
+      logger.success(`Review passed: ${taskResult.taskName} (iteration ${iteration + 1})`);
+      return { approved: true, review: currentReview, iterations: iteration + 1 };
+    }
+    
+    iteration++;
+    
+    if (iteration >= maxIterations) {
+      logger.warn(`Max review iterations (${maxIterations}) reached: ${taskResult.taskName}`);
+      break;
+    }
+    
+    // Send feedback
+    logger.info(`Sending feedback (iteration ${iteration}/${maxIterations})`);
+    const feedbackPrompt = buildFeedbackPrompt(currentReview);
+    
+    const fixResult = cursorAgentSend({
+      workspaceDir: worktreeDir,
+      chatId: workChatId,
+      prompt: feedbackPrompt,
+      model: config.model,
+    });
+    
+    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 };
+}
+
+module.exports = {
+  buildReviewPrompt,
+  parseReviewResult,
+  buildFeedbackPrompt,
+  reviewTask,
+  runReviewLoop,
+};