@litmers/cursorflow-orchestrator 0.1.3 → 0.1.6

package/src/core/{orchestrator.js → orchestrator.ts}

@@ -1,28 +1,45 @@
-#!/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');
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn, ChildProcess } from 'child_process';
 
-const logger = require('../utils/logger');
-const { loadState, saveState } = require('../utils/state');
-const { runTasks } = require('./runner');
+import * as logger from '../utils/logger';
+import { loadState } from '../utils/state';
+import { LaneState } from '../utils/types';
+
+export interface LaneInfo {
+  name: string;
+  path: string;
+}
+
+export interface SpawnLaneResult {
+  child: ChildProcess;
+  logPath: string;
+}
 
 /**
  * Spawn a lane process
  */
-function spawnLane({ laneName, tasksFile, laneRunDir, executor }) {
+export function spawnLane({ tasksFile, laneRunDir, executor }: { 
+  laneName: string; 
+  tasksFile: string; 
+  laneRunDir: string; 
+  executor: string; 
+}): SpawnLaneResult {
   fs.mkdirSync(laneRunDir, { recursive: true});
   const logPath = path.join(laneRunDir, 'terminal.log');
   const logFd = fs.openSync(logPath, 'a');
   
+  // Use extension-less resolve to handle both .ts (dev) and .js (dist)
+  const runnerPath = require.resolve('./runner');
+  
   const args = [
-    require.resolve('./runner.js'),
+    runnerPath,
     tasksFile,
     '--run-dir', laneRunDir,
     '--executor', executor,
@@ -46,7 +63,7 @@ function spawnLane({ laneName, tasksFile, laneRunDir, executor }) {
 /**
  * Wait for child process to exit
  */
-function waitChild(proc) {
+export function waitChild(proc: ChildProcess): Promise<number> {
   return new Promise((resolve) => {
     if (proc.exitCode !== null) {
       resolve(proc.exitCode);
@@ -61,7 +78,7 @@ function waitChild(proc) {
 /**
  * List lane task files in directory
  */
-function listLaneFiles(tasksDir) {
+export function listLaneFiles(tasksDir: string): LaneInfo[] {
   if (!fs.existsSync(tasksDir)) {
     return [];
   }
@@ -79,16 +96,19 @@ function listLaneFiles(tasksDir) {
 /**
  * Monitor lane states
  */
-function printLaneStatus(lanes, laneRunDirs) {
+export function printLaneStatus(lanes: LaneInfo[], laneRunDirs: Record<string, string>): void {
   const rows = lanes.map(lane => {
-    const statePath = path.join(laneRunDirs[lane.name], 'state.json');
-    const state = loadState(statePath);
+    const dir = laneRunDirs[lane.name];
+    if (!dir) return { lane: lane.name, status: '(unknown)', task: '-' };
+    
+    const statePath = path.join(dir, 'state.json');
+    const state = loadState<LaneState>(statePath);
     
     if (!state) {
       return { lane: lane.name, status: '(no state)', task: '-' };
     }
     
-    const idx = state.currentTaskIndex + 1;
+    const idx = (state.currentTaskIndex || 0) + 1;
     return {
       lane: lane.name,
       status: state.status || 'unknown',
@@ -105,7 +125,11 @@ function printLaneStatus(lanes, laneRunDirs) {
 /**
  * Run orchestration
  */
-async function orchestrate(tasksDir, options = {}) {
+export async function orchestrate(tasksDir: string, options: { 
+  runDir?: string; 
+  executor?: string; 
+  pollInterval?: number; 
+} = {}): Promise<{ lanes: LaneInfo[]; exitCodes: Record<string, number>; runRoot: string }> {
   const lanes = listLaneFiles(tasksDir);
   
   if (lanes.length === 0) {
@@ -115,7 +139,7 @@ async function orchestrate(tasksDir, options = {}) {
   const runRoot = options.runDir || `_cursorflow/logs/runs/run-${Date.now()}`;
   fs.mkdirSync(runRoot, { recursive: true });
   
-  const laneRunDirs = {};
+  const laneRunDirs: Record<string, string> = {};
   for (const lane of lanes) {
     laneRunDirs[lane.name] = path.join(runRoot, 'lanes', lane.name);
   }
@@ -126,13 +150,13 @@ async function orchestrate(tasksDir, options = {}) {
   logger.info(`Lanes: ${lanes.length}`);
   
   // Spawn all lanes
-  const running = [];
+  const running: { lane: string; child: ChildProcess; logPath: string }[] = [];
   
   for (const lane of lanes) {
     const { child, logPath } = spawnLane({
       laneName: lane.name,
       tasksFile: lane.path,
-      laneRunDir: laneRunDirs[lane.name],
+      laneRunDir: laneRunDirs[lane.name]!,
       executor: options.executor || 'cursor-agent',
     });
     
@@ -146,7 +170,7 @@ async function orchestrate(tasksDir, options = {}) {
   }, options.pollInterval || 60000);
   
   // Wait for all lanes
-  const exitCodes = {};
+  const exitCodes: Record<string, number> = {};
   
   for (const r of running) {
     exitCodes[r.lane] = await waitChild(r.child);
@@ -177,9 +201,3 @@ async function orchestrate(tasksDir, options = {}) {
   logger.success('All lanes completed successfully!');
   return { lanes, exitCodes, runRoot };
 }
-
-module.exports = {
-  orchestrate,
-  spawnLane,
-  listLaneFiles,
-};

package/src/core/{reviewer.js → reviewer.ts}

@@ -1,18 +1,18 @@
-#!/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');
+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';
 
 /**
  * Build review prompt
  */
-function buildReviewPrompt({ taskName, taskBranch, acceptanceCriteria = [] }) {
+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.';
@@ -61,29 +61,29 @@ IMPORTANT: You MUST respond in the exact JSON format above. "status" must be eit
 /**
  * Parse review result
  */
-function parseReviewResult(text) {
+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]);
+      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 : [],
+        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) {
+    } catch (err: any) {
       logger.warn(`JSON parse failed: ${err.message}`);
     }
   }
   
   // Fallback parsing
-  const hasApproved = t.toLowerCase().includes('"status": "approved"');
+  const hasApproved = t.toLowerCase().includes('approved');
   const hasIssues = t.toLowerCase().includes('needs_changes') ||
                     t.toLowerCase().includes('error') ||
                     t.toLowerCase().includes('failed');
@@ -101,8 +101,8 @@ function parseReviewResult(text) {
 /**
  * Build feedback prompt
  */
-function buildFeedbackPrompt(review) {
-  const lines = [];
+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:');
@@ -110,7 +110,7 @@ function buildFeedbackPrompt(review) {
   
   if (!review.buildSuccess) {
     lines.push('## CRITICAL: Build Failed');
-    lines.push('- `pnpm build` failed. Fix build errors first.');
+    lines.push('- \`pnpm build\` failed. Fix build errors first.');
     lines.push('');
   }
   
@@ -132,7 +132,7 @@ function buildFeedbackPrompt(review) {
   
   lines.push('## Requirements');
   lines.push('1. Fix all issues listed above');
-  lines.push('2. Ensure `pnpm build` succeeds');
+  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.**');
@@ -143,7 +143,14 @@ function buildFeedbackPrompt(review) {
 /**
  * Review task
  */
-async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgentSend, cursorAgentCreateChat }) {
+export async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgentSend, cursorAgentCreateChat }: { 
+  taskResult: TaskResult; 
+  worktreeDir: string; 
+  runDir: string; 
+  config: RunnerConfig; 
+  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult; 
+  cursorAgentCreateChat: () => string; 
+}): Promise<ReviewResult> {
   const reviewPrompt = buildReviewPrompt({
     taskName: taskResult.taskName,
     taskBranch: taskResult.taskBranch,
@@ -160,11 +167,11 @@ async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgent
     model: config.reviewModel || 'sonnet-4.5-thinking',
   });
   
-  const review = parseReviewResult(reviewResult.resultText);
+  const review = parseReviewResult(reviewResult.resultText || '');
   
   // Log review
   const convoPath = path.join(runDir, 'conversation.jsonl');
-  appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText, {
+  appendLog(convoPath, createConversationEntry('reviewer', reviewResult.resultText || 'No result', {
     task: taskResult.taskName,
     model: config.reviewModel,
   }));
@@ -177,10 +184,18 @@ async function reviewTask({ taskResult, worktreeDir, runDir, config, cursorAgent
 /**
  * Review loop with feedback
  */
-async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, cursorAgentSend, cursorAgentCreateChat }) {
+export async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChatId, cursorAgentSend, cursorAgentCreateChat }: {
+  taskResult: TaskResult;
+  worktreeDir: string;
+  runDir: string;
+  config: RunnerConfig;
+  workChatId: string;
+  cursorAgentSend: (options: { workspaceDir: string; chatId: string; prompt: string; model?: string }) => AgentSendResult;
+  cursorAgentCreateChat: () => string;
+}): Promise<{ approved: boolean; review: ReviewResult; iterations: number; error?: string }> {
   const maxIterations = config.maxReviewIterations || 3;
   let iteration = 0;
-  let currentReview = null;
+  let currentReview: ReviewResult | null = null;
   
   while (iteration < maxIterations) {
     currentReview = await reviewTask({
@@ -221,13 +236,5 @@ async function runReviewLoop({ taskResult, worktreeDir, runDir, config, workChat
     }
   }
   
-  return { approved: false, review: currentReview, iterations: iteration };
+  return { approved: false, review: currentReview!, iterations: iteration };
 }
-
-module.exports = {
-  buildReviewPrompt,
-  parseReviewResult,
-  buildFeedbackPrompt,
-  reviewTask,
-  runReviewLoop,
-};