@magnusekdahl/parallix 1.2.0 → 1.3.0

package/lib/commands/status.ts

@@ -0,0 +1,219 @@
+import { detectRebaseState, getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } from '../core/git.js';
+import { findTaskFile, getTaskStatus } from '../tools/backlog.js';
+import { findMissionDir, findCheckpoints, getFirstLine, inferSlug, missionBranchPrefix, missionBranchName, getPrimaryWorktree } from '../core/mission-utils.js';
+import { WORKFLOW_AGENT_NAMES, eligibleAgentsForStep, readAgentConfigOrExit, workflowLauncherStatus } from '../agents/agents.js';
+import { getPrStatus } from '../tools/forgejo.js';
+import * as path from 'node:path';
+import * as fmt from '../core/fmt.js';
+
+/** @param {string} porcelain */
+function parseWorktreeList(porcelain: string) {
+  const entries = [];
+  /** @type{{path: string, branch: string | null} | null} */
+  let current: { path: string; branch: string | null } | null = null;
+
+  for (const line of porcelain.split('\n')) {
+    if (!line.trim()) {
+      if (current) {
+        entries.push(current);
+        current = null;
+      }
+      continue;
+    }
+
+    if (line.startsWith('worktree ')) {
+      if (current) {entries.push(current);}
+      current = { path: line.slice('worktree '.length).trim(), branch: null };
+      continue;
+    }
+
+    if (line.startsWith('branch ') && current) {
+      current.branch = line.slice('branch '.length).trim() as string;
+    }
+  }
+
+  if (current) {entries.push(current);}
+  return entries;
+}
+
+function findStaleMissionWorktrees({
+  gitRun = run,
+  findTaskFileFn = findTaskFile,
+  getTaskStatusFn = getTaskStatus,
+  primaryWorktree = null
+} = {}) {
+  const result = gitRun('git', ['worktree', 'list', '--porcelain']);
+  if (result.status !== 0) {
+    return [];
+  }
+
+  /** @type {string | null} */
+  let resolvedPrimary: string | null = primaryWorktree;
+  if (!resolvedPrimary) {
+    try {
+      resolvedPrimary = getPrimaryWorktree();
+    } catch (_) {
+      resolvedPrimary = null;
+    }
+  }
+
+  return parseWorktreeList(result.stdout)
+    .filter(entry => entry.path !== resolvedPrimary)
+    .map(entry => {
+      const branchRef = entry.branch || '';
+      const prefix = missionBranchPrefix(resolvedPrimary || process.cwd());
+      const normalizedRefPrefix = `refs/heads/${prefix}`;
+      const match = branchRef.startsWith(normalizedRefPrefix)
+        ? [branchRef, branchRef.slice(normalizedRefPrefix.length)]
+        : null;
+      if (!match) {return null;}
+
+      const slug = match[1];
+      const taskFile = findTaskFileFn(slug);
+      const taskStatus = taskFile ? getTaskStatusFn(taskFile) : null;
+      if (taskStatus !== 'done' && taskFile) {
+        return null;
+      }
+
+      return {
+        slug,
+        path: entry.path,
+        branch: branchRef,
+        taskStatus: taskStatus || 'missing',
+        cleanupCommand: taskStatus === 'done'
+          ? `scripts/cleanup-mission-worktree.sh ${slug}`
+          : `git worktree remove ${entry.path} && git branch -D ${missionBranchName(slug, resolvedPrimary || process.cwd())}`
+      };
+    })
+    .filter(Boolean);
+}
+
+/** @param {string} ref */
+function formatWorktreeBranch(ref: string) {
+  if (!ref) {return '(detached HEAD)';}
+  return ref.replace(/^refs\/heads\//, '');
+}
+
+/** @param {Function} log @param {string} label @param {{detached?: boolean, unmergedFiles: string[]}} rebaseState */
+function logRebaseDiagnostics(log: Function, label: string, rebaseState: {detached?: boolean, unmergedFiles: string[]}) {
+  const detachedText = rebaseState.detached ? 'detached HEAD, ' : '';
+  log(`${label}: ${detachedText}${rebaseState.unmergedFiles.length} unmerged file(s)`);
+  rebaseState.unmergedFiles.forEach(file => {
+    log(`  - ${file}`);
+  });
+}
+
+/** @param {string[]} args @param {{exit?: Function, log?: Function, inferSlugFn?: Function, getCurrentBranchFn?: Function, findTaskFileFn?: Function, getTaskStatusFn?: Function, findMissionDirFn?: Function, findCheckpointsFn?: Function, getFirstLineFn?: Function, getPrStatusFn?: Function, findStaleMissionWorktreesFn?: Function, readAgentConfigOrExitFn?: Function, eligibleAgentsForStepFn?: Function, allWorkflowAgentNamesFn?: Function, workflowLauncherStatusFn?: Function, getLastThreeCommitsFn?: Function, getUncommittedCountFn?: Function, detectRebaseStateFn?: Function}} opts */
+function status(args: string[], opts: {exit?: Function, log?: Function, inferSlugFn?: Function, getCurrentBranchFn?: Function, findTaskFileFn?: Function, getTaskStatusFn?: Function, findMissionDirFn?: Function, findCheckpointsFn?: Function, getFirstLineFn?: Function, getPrStatusFn?: Function, findStaleMissionWorktreesFn?: Function, readAgentConfigOrExitFn?: Function, eligibleAgentsForStepFn?: Function, allWorkflowAgentNamesFn?: Function, workflowLauncherStatusFn?: Function, getLastThreeCommitsFn?: Function, getUncommittedCountFn?: Function, detectRebaseStateFn?: Function}) {
+  const exit = opts.exit || process.exit;
+  const log = opts.log || fmt.log.plain;
+  const inferSlugFn = opts.inferSlugFn || inferSlug;
+  const getCurrentBranchFn = opts.getCurrentBranchFn || getCurrentBranch;
+  const findTaskFileFn = opts.findTaskFileFn || findTaskFile;
+  const getTaskStatusFn = opts.getTaskStatusFn || getTaskStatus;
+  const findMissionDirFn = opts.findMissionDirFn || findMissionDir;
+  const findCheckpointsFn = opts.findCheckpointsFn || findCheckpoints;
+  const getFirstLineFn = opts.getFirstLineFn || getFirstLine;
+  const getPrStatusFn = opts.getPrStatusFn || getPrStatus;
+  const findStaleMissionWorktreesFn = opts.findStaleMissionWorktreesFn || findStaleMissionWorktrees;
+  const readAgentConfigOrExitFn = opts.readAgentConfigOrExitFn || readAgentConfigOrExit;
+  const eligibleAgentsForStepFn = opts.eligibleAgentsForStepFn || eligibleAgentsForStep;
+  const allWorkflowAgentNamesFn = opts.allWorkflowAgentNamesFn || (() => WORKFLOW_AGENT_NAMES);
+  const workflowLauncherStatusFn = opts.workflowLauncherStatusFn || workflowLauncherStatus;
+  const getLastThreeCommitsFn = opts.getLastThreeCommitsFn || getLastThreeCommits;
+  const getUncommittedCountFn = opts.getUncommittedCountFn || getUncommittedCount;
+  const detectRebaseStateFn = opts.detectRebaseStateFn || detectRebaseState;
+
+  const explicitSlug = args[0];
+  const slug = inferSlugFn(explicitSlug);
+
+  log(fmt.bold('--- Mission Status ---'));
+  log(`Branch: ${fmt.branch(getCurrentBranchFn())}`);
+  log(`Worktree: ${fmt.path(process.cwd())}`);
+
+  try {
+    const rebaseState = detectRebaseStateFn(process.cwd());
+    if (rebaseState.inProgress && rebaseState.detached) {
+      logRebaseDiagnostics(log, 'Detached HEAD: rebase in progress', rebaseState);
+    }
+  } catch (_) {
+    // Ignore transient worktree/git-state failures in status output.
+  }
+
+  if (slug) {
+    const taskFile = findTaskFileFn(slug);
+    const taskStatus = getTaskStatusFn(taskFile);
+    log(`Backlog status: ${taskStatus || 'unknown'}`);
+
+    const missionDir = findMissionDirFn(slug);
+    if (missionDir) {
+      const checkpoints = findCheckpointsFn(missionDir);
+      if (checkpoints.length > 0) {
+        const lastCP = checkpoints[checkpoints.length - 1];
+        const firstLine = getFirstLineFn(lastCP);
+        log(`Last checkpoint: ${path.basename(lastCP)} - ${firstLine}`);
+      } else {
+        log('Last checkpoint: none');
+      }
+    } else {
+      log('Last checkpoint: unknown');
+    }
+
+    // Forgejo PR state
+    const pr = getPrStatusFn(missionBranchName(slug));
+    if (pr.exists) {
+      log(`Forgejo PR: #${pr.number} (${pr.state})`);
+    } else if (pr.raw) {
+      log(`Forgejo PR: unavailable (${pr.raw})`);
+    } else {
+      log('Forgejo PR: none');
+    }
+  }
+
+  if (!explicitSlug) {
+    const staleWorktrees = findStaleMissionWorktreesFn();
+    staleWorktrees.forEach((entry: { path: string; branch: string | null; taskStatus: string | null; cleanupCommand?: string }) => {
+      log(`Stale worktree: ${fmt.path(entry.path)} (task: ${entry.taskStatus})`);
+      try {
+        const rebaseState = detectRebaseStateFn(entry.path);
+        if (rebaseState.inProgress) {
+          logRebaseDiagnostics(log, `Rebase in progress on ${formatWorktreeBranch(entry.branch || '')}`, rebaseState);
+        }
+      } catch (_) {
+        // Ignore stale worktrees that disappear during inspection.
+      }
+      log(`  Cleanup: ${fmt.command(entry.cleanupCommand || '')}`);
+    });
+  }
+
+  // Agent eligibility matrix
+  const config = readAgentConfigOrExitFn();
+  const draftEligible = eligibleAgentsForStepFn('draft', { config });
+  const activeEligible = eligibleAgentsForStepFn('active', { config });
+  const baseAgents = allWorkflowAgentNamesFn();
+  const allAgents = [...new Set([...baseAgents, ...draftEligible, ...activeEligible])].sort();
+  const envOverride = process.env.WORKFLOW_AGENT;
+  log('Agent launcher matrix:');
+  for (const agent of allAgents) {
+    const launcher = workflowLauncherStatusFn(agent);
+    const support = launcher.supported ? 'supported' : 'blocked';
+    const draftMark = draftEligible.includes(agent) ? 'draft' : '-';
+    const activeMark = activeEligible.includes(agent) ? 'active' : '-';
+    log(`  ${fmt.agent(agent)}: ${support} | eligible: ${draftMark},${activeMark}`);
+  }
+  if (envOverride) {
+    log(`  (WORKFLOW_AGENT override: ${fmt.agent(envOverride)})`);
+  }
+
+  const lastThree = getLastThreeCommitsFn();
+  log('Last 3 commits:');
+  lastThree.forEach((c: string) => log(`  - ${c}`));
+
+  log(`Uncommitted files: ${getUncommittedCountFn()}`);
+  log(fmt.bold('----------------------'));
+  exit(0);
+}
+
+(status as any).parseWorktreeList = parseWorktreeList;
+(status as any).findStaleMissionWorktrees = findStaleMissionWorktrees;
+export = status;

package/lib/commands/verify.js

@@ -1 +1,3 @@
-module.exports = require('../core/verification');
+"use strict";
+const verify = require("../core/verification.js");
+module.exports = verify;

package/lib/commands/verify.ts

@@ -0,0 +1,2 @@
+import verify = require('../core/verification.js');
+export = verify;

package/lib/core/fmt.js

@@ -1,249 +1,178 @@
+"use strict";
 /**
  * Shared formatting and palette layer for workflow-owned output.
  * Uses Node.js built-in util.styleText for color rendering (ADR 0042).
  * No external dependencies.
  */
-
-const { styleText } = require('node:util');
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = exports.log = void 0;
+exports.colorize = colorize;
+exports.stripAnsi = stripAnsi;
+exports.visibleWidth = visibleWidth;
+exports.padVisibleEnd = padVisibleEnd;
+exports.status = status;
+exports.agent = agent;
+exports.bold = bold;
+exports.dim = dim;
+exports.kv = kv;
+exports.table = table;
+exports.list = list;
+exports.path = path;
+exports.slug = slug;
+exports.branch = branch;
+exports.sha = sha;
+exports.command = command;
+exports.setLogger = setLogger;
+const node_util_1 = require("node:util");
 const colors = {
-  reset: 'reset',
-  bold: 'bold',
-  red: 'red',
-  green: 'green',
-  yellow: 'yellow',
-  blue: 'blue',
-  magenta: 'magenta',
-  cyan: 'cyan',
-  white: 'white',
-  dim: 'gray',
+    reset: 'reset',
+    bold: 'bold',
+    red: 'red',
+    green: 'green',
+    yellow: 'yellow',
+    blue: 'blue',
+    magenta: 'magenta',
+    cyan: 'cyan',
+    white: 'white',
+    dim: 'gray',
 };
-
+exports.colors = colors;
 const statusMap = {
-  PASS: 'green',
-  FAIL: 'red',
-  WARN: 'yellow',
-  INFO: 'cyan',
-  DEBUG: 'gray',
+    PASS: 'green',
+    FAIL: 'red',
+    WARN: 'yellow',
+    INFO: 'cyan',
+    DEBUG: 'gray',
 };
-
 const agentMap = {
-  codex: 'magenta',
-  claude: 'blue',
-  gemini: 'cyan',
-  custom: 'yellow',
+    codex: 'magenta',
+    claude: 'blue',
+    gemini: 'cyan',
+    custom: 'yellow',
 };
-
-/** @param {import('node:util').InspectColor} format @param {string} text */
 function colorize(format, text) {
-  return styleText(format, String(text ?? ''));
+    return (0, node_util_1.styleText)(format, String(text ?? ''));
 }
-
-/** @param {string} text */
 function stripAnsi(text) {
-  return String(text ?? '').replace(/\x1B\[[0-9;]*m/g, '');
+    return String(text ?? '').replace(/\x1B\[[0-9;]*m/g, '');
 }
-
-/** @param {string} text */
 function visibleWidth(text) {
-  return stripAnsi(text).length;
+    return stripAnsi(text).length;
 }
-
-/** @param {string} text @param {number} width */
 function padVisibleEnd(text, width) {
-  const stringValue = String(text ?? '');
-  const padLength = Math.max(0, width - visibleWidth(stringValue));
-  return stringValue + ' '.repeat(padLength);
+    const stringValue = String(text ?? '');
+    const padLength = Math.max(0, width - visibleWidth(stringValue));
+    return stringValue + ' '.repeat(padLength);
 }
-
-/**
- * Formats a status line prefix (e.g. "[PASS]").
- */
-/** @param {string} type @param {string} text */
 function status(type, text) {
-  /** @type {Record<string,string>} */
-  const sm = statusMap;
-  const format = sm[type];
-  if (!format) {return `[${type}] ${text}`;}
-  return `${colorize(/** @type {import('node:util').InspectColor} */(format), `[${type}]`)} ${text}`;
+    const format = statusMap[type];
+    if (!format) {
+        return `[${type}] ${text}`;
+    }
+    return `${colorize(format, `[${type}]`)} ${text}`;
 }
-
-/**
- * Formats an agent family name.
- */
-/** @param {string} family @param {string} [text] */
 function agent(family, text = family) {
-  let label = text;
-  // Disambiguate the opencode-backed `custom` family only when the caller
-  // passes a distinct display text (e.g. a model id): show `custom (opencode)`
-  // so the underlying runtime is explicit. When text is just `custom`, render
-  // it plainly to avoid the redundant `custom (opencode)` suffix.
-  if (family === 'custom' && text !== 'custom') {
-    label = 'custom (opencode)';
-  }
-  /** @type {Record<string,string>} */
-  const am = agentMap;
-  const format = am[family];
-  if (!format) {return label;}
-  return colorize(/** @type {import('node:util').InspectColor} */(format), label);
+    let label = text;
+    if (family === 'custom' && text !== 'custom') {
+        label = 'custom (opencode)';
+    }
+    const format = agentMap[family];
+    if (!format) {
+        return label;
+    }
+    return colorize(format, label);
 }
-
-/** @param {string} text */
 function bold(text) {
-  return colorize('bold', text);
+    return colorize('bold', text);
 }
-
-/** @param {string} text */
 function dim(text) {
-  return colorize('gray', text);
+    return colorize('gray', text);
 }
-
-/**
- * Aligned key-value pair.
- */
-/** @param {string} key @param {string} value @param {number} width */
 function kv(key, value, width = 30) {
-  return `${bold(key.padEnd(width))} ${value}`;
+    return `${bold(key.padEnd(width))} ${value}`;
 }
-
-/**
- * Aligned table of columns.
- */
-/** @param {string[][]} rows @param {{indent?: number, colPadding?: number}} [opts] */
 function table(rows, { indent = 2, colPadding = 2 } = {}) {
-  if (rows.length === 0) {return '';}
-  /** @param {unknown} _ @param {number} i */
-  const colWidths = rows[0].map((_, i) => Math.max(...rows.map(row => visibleWidth(row[i] ?? ''))));
-  const padding = ' '.repeat(indent);
-  /** @param {string[]} row */
-  return rows.map(row => padding + row.map((col, i) => padVisibleEnd(col ?? '', colWidths[i] + colPadding)).join('')).join('\n');
+    if (rows.length === 0) {
+        return '';
+    }
+    const colWidths = rows[0].map((_, i) => Math.max(...rows.map(row => visibleWidth(row[i] ?? ''))));
+    const padding = ' '.repeat(indent);
+    return rows.map(row => padding + row.map((col, i) => padVisibleEnd(col ?? '', colWidths[i] + colPadding)).join('')).join('\n');
 }
-
-/**
- * Bulleted list.
- */
-/** @param {string[]} items @param {{bullet?: string, indent?: number}} [opts] */
 function list(items, { bullet = '-', indent = 2 } = {}) {
-  const padding = ' '.repeat(indent);
-  /** @param {string} item */
-  return items.map(item => `${padding}${bullet} ${item}`).join('\n');
+    const padding = ' '.repeat(indent);
+    return items.map(item => `${padding}${bullet} ${item}`).join('\n');
 }
-
-const semantic = {
-  path: /** @param {string} text */(text) => colorize('blue', text),
-  slug: /** @param {string} text */(text) => colorize('cyan', bold(text)),
-  branch: /** @param {string} text */(text) => colorize('magenta', text),
-  sha: /** @param {string} text */(text) => colorize('yellow', text),
-  command: /** @param {string} text */(text) => colorize('green', text),
-};
-
-/** @type {{log: Function, error: Function}} */
+function path(text) { return colorize('blue', text); }
+function slug(text) { return colorize('cyan', bold(text)); }
+function branch(text) { return colorize('magenta', text); }
+function sha(text) { return colorize('yellow', text); }
+function command(text) { return colorize('green', text); }
 let currentLogger = {
-  /** @param {...any} args */
-  log: (...args) => console.log(...args),
-  /** @param {...any} args */
-  error: (...args) => console.error(...args),
+    log: (...args) => console.log(...args),
+    error: (...args) => console.error(...args),
 };
-
-/** @typedef {{log?: Function, error?: Function}} LoggerObj */
-
-/** @type{{info: Function, pass: Function, fail: Function, warn: Function, error: Function, debug: Function, plain: Function, plainError: Function}} */
-const log = {
-  /** @param {string} text */
-  info: (text) => {
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('INFO', line);
-      currentLogger.log(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  pass: (text) => {
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('PASS', line);
-      currentLogger.log(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  fail: (text) => {
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('FAIL', line);
-      currentLogger.error(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  warn: (text) => {
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('WARN', line);
-      currentLogger.log(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  error: (text) => {
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('FAIL', line);
-      currentLogger.error(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  debug: (text) => {
-    if (!process.env.DEBUG) {return null;}
-    /** @param {string} line */
-    return text.toString().split('\n').map(line => {
-      const s = status('DEBUG', line);
-      currentLogger.log(s);
-      return s;
-    }).join('\n');
-  },
-  /** @param {string} text */
-  plain: (text) => {
-    /** @param {string} line */
-    text.toString().split('\n').forEach(line => currentLogger.log(line));
-    return text;
-  },
-  /** @param {string} text */
-  plainError: (text) => {
-    /** @param {string} line */
-    text.toString().split('\n').forEach(line => currentLogger.error(line));
-    return text;
-  },
+exports.log = {
+    info: (text) => {
+        return text.toString().split('\n').map(line => {
+            const s = status('INFO', line);
+            currentLogger.log(s);
+            return s;
+        }).join('\n');
+    },
+    pass: (text) => {
+        return text.toString().split('\n').map(line => {
+            const s = status('PASS', line);
+            currentLogger.log(s);
+            return s;
+        }).join('\n');
+    },
+    fail: (text) => {
+        return text.toString().split('\n').map(line => {
+            const s = status('FAIL', line);
+            currentLogger.error(s);
+            return s;
+        }).join('\n');
+    },
+    warn: (text) => {
+        return text.toString().split('\n').map(line => {
+            const s = status('WARN', line);
+            currentLogger.log(s);
+            return s;
+        }).join('\n');
+    },
+    error: (text) => {
+        return text.toString().split('\n').map(line => {
+            const s = status('FAIL', line);
+            currentLogger.error(s);
+            return s;
+        }).join('\n');
+    },
+    debug: (text) => {
+        if (!process.env.DEBUG) {
+            return null;
+        }
+        return text.toString().split('\n').map(line => {
+            const s = status('DEBUG', line);
+            currentLogger.log(s);
+            return s;
+        }).join('\n');
+    },
+    plain: (text) => {
+        text.toString().split('\n').forEach(line => currentLogger.log(line));
+        return text;
+    },
+    plainError: (text) => {
+        text.toString().split('\n').forEach(line => currentLogger.error(line));
+        return text;
+    },
 };
-
-/** @param {LoggerObj|Function} newLogger */
 function setLogger(newLogger) {
-  const old = currentLogger;
-  /** @type {LoggerObj} */
-  const logger = /** @type {LoggerObj} */(newLogger);
-  currentLogger = {
-    log: typeof logger.log === 'function' ? logger.log : (() => {}),
-    error: typeof logger.error === 'function' ? logger.error : (typeof logger.log === 'function' ? logger.log : (() => {})),
-  };
-  return old;
+    const old = currentLogger;
+    const logger = newLogger;
+    currentLogger = {
+        log: typeof logger.log === 'function' ? logger.log : (() => { }),
+        error: typeof logger.error === 'function' ? logger.error : (typeof logger.log === 'function' ? logger.log : (() => { })),
+    };
+    return old;
 }
-
-module.exports = {
-  colors,
-  status,
-  agent,
-  bold,
-  dim,
-  colorize,
-  stripAnsi,
-  visibleWidth,
-  padVisibleEnd,
-  kv,
-  table,
-  list,
-  ...semantic,
-  log,
-  setLogger,
-};