@litmers/cursorflow-orchestrator 0.1.0

package/src/utils/git.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Git utilities for CursorFlow
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Run git command and return output
+ */
+function runGit(args, options = {}) {
+  const { cwd, silent = false } = options;
+  
+  try {
+    const result = execSync(`git ${args.join(' ')}`, {
+      cwd: cwd || process.cwd(),
+      encoding: 'utf8',
+      stdio: silent ? 'pipe' : 'inherit',
+    });
+    return result ? result.trim() : '';
+  } catch (error) {
+    if (silent) {
+      return '';
+    }
+    throw error;
+  }
+}
+
+/**
+ * Run git command and return result object
+ */
+function runGitResult(args, options = {}) {
+  const { cwd } = options;
+  
+  const result = spawnSync('git', args, {
+    cwd: cwd || process.cwd(),
+    encoding: 'utf8',
+    stdio: 'pipe',
+  });
+  
+  return {
+    exitCode: result.status ?? 1,
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+    success: result.status === 0,
+  };
+}
+
+/**
+ * Get current branch name
+ */
+function getCurrentBranch(cwd) {
+  return runGit(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, silent: true });
+}
+
+/**
+ * Get repository root directory
+ */
+function getRepoRoot(cwd) {
+  return runGit(['rev-parse', '--show-toplevel'], { cwd, silent: true });
+}
+
+/**
+ * Check if directory is a git repository
+ */
+function isGitRepo(cwd) {
+  const result = runGitResult(['rev-parse', '--git-dir'], { cwd });
+  return result.success;
+}
+
+/**
+ * Check if worktree exists
+ */
+function worktreeExists(worktreePath, cwd) {
+  const result = runGitResult(['worktree', 'list'], { cwd });
+  if (!result.success) return false;
+  
+  return result.stdout.includes(worktreePath);
+}
+
+/**
+ * Create worktree
+ */
+function createWorktree(worktreePath, branchName, options = {}) {
+  const { cwd, baseBranch = 'main' } = options;
+  
+  // Check if branch already exists
+  const branchExists = runGitResult(['rev-parse', '--verify', branchName], { cwd }).success;
+  
+  if (branchExists) {
+    // Branch exists, checkout to worktree
+    runGit(['worktree', 'add', worktreePath, branchName], { cwd });
+  } else {
+    // Create new branch from base
+    runGit(['worktree', 'add', '-b', branchName, worktreePath, baseBranch], { cwd });
+  }
+  
+  return worktreePath;
+}
+
+/**
+ * Remove worktree
+ */
+function removeWorktree(worktreePath, options = {}) {
+  const { cwd, force = false } = options;
+  
+  const args = ['worktree', 'remove', worktreePath];
+  if (force) {
+    args.push('--force');
+  }
+  
+  runGit(args, { cwd });
+}
+
+/**
+ * List all worktrees
+ */
+function listWorktrees(cwd) {
+  const result = runGitResult(['worktree', 'list', '--porcelain'], { cwd });
+  if (!result.success) return [];
+  
+  const worktrees = [];
+  const lines = result.stdout.split('\n');
+  let current = {};
+  
+  for (const line of lines) {
+    if (line.startsWith('worktree ')) {
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = { path: line.slice(9) };
+    } else if (line.startsWith('branch ')) {
+      current.branch = line.slice(7);
+    } else if (line.startsWith('HEAD ')) {
+      current.head = line.slice(5);
+    }
+  }
+  
+  if (current.path) {
+    worktrees.push(current);
+  }
+  
+  return worktrees;
+}
+
+/**
+ * Check if there are uncommitted changes
+ */
+function hasUncommittedChanges(cwd) {
+  const result = runGitResult(['status', '--porcelain'], { cwd });
+  return result.success && result.stdout.length > 0;
+}
+
+/**
+ * Get list of changed files
+ */
+function getChangedFiles(cwd) {
+  const result = runGitResult(['status', '--porcelain'], { cwd });
+  if (!result.success) return [];
+  
+  return result.stdout
+    .split('\n')
+    .filter(line => line.trim())
+    .map(line => {
+      const status = line.slice(0, 2);
+      const file = line.slice(3);
+      return { status, file };
+    });
+}
+
+/**
+ * Create commit
+ */
+function commit(message, options = {}) {
+  const { cwd, addAll = true } = options;
+  
+  if (addAll) {
+    runGit(['add', '-A'], { cwd });
+  }
+  
+  runGit(['commit', '-m', message], { cwd });
+}
+
+/**
+ * Push to remote
+ */
+function push(branchName, options = {}) {
+  const { cwd, force = false, setUpstream = false } = options;
+  
+  const args = ['push'];
+  
+  if (force) {
+    args.push('--force');
+  }
+  
+  if (setUpstream) {
+    args.push('-u', 'origin', branchName);
+  } else {
+    args.push('origin', branchName);
+  }
+  
+  runGit(args, { cwd });
+}
+
+/**
+ * Fetch from remote
+ */
+function fetch(options = {}) {
+  const { cwd, prune = true } = options;
+  
+  const args = ['fetch', 'origin'];
+  if (prune) {
+    args.push('--prune');
+  }
+  
+  runGit(args, { cwd });
+}
+
+/**
+ * Check if branch exists (local or remote)
+ */
+function branchExists(branchName, options = {}) {
+  const { cwd, remote = false } = options;
+  
+  if (remote) {
+    const result = runGitResult(['ls-remote', '--heads', 'origin', branchName], { cwd });
+    return result.success && result.stdout.length > 0;
+  } else {
+    const result = runGitResult(['rev-parse', '--verify', branchName], { cwd });
+    return result.success;
+  }
+}
+
+/**
+ * Delete branch
+ */
+function deleteBranch(branchName, options = {}) {
+  const { cwd, force = false, remote = false } = options;
+  
+  if (remote) {
+    runGit(['push', 'origin', '--delete', branchName], { cwd });
+  } else {
+    const args = ['branch', force ? '-D' : '-d', branchName];
+    runGit(args, { cwd });
+  }
+}
+
+/**
+ * Merge branch
+ */
+function merge(branchName, options = {}) {
+  const { cwd, noFf = false, message = null } = options;
+  
+  const args = ['merge'];
+  
+  if (noFf) {
+    args.push('--no-ff');
+  }
+  
+  if (message) {
+    args.push('-m', message);
+  }
+  
+  args.push(branchName);
+  
+  runGit(args, { cwd });
+}
+
+/**
+ * Get commit info
+ */
+function getCommitInfo(commitHash, options = {}) {
+  const { cwd } = options;
+  
+  const format = '--format=%H%n%h%n%an%n%ae%n%at%n%s';
+  const result = runGitResult(['show', '-s', format, commitHash], { cwd });
+  
+  if (!result.success) return null;
+  
+  const lines = result.stdout.split('\n');
+  return {
+    hash: lines[0],
+    shortHash: lines[1],
+    author: lines[2],
+    authorEmail: lines[3],
+    timestamp: parseInt(lines[4]),
+    subject: lines[5],
+  };
+}
+
+module.exports = {
+  runGit,
+  runGitResult,
+  getCurrentBranch,
+  getRepoRoot,
+  isGitRepo,
+  worktreeExists,
+  createWorktree,
+  removeWorktree,
+  listWorktrees,
+  hasUncommittedChanges,
+  getChangedFiles,
+  commit,
+  push,
+  fetch,
+  branchExists,
+  deleteBranch,
+  merge,
+  getCommitInfo,
+};

package/src/utils/logger.js

@@ -0,0 +1,178 @@
+#!/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,
+};

package/src/utils/state.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * State management utilities for CursorFlow
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Save state to JSON file
+ */
+function saveState(statePath, state) {
+  const stateDir = path.dirname(statePath);
+  
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+  
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+
+/**
+ * Load state from JSON file
+ */
+function loadState(statePath) {
+  if (!fs.existsSync(statePath)) {
+    return null;
+  }
+  
+  try {
+    const content = fs.readFileSync(statePath, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Warning: Failed to parse state file ${statePath}: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Append to JSONL log file
+ */
+function appendLog(logPath, entry) {
+  const logDir = path.dirname(logPath);
+  
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  
+  const line = JSON.stringify(entry) + '\n';
+  fs.appendFileSync(logPath, line, 'utf8');
+}
+
+/**
+ * Read JSONL log file
+ */
+function readLog(logPath) {
+  if (!fs.existsSync(logPath)) {
+    return [];
+  }
+  
+  try {
+    const content = fs.readFileSync(logPath, 'utf8');
+    return content
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line));
+  } catch (error) {
+    console.warn(`Warning: Failed to parse log file ${logPath}: ${error.message}`);
+    return [];
+  }
+}
+
+/**
+ * Create initial lane state
+ */
+function createLaneState(laneName, config) {
+  return {
+    label: laneName,
+    status: 'pending',
+    currentTaskIndex: 0,
+    totalTasks: config.tasks ? config.tasks.length : 0,
+    worktreeDir: null,
+    pipelineBranch: null,
+    startTime: Date.now(),
+    endTime: null,
+    error: null,
+    dependencyRequest: null,
+  };
+}
+
+/**
+ * Update lane state
+ */
+function updateLaneState(state, updates) {
+  return {
+    ...state,
+    ...updates,
+    updatedAt: Date.now(),
+  };
+}
+
+/**
+ * Create conversation log entry
+ */
+function createConversationEntry(role, text, options = {}) {
+  return {
+    timestamp: new Date().toISOString(),
+    role,  // 'user' | 'assistant' | 'reviewer' | 'system'
+    task: options.task || null,
+    fullText: text,
+    textLength: text.length,
+    model: options.model || null,
+  };
+}
+
+/**
+ * Create git operation log entry
+ */
+function createGitLogEntry(operation, details = {}) {
+  return {
+    timestamp: new Date().toISOString(),
+    operation,  // 'commit' | 'push' | 'merge' | 'worktree-add' | etc.
+    ...details,
+  };
+}
+
+/**
+ * Create event log entry
+ */
+function createEventEntry(event, data = {}) {
+  return {
+    timestamp: new Date().toISOString(),
+    event,
+    ...data,
+  };
+}
+
+/**
+ * Get latest run directory
+ */
+function getLatestRunDir(logsDir) {
+  if (!fs.existsSync(logsDir)) {
+    return null;
+  }
+  
+  const runs = fs.readdirSync(logsDir)
+    .filter(f => fs.statSync(path.join(logsDir, f)).isDirectory())
+    .sort()
+    .reverse();
+  
+  if (runs.length === 0) {
+    return null;
+  }
+  
+  return path.join(logsDir, runs[0]);
+}
+
+/**
+ * List all lanes in a run directory
+ */
+function listLanesInRun(runDir) {
+  if (!fs.existsSync(runDir)) {
+    return [];
+  }
+  
+  return fs.readdirSync(runDir)
+    .filter(f => fs.statSync(path.join(runDir, f)).isDirectory())
+    .map(laneName => ({
+      name: laneName,
+      dir: path.join(runDir, laneName),
+      statePath: path.join(runDir, laneName, 'state.json'),
+    }));
+}
+
+/**
+ * Get lane state summary
+ */
+function getLaneStateSummary(statePath) {
+  const state = loadState(statePath);
+  if (!state) {
+    return { status: 'unknown', progress: '-' };
+  }
+  
+  const progress = `${(state.currentTaskIndex || 0) + 1}/${state.totalTasks || '?'}`;
+  
+  return {
+    status: state.status || 'unknown',
+    progress,
+    label: state.label,
+    error: state.error,
+  };
+}
+
+module.exports = {
+  saveState,
+  loadState,
+  appendLog,
+  readLog,
+  createLaneState,
+  updateLaneState,
+  createConversationEntry,
+  createGitLogEntry,
+  createEventEntry,
+  getLatestRunDir,
+  listLanesInRun,
+  getLaneStateSummary,
+};