@litmers/cursorflow-orchestrator 0.1.2 → 0.1.5

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

@@ -1,178 +1,170 @@
-#!/usr/bin/env node
-/**
- * Logging utilities for CursorFlow
- */
-
-const LOG_LEVELS = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-};
-
-const COLORS = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-  gray: '\x1b[90m',
-};
-
-let currentLogLevel = LOG_LEVELS.info;
-
-/**
- * Set log level
- */
-function setLogLevel(level) {
-  if (typeof level === 'string') {
-    currentLogLevel = LOG_LEVELS[level] ?? LOG_LEVELS.info;
-  } else {
-    currentLogLevel = level;
-  }
-}
-
-/**
- * Format message with timestamp
- */
-function formatMessage(level, message, emoji = '') {
-  const timestamp = new Date().toISOString();
-  const prefix = emoji ? `${emoji} ` : '';
-  return `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
-}
-
-/**
- * Log with color
- */
-function logWithColor(color, level, message, emoji = '') {
-  if (LOG_LEVELS[level] > currentLogLevel) {
-    return;
-  }
-  
-  const formatted = formatMessage(level, message, emoji);
-  console.log(`${color}${formatted}${COLORS.reset}`);
-}
-
-/**
- * Error log
- */
-function error(message, emoji = '❌') {
-  logWithColor(COLORS.red, 'error', message, emoji);
-}
-
-/**
- * Warning log
- */
-function warn(message, emoji = '⚠️') {
-  logWithColor(COLORS.yellow, 'warn', message, emoji);
-}
-
-/**
- * Info log
- */
-function info(message, emoji = 'ℹ️') {
-  logWithColor(COLORS.cyan, 'info', message, emoji);
-}
-
-/**
- * Success log
- */
-function success(message, emoji = '✅') {
-  logWithColor(COLORS.green, 'info', message, emoji);
-}
-
-/**
- * Debug log
- */
-function debug(message, emoji = '🔍') {
-  logWithColor(COLORS.gray, 'debug', message, emoji);
-}
-
-/**
- * Progress log
- */
-function progress(message, emoji = '🔄') {
-  logWithColor(COLORS.blue, 'info', message, emoji);
-}
-
-/**
- * Section header
- */
-function section(message) {
-  console.log('');
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
-  console.log(`${COLORS.cyan}  ${message}${COLORS.reset}`);
-  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
-  console.log('');
-}
-
-/**
- * Simple log without formatting
- */
-function log(message) {
-  console.log(message);
-}
-
-/**
- * Log JSON data (pretty print in debug mode)
- */
-function json(data) {
-  if (currentLogLevel >= LOG_LEVELS.debug) {
-    console.log(JSON.stringify(data, null, 2));
-  }
-}
-
-/**
- * Create spinner (simple implementation)
- */
-function createSpinner(message) {
-  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  let i = 0;
-  let interval = null;
-  
-  return {
-    start() {
-      process.stdout.write(`${message} ${frames[0]}`);
-      interval = setInterval(() => {
-        i = (i + 1) % frames.length;
-        process.stdout.write(`\r${message} ${frames[i]}`);
-      }, 80);
-    },
-    
-    stop(finalMessage = null) {
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
-      }
-      process.stdout.write('\r\x1b[K'); // Clear line
-      if (finalMessage) {
-        console.log(finalMessage);
-      }
-    },
-    
-    succeed(message) {
-      this.stop(`${COLORS.green}✓${COLORS.reset} ${message}`);
-    },
-    
-    fail(message) {
-      this.stop(`${COLORS.red}✗${COLORS.reset} ${message}`);
-    },
-  };
-}
-
-module.exports = {
-  setLogLevel,
-  error,
-  warn,
-  info,
-  success,
-  debug,
-  progress,
-  section,
-  log,
-  json,
-  createSpinner,
-  COLORS,
-  LOG_LEVELS,
-};
+/**
+ * Logging utilities for CursorFlow
+ */
+
+export enum LogLevel {
+  error = 0,
+  warn = 1,
+  info = 2,
+  debug = 3,
+}
+
+export const COLORS = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+};
+
+let currentLogLevel: number = LogLevel.info;
+
+/**
+ * Set log level
+ */
+export function setLogLevel(level: string | number): void {
+  if (typeof level === 'string') {
+    currentLogLevel = (LogLevel as any)[level] ?? LogLevel.info;
+  } else {
+    currentLogLevel = level;
+  }
+}
+
+/**
+ * Format message with timestamp
+ */
+function formatMessage(level: string, message: string, emoji = ''): string {
+  const timestamp = new Date().toISOString();
+  const prefix = emoji ? `${emoji} ` : '';
+  return `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
+}
+
+/**
+ * Log with color
+ */
+function logWithColor(color: string, level: keyof typeof LogLevel, message: string, emoji = ''): void {
+  if (LogLevel[level] > currentLogLevel) {
+    return;
+  }
+  
+  const formatted = formatMessage(level, message, emoji);
+  console.log(`${color}${formatted}${COLORS.reset}`);
+}
+
+/**
+ * Error log
+ */
+export function error(message: string, emoji = '❌'): void {
+  logWithColor(COLORS.red, 'error', message, emoji);
+}
+
+/**
+ * Warning log
+ */
+export function warn(message: string, emoji = '⚠️'): void {
+  logWithColor(COLORS.yellow, 'warn', message, emoji);
+}
+
+/**
+ * Info log
+ */
+export function info(message: string, emoji = 'ℹ️'): void {
+  logWithColor(COLORS.cyan, 'info', message, emoji);
+}
+
+/**
+ * Success log
+ */
+export function success(message: string, emoji = '✅'): void {
+  logWithColor(COLORS.green, 'info', message, emoji);
+}
+
+/**
+ * Debug log
+ */
+export function debug(message: string, emoji = '🔍'): void {
+  logWithColor(COLORS.gray, 'debug', message, emoji);
+}
+
+/**
+ * Progress log
+ */
+export function progress(message: string, emoji = '🔄'): void {
+  logWithColor(COLORS.blue, 'info', message, emoji);
+}
+
+/**
+ * Section header
+ */
+export function section(message: string): void {
+  console.log('');
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(`${COLORS.cyan}  ${message}${COLORS.reset}`);
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log('');
+}
+
+/**
+ * Simple log without formatting
+ */
+export function log(message: string | any): void {
+  console.log(message);
+}
+
+/**
+ * Log JSON data (pretty print in debug mode)
+ */
+export function json(data: any): void {
+  if (currentLogLevel >= LogLevel.debug) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+export interface Spinner {
+  start(): void;
+  stop(finalMessage?: string | null): void;
+  succeed(message: string): void;
+  fail(message: string): void;
+}
+
+/**
+ * Create spinner (simple implementation)
+ */
+export function createSpinner(message: string): Spinner {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  let i = 0;
+  let interval: NodeJS.Timeout | null = null;
+  
+  const spinner: Spinner = {
+    start() {
+      process.stdout.write(`${message} ${frames[0]}`);
+      interval = setInterval(() => {
+        i = (i + 1) % frames.length;
+        process.stdout.write(`\r${message} ${frames[i]}`);
+      }, 80);
+    },
+    
+    stop(finalMessage: string | null = null) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write('\r\x1b[K'); // Clear line
+      if (finalMessage) {
+        console.log(finalMessage);
+      }
+    },
+    
+    succeed(message: string) {
+      this.stop(`${COLORS.green}✓${COLORS.reset} ${message}`);
+    },
+    
+    fail(message: string) {
+      this.stop(`${COLORS.red}✗${COLORS.reset} ${message}`);
+    },
+  };
+
+  return spinner;
+}

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,133 @@
+/**
+ * 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;
+}
+
+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;
+}
+