@magnusekdahl/parallix 1.2.1 → 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/nels.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Net Engineering Lines (NEL) computation.
  *
@@ -14,32 +15,33 @@
  *
  * @module lib/core/nels
  */
-
-const { spawnSync } = require('child_process');
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUCKET_MEDIUM_MAX = exports.BUCKET_SMALL_MAX = exports.EXCLUSION_PATTERNS = void 0;
+exports.classifyBucket = classifyBucket;
+exports.isExcluded = isExcluded;
+exports.computeNEL = computeNEL;
+exports.computeNELRecord = computeNELRecord;
+const node_child_process_1 = require("node:child_process");
 // ---------- exclusion globs (ADR 0047) ----------
 // Each entry is a minimatch-compatible pattern. Patterns are checked in order;
 // the first match wins.
-
-const EXCLUSION_PATTERNS = [
-  'missions/**',        // workflow/process bookkeeping
-  'backlog/**',         // workflow/process bookkeeping
-  'review-*',           // workflow/process bookkeeping
-  'CP-*',               // workflow/process bookkeeping
-  '**/*.md',            // documentation
-  'docs/**',            // documentation
-  'package-lock.json',  // generated/vendored
-  'coverage/**',        // generated/vendored
-  '*lock*',             // lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, Gemfile.lock, etc.)
-  '*.lock',             // additional lockfile safety net
+exports.EXCLUSION_PATTERNS = [
+    'missions/**', // workflow/process bookkeeping
+    'backlog/**', // workflow/process bookkeeping
+    'review-*', // workflow/process bookkeeping
+    'CP-*', // workflow/process bookkeeping
+    '**/*.md', // documentation
+    'docs/**', // documentation
+    'package-lock.json', // generated/vendored
+    'coverage/**', // generated/vendored
+    '*lock*', // lockfiles (package-lock.json, yarn.lock, pnpm-lock.yaml, Gemfile.lock, etc.)
+    '*.lock', // additional lockfile safety net
 ];
-
 /**
  * Bucket constants derived from ADR 0047 empirical terciles.
  */
-const BUCKET_SMALL_MAX = 80;
-const BUCKET_MEDIUM_MAX = 235;
-
+exports.BUCKET_SMALL_MAX = 80;
+exports.BUCKET_MEDIUM_MAX = 235;
 /**
  * Classify NEL count into a bucket label.
  *
@@ -47,15 +49,14 @@ const BUCKET_MEDIUM_MAX = 235;
  * @returns {{ label: 'Small' | 'Medium' | 'Large', min: number, max: number }}
  */
 function classifyBucket(nel) {
-  if (nel <= BUCKET_SMALL_MAX) {
-    return { label: 'Small', min: 0, max: BUCKET_SMALL_MAX };
-  }
-  if (nel <= BUCKET_MEDIUM_MAX) {
-    return { label: 'Medium', min: BUCKET_SMALL_MAX + 1, max: BUCKET_MEDIUM_MAX };
-  }
-  return { label: 'Large', min: BUCKET_MEDIUM_MAX + 1, max: Infinity };
+    if (nel <= exports.BUCKET_SMALL_MAX) {
+        return { label: 'Small', min: 0, max: exports.BUCKET_SMALL_MAX };
+    }
+    if (nel <= exports.BUCKET_MEDIUM_MAX) {
+        return { label: 'Medium', min: exports.BUCKET_SMALL_MAX + 1, max: exports.BUCKET_MEDIUM_MAX };
+    }
+    return { label: 'Large', min: exports.BUCKET_MEDIUM_MAX + 1, max: Infinity };
 }
-
 /**
  * Check whether a file path matches any exclusion pattern.
  *
@@ -63,17 +64,15 @@ function classifyBucket(nel) {
  * @returns {boolean}
  */
 function isExcluded(filePath) {
-  // Normalize to forward slashes
-  const normalized = filePath.replace(/\\/g, '/');
-
-  for (const pattern of EXCLUSION_PATTERNS) {
-    if (patternMatches(normalized, pattern)) {
-      return true;
+    // Normalize to forward slashes
+    const normalized = filePath.replace(/\\/g, '/');
+    for (const pattern of exports.EXCLUSION_PATTERNS) {
+        if (patternMatches(normalized, pattern)) {
+            return true;
+        }
     }
-  }
-  return false;
+    return false;
 }
-
 /**
  * Simple glob matcher supporting *, **, and literal segments.
  * Does not require a full minimatch dependency — keeps this module light.
@@ -83,45 +82,47 @@ function isExcluded(filePath) {
  * @returns {boolean}
  */
 function patternMatches(str, pattern) {
-  // Convert minimatch-style glob to regex
-  // Escape regex special chars except * and ?
-  let regexStr = '';
-  let i = 0;
-  const pLen = pattern.length;
-
-  while (i < pLen) {
-    const ch = pattern[i];
-    if (ch === '*') {
-      if (i + 1 < pLen && pattern[i + 1] === '*') {
-        // ** matches everything including /
-        if (i + 2 < pLen && pattern[i + 2] === '/') {
-          regexStr += '(?:.*/)?';
-          i += 3;
-          continue;
-        } else {
-          regexStr += '.*';
-          i += 2;
-          continue;
+    // Convert minimatch-style glob to regex
+    // Escape regex special chars except * and ?
+    let regexStr = '';
+    let i = 0;
+    const pLen = pattern.length;
+    while (i < pLen) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (i + 1 < pLen && pattern[i + 1] === '*') {
+                // ** matches everything including /
+                if (i + 2 < pLen && pattern[i + 2] === '/') {
+                    regexStr += '(?:.*/)?';
+                    i += 3;
+                    continue;
+                }
+                else {
+                    regexStr += '.*';
+                    i += 2;
+                    continue;
+                }
+            }
+            else {
+                regexStr += '[^/]*';
+                i += 1;
+                continue;
+            }
+        }
+        else if (ch === '?') {
+            regexStr += '[^/]';
+        }
+        else if ('.+^${}()|[]\\'.includes(ch)) {
+            regexStr += '\\' + ch;
+        }
+        else {
+            regexStr += ch;
         }
-      } else {
-        regexStr += '[^/]*';
-        i += 1;
-        continue;
-      }
-    } else if (ch === '?') {
-      regexStr += '[^/]';
-    } else if ('.+^${}()|[]\\'.includes(ch)) {
-      regexStr += '\\' + ch;
-    } else {
-      regexStr += ch;
+        i++;
     }
-    i++;
-  }
-
-  const re = new RegExp('^' + regexStr + '$');
-  return re.test(str);
+    const re = new RegExp('^' + regexStr + '$');
+    return re.test(str);
 }
-
 /**
  * Compute Net Engineering Lines (NEL) from a git diff range.
  *
@@ -133,49 +134,43 @@ function patternMatches(str, pattern) {
  * @returns {number} Total NEL count (insertions + deletions, whitespace-ignored)
  */
 function computeNEL(range, options = {}) {
-  const cwd = options.cwd || process.cwd();
-
-  const result = spawnSync('git', ['diff', '--numstat', '-w', range], {
-    cwd,
-    encoding: 'utf8',
-    maxBuffer: 50 * 1024 * 1024, // 50 MB
-  });
-
-  if (result.status !== 0) {
-    // Git error, empty diff, or uncomputable — return 0
-    return 0;
-  }
-
-  const stdout = result.stdout || '';
-  const lines = stdout.split('\n').filter(line => line.trim().length > 0);
-
-  let total = 0;
-
-  for (const line of lines) {
-    // numstat format: <insertions>\t<deletions>\t<filename>
-    // Binary files show: -\t-\t<filename>
-    const parts = line.split('\t');
-    if (parts.length < 3) { continue; }
-
-    const adds = parts[0];
-    const dels = parts[1];
-    const filePath = parts.slice(2).join('\t');
-
-    // Skip binary files
-    if (adds === '-' || dels === '-') { continue; }
-
-    // Apply exclusion globs
-    if (isExcluded(filePath)) { continue; }
-
-    const addsNum = parseInt(adds, 10) || 0;
-    const delsNum = parseInt(dels, 10) || 0;
-
-    total += addsNum + delsNum;
-  }
-
-  return total;
+    const cwd = options.cwd || process.cwd();
+    const result = (0, node_child_process_1.spawnSync)('git', ['diff', '--numstat', '-w', range], {
+        cwd,
+        encoding: 'utf8',
+        maxBuffer: 50 * 1024 * 1024, // 50 MB
+    });
+    if (result.status !== 0) {
+        // Git error, empty diff, or uncomputable — return 0
+        return 0;
+    }
+    const stdout = result.stdout || '';
+    const lines = stdout.split('\n').filter(line => line.trim().length > 0);
+    let total = 0;
+    for (const line of lines) {
+        // numstat format: <insertions>\t<deletions>\t<filename>
+        // Binary files show: -\t-\t<filename>
+        const parts = line.split('\t');
+        if (parts.length < 3) {
+            continue;
+        }
+        const adds = parts[0];
+        const dels = parts[1];
+        const filePath = parts.slice(2).join('\t');
+        // Skip binary files
+        if (adds === '-' || dels === '-') {
+            continue;
+        }
+        // Apply exclusion globs
+        if (isExcluded(filePath)) {
+            continue;
+        }
+        const addsNum = parseInt(adds, 10) || 0;
+        const delsNum = parseInt(dels, 10) || 0;
+        total += addsNum + delsNum;
+    }
+    return total;
 }
-
 /**
  * Compute NEL and return the full NEL record including bucket classification.
  *
@@ -183,17 +178,7 @@ function computeNEL(range, options = {}) {
  * @param {{ cwd?: string }} [options]
  * @returns {{ nel: number, bucket: { label: string, min: number, max: number } }}
  */
-function computeNELRecord(range, options) {
-  const nel = computeNEL(range, options);
-  return { nel, bucket: classifyBucket(nel) };
+function computeNELRecord(range, options = {}) {
+    const nel = computeNEL(range, options);
+    return { nel, bucket: classifyBucket(nel) };
 }
-
-module.exports = {
-  computeNEL,
-  computeNELRecord,
-  classifyBucket,
-  isExcluded,
-  EXCLUSION_PATTERNS,
-  BUCKET_SMALL_MAX,
-  BUCKET_MEDIUM_MAX,
-};