@litmers/cursorflow-orchestrator 0.1.3 → 0.1.6

package/src/utils/{state.js → state.ts}

@@ -1,15 +1,22 @@
-#!/usr/bin/env node
 /**
  * State management utilities for CursorFlow
  */
 
-const fs = require('fs');
-const path = require('path');
+import * as fs from 'fs';
+import * as path from 'path';
+import { 
+  LaneState, 
+  ConversationEntry, 
+  GitLogEntry, 
+  EventEntry, 
+  RunnerConfig 
+} from './types';
+export { LaneState, ConversationEntry, GitLogEntry, EventEntry };
 
 /**
  * Save state to JSON file
  */
-function saveState(statePath, state) {
+export function saveState(statePath: string, state: any): void {
   const stateDir = path.dirname(statePath);
   
   if (!fs.existsSync(stateDir)) {
@@ -22,15 +29,15 @@ function saveState(statePath, state) {
 /**
  * Load state from JSON file
  */
-function loadState(statePath) {
+export function loadState<T = any>(statePath: string): T | null {
   if (!fs.existsSync(statePath)) {
     return null;
   }
   
   try {
     const content = fs.readFileSync(statePath, 'utf8');
-    return JSON.parse(content);
-  } catch (error) {
+    return JSON.parse(content) as T;
+  } catch (error: any) {
     console.warn(`Warning: Failed to parse state file ${statePath}: ${error.message}`);
     return null;
   }
@@ -39,7 +46,7 @@ function loadState(statePath) {
 /**
  * Append to JSONL log file
  */
-function appendLog(logPath, entry) {
+export function appendLog(logPath: string, entry: any): void {
   const logDir = path.dirname(logPath);
   
   if (!fs.existsSync(logDir)) {
@@ -53,7 +60,7 @@ function appendLog(logPath, entry) {
 /**
  * Read JSONL log file
  */
-function readLog(logPath) {
+export function readLog<T = any>(logPath: string): T[] {
   if (!fs.existsSync(logPath)) {
     return [];
   }
@@ -63,8 +70,8 @@ function readLog(logPath) {
     return content
       .split('\n')
       .filter(line => line.trim())
-      .map(line => JSON.parse(line));
-  } catch (error) {
+      .map(line => JSON.parse(line) as T);
+  } catch (error: any) {
     console.warn(`Warning: Failed to parse log file ${logPath}: ${error.message}`);
     return [];
   }
@@ -73,7 +80,7 @@ function readLog(logPath) {
 /**
  * Create initial lane state
  */
-function createLaneState(laneName, config) {
+export function createLaneState(laneName: string, config: RunnerConfig): LaneState {
   return {
     label: laneName,
     status: 'pending',
@@ -91,7 +98,7 @@ function createLaneState(laneName, config) {
 /**
  * Update lane state
  */
-function updateLaneState(state, updates) {
+export function updateLaneState(state: LaneState, updates: Partial<LaneState>): LaneState {
   return {
     ...state,
     ...updates,
@@ -102,10 +109,10 @@ function updateLaneState(state, updates) {
 /**
  * Create conversation log entry
  */
-function createConversationEntry(role, text, options = {}) {
+export function createConversationEntry(role: ConversationEntry['role'], text: string, options: { task?: string; model?: string } = {}): ConversationEntry {
   return {
     timestamp: new Date().toISOString(),
-    role,  // 'user' | 'assistant' | 'reviewer' | 'system'
+    role,
     task: options.task || null,
     fullText: text,
     textLength: text.length,
@@ -116,10 +123,10 @@ function createConversationEntry(role, text, options = {}) {
 /**
  * Create git operation log entry
  */
-function createGitLogEntry(operation, details = {}) {
+export function createGitLogEntry(operation: string, details: any = {}): GitLogEntry {
   return {
     timestamp: new Date().toISOString(),
-    operation,  // 'commit' | 'push' | 'merge' | 'worktree-add' | etc.
+    operation,
     ...details,
   };
 }
@@ -127,7 +134,7 @@ function createGitLogEntry(operation, details = {}) {
 /**
  * Create event log entry
  */
-function createEventEntry(event, data = {}) {
+export function createEventEntry(event: string, data: any = {}): EventEntry {
   return {
     timestamp: new Date().toISOString(),
     event,
@@ -138,7 +145,7 @@ function createEventEntry(event, data = {}) {
 /**
  * Get latest run directory
  */
-function getLatestRunDir(logsDir) {
+export function getLatestRunDir(logsDir: string): string | null {
   if (!fs.existsSync(logsDir)) {
     return null;
   }
@@ -152,13 +159,13 @@ function getLatestRunDir(logsDir) {
     return null;
   }
   
-  return path.join(logsDir, runs[0]);
+  return path.join(logsDir, runs[0]!);
 }
 
 /**
  * List all lanes in a run directory
  */
-function listLanesInRun(runDir) {
+export function listLanesInRun(runDir: string): { name: string; dir: string; statePath: string }[] {
   if (!fs.existsSync(runDir)) {
     return [];
   }
@@ -175,8 +182,8 @@ function listLanesInRun(runDir) {
 /**
  * Get lane state summary
  */
-function getLaneStateSummary(statePath) {
-  const state = loadState(statePath);
+export function getLaneStateSummary(statePath: string): { status: string; progress: string; label?: string; error?: string | null } {
+  const state = loadState<LaneState>(statePath);
   if (!state) {
     return { status: 'unknown', progress: '-' };
   }
@@ -190,18 +197,3 @@ function getLaneStateSummary(statePath) {
     error: state.error,
   };
 }
-
-module.exports = {
-  saveState,
-  loadState,
-  appendLog,
-  readLog,
-  createLaneState,
-  updateLaneState,
-  createConversationEntry,
-  createGitLogEntry,
-  createEventEntry,
-  getLatestRunDir,
-  listLanesInRun,
-  getLaneStateSummary,
-};

package/src/utils/types.ts

@@ -0,0 +1,134 @@
+/**
+ * Shared type definitions for CursorFlow
+ */
+
+export interface LaneConfig {
+  devPort: number;
+  autoCreatePr: boolean;
+}
+
+export interface CursorFlowConfig {
+  tasksDir: string;
+  logsDir: string;
+  baseBranch: string;
+  branchPrefix: string;
+  executor: 'cursor-agent' | 'cloud';
+  pollInterval: number;
+  allowDependencyChange: boolean;
+  lockfileReadOnly: boolean;
+  enableReview: boolean;
+  reviewModel: string;
+  maxReviewIterations: number;
+  defaultLaneConfig: LaneConfig;
+  logLevel: string;
+  verboseGit: boolean;
+  worktreePrefix: string;
+  maxConcurrentLanes: number;
+  projectRoot: string;
+}
+
+export interface DependencyPolicy {
+  allowDependencyChange: boolean;
+  lockfileReadOnly: boolean;
+}
+
+export interface Task {
+  name: string;
+  prompt: string;
+  model?: string;
+}
+
+export interface RunnerConfig {
+  tasks: Task[];
+  pipelineBranch?: string;
+  branchPrefix?: string;
+  worktreeRoot?: string;
+  baseBranch?: string;
+  model?: string;
+  dependencyPolicy: DependencyPolicy;
+  reviewModel?: string;
+  maxReviewIterations?: number;
+  acceptanceCriteria?: string[];
+}
+
+export interface DependencyRequestPlan {
+  reason: string;
+  changes: string[];
+  commands: string[];
+  notes?: string;
+}
+
+export interface TaskExecutionResult {
+  taskName: string;
+  taskBranch: string;
+  status: 'FINISHED' | 'ERROR' | 'BLOCKED_DEPENDENCY';
+  error?: string;
+  dependencyRequest?: DependencyRequestPlan | null;
+}
+
+export interface AgentSendResult {
+  ok: boolean;
+  exitCode: number;
+  error?: string;
+  sessionId?: string;
+  resultText?: string;
+}
+
+export interface ReviewIssue {
+  severity: 'critical' | 'major' | 'minor';
+  description: string;
+  file?: string;
+  suggestion?: string;
+}
+
+export interface ReviewResult {
+  status: 'approved' | 'needs_changes';
+  buildSuccess: boolean;
+  issues: ReviewIssue[];
+  suggestions: string[];
+  summary: string;
+  raw: string;
+}
+
+export interface TaskResult {
+  taskName: string;
+  taskBranch: string;
+  [key: string]: any;
+}
+
+export interface LaneState {
+  label: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'paused' | 'waiting' | 'reviewing';
+  currentTaskIndex: number;
+  totalTasks: number;
+  worktreeDir: string | null;
+  pipelineBranch: string | null;
+  startTime: number;
+  endTime: number | null;
+  error: string | null;
+  dependencyRequest: DependencyRequestPlan | null;
+  updatedAt?: number;
+  tasksFile?: string; // Original tasks file path
+}
+
+export interface ConversationEntry {
+  timestamp: string;
+  role: 'user' | 'assistant' | 'reviewer' | 'system';
+  task: string | null;
+  fullText: string;
+  textLength: number;
+  model: string | null;
+}
+
+export interface GitLogEntry {
+  timestamp: string;
+  operation: string;
+  [key: string]: any;
+}
+
+export interface EventEntry {
+  timestamp: string;
+  event: string;
+  [key: string]: any;
+}
+

package/src/cli/resume.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-/**
- * CursorFlow resume command (stub)
- */
-
-const logger = require('../utils/logger');
-
-function parseArgs(args) {
-  return {
-    lane: args[0],
-    runDir: null,
-    clean: args.includes('--clean'),
-    restart: args.includes('--restart'),
-  };
-}
-
-async function resume(args) {
-  logger.section('🔁 Resuming Lane');
-  
-  const options = parseArgs(args);
-  
-  logger.info('This command will be fully implemented in the next phase');
-  logger.info(`Lane: ${options.lane}`);
-  logger.info(`Clean: ${options.clean}`);
-  logger.info(`Restart: ${options.restart}`);
-  
-  logger.warn('\n⚠️  Implementation pending');
-  logger.info('This will resume interrupted lanes');
-}
-
-module.exports = resume;

package/src/cli/run.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-/**
- * CursorFlow run command
- */
-
-const path = require('path');
-const fs = require('fs');
-const logger = require('../utils/logger');
-const { orchestrate } = require('../core/orchestrator');
-const { loadConfig } = require('../utils/config');
-
-function parseArgs(args) {
-  return {
-    tasksDir: args.find(a => !a.startsWith('--')),
-    dryRun: args.includes('--dry-run'),
-    executor: args[args.indexOf('--executor') + 1] || null,
-  };
-}
-
-async function run(args) {
-  const options = parseArgs(args);
-  
-  if (!options.tasksDir) {
-    logger.error('Tasks directory required');
-    console.log('\nUsage: cursorflow run <tasks-dir> [options]');
-    process.exit(1);
-  }
-  
-  if (!fs.existsSync(options.tasksDir)) {
-    logger.error(`Tasks directory not found: ${options.tasksDir}`);
-    process.exit(1);
-  }
-  
-  const config = loadConfig();
-  
-  try {
-    await orchestrate(options.tasksDir, {
-      executor: options.executor || config.executor,
-      pollInterval: config.pollInterval * 1000,
-      runDir: path.join(config.logsDir, 'runs', `run-${Date.now()}`),
-    });
-  } catch (error) {
-    logger.error(`Orchestration failed: ${error.message}`);
-    if (process.env.DEBUG) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
-}
-
-module.exports = run;