@profoundlogic/coderflow-cli 0.2.1

package/lib/state-capture.js

@@ -0,0 +1,336 @@
+/**
+ * Local Repository State Capture (Client-side)
+ * Captures complete git state including local branches, staged/unstaged changes, untracked files
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import { promises as fs } from 'fs';
+
+const execAsync = promisify(exec);
+
+/**
+ * Execute git command in a repository
+ */
+async function execGit(repoPath, command) {
+  try {
+    const { stdout, stderr } = await execAsync(`git ${command}`, {
+      cwd: repoPath,
+      maxBuffer: 50 * 1024 * 1024, // 50MB for large diffs
+      encoding: 'utf8'
+    });
+    return stdout.trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Check if a directory is a git repository
+ */
+async function isGitRepo(dirPath) {
+  try {
+    const gitDir = await execGit(dirPath, 'rev-parse --git-dir');
+    return gitDir !== null;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect all git repositories in a directory tree
+ * @param {string} basePath - Directory to search
+ * @param {Array} repoConfigs - Repository configurations from environment.json with name, path, etc.
+ * @returns {Object} Map of repoName -> absolutePath
+ */
+async function discoverRepos(basePath, repoConfigs) {
+  const discovered = {};
+
+  // Strategy 1: Use configured paths from environment.json
+  for (const repoConfig of repoConfigs) {
+    if (discovered[repoConfig.name]) continue;
+
+    // Use the path from config, or fall back to name
+    const repoPath = repoConfig.path || repoConfig.name;
+
+    // Try the path relative to basePath
+    const fullPath = path.join(basePath, repoPath);
+    try {
+      if (await isGitRepo(fullPath)) {
+        discovered[repoConfig.name] = fullPath;
+        continue;
+      }
+    } catch {
+      // Path doesn't exist
+    }
+
+    // Try parent directory + configured path
+    const parentPath = path.resolve(basePath, '..');
+    const parentFullPath = path.join(parentPath, repoPath);
+    try {
+      if (await isGitRepo(parentFullPath)) {
+        discovered[repoConfig.name] = parentFullPath;
+        continue;
+      }
+    } catch {
+      // Path doesn't exist
+    }
+  }
+
+  // Strategy 2: Check if basePath itself is one of the repos
+  const baseRepoName = path.basename(basePath);
+  const baseRepo = repoConfigs.find(r => r.name === baseRepoName);
+  if (baseRepo && !discovered[baseRepoName] && await isGitRepo(basePath)) {
+    discovered[baseRepoName] = basePath;
+  }
+
+  // Strategy 3: Search nested directories as fallback (for repos not yet configured with paths)
+  async function searchNested(dir, depth = 0) {
+    if (depth > 2) return; // Don't search too deep
+
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (!entry.isDirectory() || entry.name.startsWith('.') || entry.name === 'node_modules') {
+          continue;
+        }
+
+        const fullPath = path.join(dir, entry.name);
+
+        // Check if this directory matches any repo name
+        const matchingRepo = repoConfigs.find(r => r.name === entry.name);
+        if (matchingRepo && !discovered[matchingRepo.name]) {
+          if (await isGitRepo(fullPath)) {
+            discovered[matchingRepo.name] = fullPath;
+          }
+        }
+
+        // Recurse into subdirectories
+        await searchNested(fullPath, depth + 1);
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  await searchNested(basePath);
+
+  return discovered;
+}
+
+/**
+ * Get contents of untracked files
+ */
+async function getUntrackedFiles(repoPath) {
+  const untrackedList = await execGit(repoPath, 'ls-files --others --exclude-standard');
+  if (!untrackedList) return {};
+
+  const files = {};
+  const fileNames = untrackedList.split('\n').filter(f => f.trim());
+
+  for (const fileName of fileNames) {
+    const filePath = path.join(repoPath, fileName);
+    try {
+      // Check file size first (skip large files)
+      const stats = await fs.stat(filePath);
+      if (stats.size > 1024 * 1024) { // Skip files > 1MB
+        console.warn(`Skipping large untracked file: ${fileName} (${stats.size} bytes)`);
+        continue;
+      }
+
+      const content = await fs.readFile(filePath, 'utf8');
+      files[fileName] = content;
+    } catch (error) {
+      console.warn(`Could not read untracked file ${fileName}: ${error.message}`);
+    }
+  }
+
+  return files;
+}
+
+/**
+ * Capture complete state of a single repository
+ */
+async function captureRepoState(repoPath, repoName) {
+  const currentBranch = await execGit(repoPath, 'rev-parse --abbrev-ref HEAD');
+  if (!currentBranch) {
+    throw new Error(`Could not determine current branch for ${repoName}`);
+  }
+
+  // Check if branch exists on remote
+  const remoteBranch = await execGit(repoPath, 'rev-parse --abbrev-ref @{u}');
+  const isRemoteTracking = remoteBranch !== null;
+
+  const state = {
+    repo_name: repoName,
+    repo_path: repoPath,
+    current_branch: currentBranch,
+    is_remote_tracking: isRemoteTracking,
+    remote_branch: remoteBranch,
+  };
+
+  // Capture local commits (both local-only branches and unpushed commits on remote-tracking branches)
+  let baseBranch = null;
+  let commitsAhead = 0;
+
+  if (isRemoteTracking) {
+    // Remote-tracking branch - check for unpushed commits
+    const remoteBranchRef = `origin/${currentBranch}`;
+    const remoteExists = await execGit(repoPath, `rev-parse --verify ${remoteBranchRef} 2>/dev/null`);
+
+    if (remoteExists) {
+      baseBranch = remoteBranchRef;
+      const ahead = await execGit(repoPath, `rev-list --count ${remoteBranchRef}..HEAD`);
+      commitsAhead = parseInt(ahead) || 0;
+    }
+  } else if (currentBranch !== 'HEAD') {
+    // Local-only branch - find base branch point
+    for (const candidate of ['dev', 'main', 'master']) {
+      const exists = await execGit(repoPath, `rev-parse --verify ${candidate} 2>/dev/null`);
+      if (exists) {
+        baseBranch = candidate;
+        break;
+      }
+    }
+
+    if (baseBranch) {
+      const ahead = await execGit(repoPath, `rev-list --count ${baseBranch}..HEAD`);
+      commitsAhead = parseInt(ahead) || 0;
+    }
+  }
+
+  // Capture commit patches if we have commits ahead
+  if (baseBranch && commitsAhead > 0) {
+    state.base_branch = baseBranch;
+    state.commits_ahead = commitsAhead;
+
+    const commitPatch = await execGit(repoPath, `format-patch ${baseBranch}..HEAD --stdout`);
+    if (commitPatch) {
+      state.commit_patch = commitPatch;
+    }
+  }
+
+  // Capture uncommitted changes (unstaged working directory changes)
+  const unstaged = await execGit(repoPath, 'diff HEAD');
+  if (unstaged) {
+    state.unstaged = unstaged;
+  }
+
+  // Capture staged changes
+  const staged = await execGit(repoPath, 'diff --cached');
+  if (staged) {
+    state.staged = staged;
+  }
+
+  // Capture untracked files
+  const untracked = await getUntrackedFiles(repoPath);
+  const untrackedCount = Object.keys(untracked).length;
+  if (untrackedCount > 0) {
+    state.untracked_files = untracked;
+  }
+
+  // Get current commit hash for reference
+  state.current_commit = await execGit(repoPath, 'rev-parse HEAD');
+
+  // Get remote URL for verification
+  state.remote_url = await execGit(repoPath, 'config --get remote.origin.url');
+
+  return state;
+}
+
+/**
+ * Main function: Capture state of all repositories
+ *
+ * @param {string} sourcePath - Directory to search for repos (typically cwd)
+ * @param {Array} repoConfigs - Repository configurations from environment.json (objects with name, path, etc.)
+ * @returns {Promise<Object>} Complete state object
+ */
+export async function captureAllRepos(sourcePath, repoConfigs) {
+  const repoNames = repoConfigs.map(r => r.name);
+
+  // Discover repositories
+  const discovered = await discoverRepos(sourcePath, repoConfigs);
+
+  const foundCount = Object.keys(discovered).length;
+
+  if (foundCount === 0) {
+    const error = `No repositories found!
+
+Expected repos: ${repoNames.join(', ')}
+Search path: ${sourcePath}
+
+Please run this command from:
+  - The parent directory containing all repos, or
+  - Inside one of the repository directories
+
+The system will automatically discover repos in the current directory,
+subdirectories, and parent directory.`;
+
+    throw new Error(error);
+  }
+
+  // Warn about missing repos
+  const missing = repoNames.filter(r => !discovered[r]);
+  if (missing.length > 0) {
+    console.warn(`Warning: Missing repositories: ${missing.join(', ')} - will use container defaults`);
+  }
+
+  // Capture state for each discovered repo
+  const states = {};
+  for (const [repoName, repoPath] of Object.entries(discovered)) {
+    try {
+      states[repoName] = await captureRepoState(repoPath, repoName);
+    } catch (error) {
+      throw new Error(`Failed to capture state for ${repoName}: ${error.message}`);
+    }
+  }
+
+  return {
+    captured_at: new Date().toISOString(),
+    source_path: sourcePath,
+    repositories: states,
+    repos_found: Object.keys(states),
+    repos_missing: missing
+  };
+}
+
+/**
+ * Validate that captured state can be applied
+ * Returns validation result with any errors
+ */
+export function validateState(stateObj) {
+  const errors = [];
+  const warnings = [];
+
+  if (!stateObj.repositories || Object.keys(stateObj.repositories).length === 0) {
+    errors.push('No repositories in state object');
+    return { valid: false, errors, warnings };
+  }
+
+  for (const [repoName, state] of Object.entries(stateObj.repositories)) {
+    if (!state.current_branch) {
+      errors.push(`${repoName}: Missing current_branch`);
+    }
+
+    // Warn about very large patches (but don't fail)
+    if (state.commit_patch && state.commit_patch.length > 10 * 1024 * 1024) {
+      warnings.push(`${repoName}: Commit patch is very large (${(state.commit_patch.length / 1024 / 1024).toFixed(1)}MB)`);
+    }
+
+    if (state.unstaged && state.unstaged.length > 10 * 1024 * 1024) {
+      warnings.push(`${repoName}: Unstaged diff is very large (${(state.unstaged.length / 1024 / 1024).toFixed(1)}MB)`);
+    }
+
+    if (state.untracked_files && Object.keys(state.untracked_files).length > 100) {
+      warnings.push(`${repoName}: Many untracked files (${Object.keys(state.untracked_files).length})`);
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}

package/lib/task-grouping.js

@@ -0,0 +1,210 @@
+/**
+ * Task grouping utilities - mirrors the web UI grouping logic
+ */
+
+/**
+ * Compare parameters excluding 'instructions' field
+ */
+function areParametersEqual(params1, params2) {
+  const keys1 = Object.keys(params1 || {}).filter(k => k !== 'instructions').sort();
+  const keys2 = Object.keys(params2 || {}).filter(k => k !== 'instructions').sort();
+
+  if (keys1.length !== keys2.length) return false;
+
+  return keys1.every(key => params1[key] === params2[key]);
+}
+
+/**
+ * Group related tasks as variants
+ * Criteria:
+ * - Same environment
+ * - Same taskType
+ * - Same testName (if task_type is 'test')
+ * - Same parameters (excluding instructions)
+ * - Created within 25 seconds of each other
+ */
+export function groupRelatedTasks(tasks) {
+  const groups = [];
+  const seen = new Set();
+
+  for (const task of tasks) {
+    if (seen.has(task.taskId)) continue;
+
+    // Find all tasks submitted ~same time with same params
+    const related = tasks.filter(t =>
+      !seen.has(t.taskId) &&
+      t.environment === task.environment &&
+      t.taskType === task.taskType &&
+      (t.taskType !== 'test' || t.testName === task.testName) &&
+      areParametersEqual(t.parameters, task.parameters) &&
+      Math.abs(new Date(t.createdAt) - new Date(task.createdAt)) < 25000
+    );
+
+    if (related.length > 1) {
+      // Sort variants by agent (claude first, then codex) and creation time
+      const sorted = related.sort((a, b) => {
+        const agentA = a.envVars?.CODER_AGENT || a.envVars?.default_agent || '';
+        const agentB = b.envVars?.CODER_AGENT || b.envVars?.default_agent || '';
+        if (agentA !== agentB) {
+          // Sort claude before codex
+          if (agentA === 'claude') return -1;
+          if (agentB === 'claude') return 1;
+        }
+        // Same agent, sort by creation time
+        const timeA = new Date(a.createdAt).getTime();
+        const timeB = new Date(b.createdAt).getTime();
+        return timeA - timeB;
+      });
+
+      groups.push({
+        primary: sorted[0],
+        variants: sorted,
+        isGroup: true
+      });
+      related.forEach(t => seen.add(t.taskId));
+    } else {
+      groups.push({
+        primary: task,
+        variants: [task],
+        isGroup: false
+      });
+      seen.add(task.taskId);
+    }
+  }
+
+  return groups;
+}
+
+/**
+ * Get a brief description of what the task did
+ */
+function getTaskDescription(task) {
+  // Try summary first (if included from server)
+  if (task.summary) {
+    // Extract first line or first 80 chars
+    const firstLine = task.summary.split('\n')[0].trim();
+
+    // Skip generic completion messages
+    if (firstLine.includes('completed successfully') ||
+        firstLine.includes('Task completed') ||
+        firstLine.match(/^Task \d+-\w+ completed/)) {
+      // Skip this line, try second line if available
+      const lines = task.summary.split('\n');
+      if (lines.length > 1) {
+        const secondLine = lines[1].trim();
+        if (secondLine && secondLine.length > 0) {
+          if (secondLine.length > 80) {
+            return secondLine.substring(0, 77) + '...';
+          }
+          return secondLine;
+        }
+      }
+      // Fall through to try instructions
+    } else {
+      if (firstLine.length > 80) {
+        return firstLine.substring(0, 77) + '...';
+      }
+      return firstLine;
+    }
+  }
+
+  // Try parameters.instructions
+  if (task.parameters?.instructions) {
+    const firstLine = task.parameters.instructions.split('\n')[0].trim();
+    if (firstLine.length > 80) {
+      return firstLine.substring(0, 77) + '...';
+    }
+    return firstLine;
+  }
+
+  // Try test name
+  if (task.taskType === 'test' && task.testName) {
+    return `Test: ${task.testName}`;
+  }
+
+  // Try task type
+  if (task.taskType && task.taskType !== 'manual') {
+    return task.taskType;
+  }
+
+  // Fallback
+  return 'No description';
+}
+
+/**
+ * Format a relative time string
+ */
+function formatRelativeTime(date) {
+  const now = new Date();
+  const diffMs = now - date;
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return 'just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays === 1) return 'yesterday';
+  if (diffDays < 7) return `${diffDays}d ago`;
+
+  // For older tasks, show date
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${month}/${day}`;
+}
+
+/**
+ * Format a task for display in selection list
+ * @param {Object} task - The task to format
+ * @param {boolean} isVariant - Whether this is a variant display (for sub-menu)
+ * @param {boolean} showAgent - Whether to show the agent badge (default: true)
+ */
+export function formatTaskForDisplay(task, isVariant = false, showAgent = true) {
+  const agent = task.envVars?.CODER_AGENT || task.envVars?.default_agent || 'unknown';
+  const date = new Date(task.createdAt);
+  const timeStr = formatRelativeTime(date);
+
+  // Agent badge with color indicator
+  const agentBadge = agent === 'claude' ? 'Claude' :
+                     agent === 'codex' ? 'Codex' :
+                     agent;
+
+  let label = '';
+
+  if (isVariant) {
+    // Variant display (for sub-menu) - show task ID, agent, and time
+    label = `${task.taskId} • ${agentBadge} • ${timeStr}`;
+  } else {
+    // Primary task display - show description, environment, time, and optionally agent
+    const description = getTaskDescription(task);
+    const env = task.environment || 'default';
+
+    if (showAgent) {
+      label = `${description} • ${agentBadge} • ${env} • ${timeStr}`;
+    } else {
+      label = `${description} • ${env} • ${timeStr}`;
+    }
+  }
+
+  return label;
+}
+
+/**
+ * Format a task group for display in selection list
+ */
+export function formatGroupForDisplay(group) {
+  const task = group.primary;
+  const variantCount = group.variants.length;
+
+  // For multi-agent groups, don't show the agent badge since it would be misleading
+  // (only shows one agent when there are multiple)
+  const showAgent = !group.isGroup || variantCount === 1;
+  let label = formatTaskForDisplay(task, false, showAgent);
+
+  // Add variant count if this is a group with multiple variants
+  if (group.isGroup && variantCount > 1) {
+    label += ` (${variantCount} agents)`;
+  }
+
+  return label;
+}

package/lib/terminal-client.js

@@ -0,0 +1,162 @@
+/**
+ * WebSocket terminal client
+ * Connects to server's terminal WebSocket and provides interactive terminal
+ */
+
+import { WebSocket } from 'ws';
+import { getServerUrl } from './config.js';
+
+/**
+ * Connect to server's WebSocket terminal and provide interactive session
+ * @param {string} containerId - Container ID
+ * @param {string} cmd - Command to execute (optional)
+ * @returns {Promise<number>} Exit code
+ */
+export async function connectTerminal(containerId, cmd = null) {
+  const serverUrl = await getServerUrl();
+
+  // Convert HTTP URL to WebSocket URL
+  const wsUrl = new URL(serverUrl);
+  wsUrl.protocol = wsUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+  wsUrl.pathname = `/ws/containers/${encodeURIComponent(containerId)}`;
+  if (cmd) {
+    wsUrl.searchParams.set('cmd', cmd);
+  }
+
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl.toString());
+    let connected = false;
+
+    ws.on('open', () => {
+      connected = true;
+    });
+
+    ws.on('message', (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+
+        if (message.type === 'status') {
+          if (message.status === 'connected') {
+            // Terminal connected - set up stdin forwarding
+            setupStdinForwarding(ws);
+          } else if (message.status === 'terminated') {
+            // Terminal session ended normally
+            cleanupStdin();
+            ws.close();
+            resolve(0);
+          }
+        } else if (message.type === 'data') {
+          // Output from terminal
+          process.stdout.write(message.data);
+        } else if (message.type === 'error') {
+          // Error from server
+          console.error(`\nTerminal error: ${message.message}`);
+          cleanupStdin();
+          ws.close();
+          resolve(1);
+        }
+      } catch (error) {
+        // Ignore JSON parse errors
+      }
+    });
+
+    ws.on('error', (error) => {
+      if (!connected) {
+        console.error(`\nFailed to connect to server terminal: ${error.message}`);
+        console.error('\nPossible solutions:');
+        console.error('  1. Check that the server is running');
+        console.error('  2. Verify CODER_SERVER_URL is correct');
+        console.error('  3. Ensure the container still exists');
+      } else {
+        console.error(`\nWebSocket error: ${error.message}`);
+      }
+      cleanupStdin();
+      reject(error);
+    });
+
+    ws.on('close', (code, reason) => {
+      cleanupStdin();
+      if (!connected) {
+        resolve(1);
+      } else if (code !== 1000) {
+        // Non-normal closure
+        console.error(`\nConnection closed: ${reason || 'Unknown reason'}`);
+        resolve(1);
+      }
+      // Normal closure already handled by 'terminated' status
+    });
+
+    // Handle Ctrl+C gracefully
+    process.on('SIGINT', () => {
+      cleanupStdin();
+      ws.close();
+      resolve(130); // Standard exit code for SIGINT
+    });
+  });
+}
+
+/**
+ * Set up stdin forwarding to WebSocket
+ */
+function setupStdinForwarding(ws) {
+  // Set stdin to raw mode for interactive terminal
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  // Forward stdin to WebSocket
+  const stdinHandler = (data) => {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: 'data', data }));
+    }
+  };
+
+  process.stdin.on('data', stdinHandler);
+
+  // Store handler for cleanup
+  process.stdin._terminalHandler = stdinHandler;
+
+  // Handle terminal resize events
+  if (process.stdout.isTTY) {
+    const sendResize = () => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({
+          type: 'resize',
+          cols: process.stdout.columns,
+          rows: process.stdout.rows
+        }));
+      }
+    };
+
+    // Send initial size
+    sendResize();
+
+    // Send on resize
+    process.stdout.on('resize', sendResize);
+    process.stdout._resizeHandler = sendResize;
+  }
+}
+
+/**
+ * Clean up stdin handlers and restore terminal state
+ */
+function cleanupStdin() {
+  if (process.stdin._terminalHandler) {
+    process.stdin.removeListener('data', process.stdin._terminalHandler);
+    delete process.stdin._terminalHandler;
+  }
+
+  if (process.stdout._resizeHandler) {
+    process.stdout.removeListener('resize', process.stdout._resizeHandler);
+    delete process.stdout._resizeHandler;
+  }
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(false);
+  }
+
+  process.stdin.pause();
+}