@magnusekdahl/parallix 1.0.0

package/lib/commands/status.js

@@ -0,0 +1,183 @@
+const { getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } = require('../core/git');
+const { findTaskFile, getTaskStatus } = require('../tools/backlog');
+const { findMissionDir, findCheckpoints, getFirstLine, inferSlug, missionBranchPrefix, missionBranchName } = require('../core/mission-utils');
+const { WORKFLOW_AGENT_NAMES, eligibleAgentsForStep, readAgentConfigOrExit, workflowLauncherStatus } = require('../agents/agents');
+const { getPrStatus } = require('../tools/forgejo');
+const fs = require('fs');
+const path = require('path');
+const fmt = require('../core/fmt');
+
+function parseWorktreeList(porcelain) {
+  const entries = [];
+  let current = 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();
+    }
+  }
+
+  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 [];
+  }
+
+  let resolvedPrimary = primaryWorktree;
+  if (!resolvedPrimary) {
+    try {
+      const { getPrimaryWorktree } = require('../core/mission-utils');
+      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,
+        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);
+}
+
+function status(args, options = {}) {
+  const exit = options.exit || process.exit;
+  const log = options.log || fmt.log.plain;
+  const inferSlugFn = options.inferSlugFn || inferSlug;
+  const getCurrentBranchFn = options.getCurrentBranchFn || getCurrentBranch;
+  const findTaskFileFn = options.findTaskFileFn || findTaskFile;
+  const getTaskStatusFn = options.getTaskStatusFn || getTaskStatus;
+  const findMissionDirFn = options.findMissionDirFn || findMissionDir;
+  const findCheckpointsFn = options.findCheckpointsFn || findCheckpoints;
+  const getFirstLineFn = options.getFirstLineFn || getFirstLine;
+  const getPrStatusFn = options.getPrStatusFn || getPrStatus;
+  const findStaleMissionWorktreesFn = options.findStaleMissionWorktreesFn || findStaleMissionWorktrees;
+  const readAgentConfigOrExitFn = options.readAgentConfigOrExitFn || readAgentConfigOrExit;
+  const eligibleAgentsForStepFn = options.eligibleAgentsForStepFn || eligibleAgentsForStep;
+  const allWorkflowAgentNamesFn = options.allWorkflowAgentNamesFn || (() => WORKFLOW_AGENT_NAMES);
+  const workflowLauncherStatusFn = options.workflowLauncherStatusFn || workflowLauncherStatus;
+  const getLastThreeCommitsFn = options.getLastThreeCommitsFn || getLastThreeCommits;
+  const getUncommittedCountFn = options.getUncommittedCountFn || getUncommittedCount;
+
+  const explicitSlug = args[0];
+  const slug = inferSlugFn(explicitSlug);
+
+  log(fmt.bold('--- Mission Status ---'));
+  log(`Branch: ${fmt.branch(getCurrentBranchFn())}`);
+  log(`Worktree: ${fmt.path(process.cwd())}`);
+
+  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 => {
+      log(`Stale worktree: ${fmt.path(entry.path)} (task: ${entry.taskStatus})`);
+      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 => log(`  - ${c}`));
+
+  log(`Uncommitted files: ${getUncommittedCountFn()}`);
+  log(fmt.bold('----------------------'));
+  exit(0);
+}
+
+module.exports = status;
+module.exports.parseWorktreeList = parseWorktreeList;
+module.exports.findStaleMissionWorktrees = findStaleMissionWorktrees;

package/lib/commands/verify.js

@@ -0,0 +1 @@
+module.exports = require('../core/verification');

package/lib/core/fmt.js

@@ -0,0 +1,202 @@
+/**
+ * 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');
+
+const colors = {
+  reset: 'reset',
+  bold: 'bold',
+  red: 'red',
+  green: 'green',
+  yellow: 'yellow',
+  blue: 'blue',
+  magenta: 'magenta',
+  cyan: 'cyan',
+  white: 'white',
+  dim: 'gray',
+};
+
+const statusMap = {
+  PASS: 'green',
+  FAIL: 'red',
+  WARN: 'yellow',
+  INFO: 'cyan',
+  DEBUG: 'gray',
+};
+
+const agentMap = {
+  codex: 'magenta',
+  claude: 'blue',
+  gemini: 'cyan',
+  qwen: 'yellow',
+};
+
+function colorize(format, text) {
+  return styleText(format, String(text ?? ''));
+}
+
+function stripAnsi(text) {
+  return String(text ?? '').replace(/\x1B\[[0-9;]*m/g, '');
+}
+
+function visibleWidth(text) {
+  return stripAnsi(text).length;
+}
+
+function padVisibleEnd(text, width) {
+  const stringValue = String(text ?? '');
+  const padLength = Math.max(0, width - visibleWidth(stringValue));
+  return stringValue + ' '.repeat(padLength);
+}
+
+/**
+ * Formats a status line prefix (e.g. "[PASS]").
+ */
+function status(type, text) {
+  const format = statusMap[type];
+  if (!format) return `[${type}] ${text}`;
+  return `${colorize(format, `[${type}]`)} ${text}`;
+}
+
+/**
+ * Formats an agent family name.
+ */
+function agent(family, text = family) {
+  let label = text;
+  if (family === 'qwen' && text === 'qwen') {
+    label = 'qwen (opencode)';
+  }
+  const format = agentMap[family];
+  if (!format) return label;
+  return colorize(format, label);
+}
+
+function bold(text) {
+  return colorize('bold', text);
+}
+
+function dim(text) {
+  return colorize('gray', text);
+}
+
+/**
+ * Aligned key-value pair.
+ */
+function kv(key, value, width = 30) {
+  return `${bold(key.padEnd(width))} ${value}`;
+}
+
+/**
+ * Aligned table of columns.
+ */
+function table(rows, { indent = 2, colPadding = 2 } = {}) {
+  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.
+ */
+function list(items, { bullet = '-', indent = 2 } = {}) {
+  const padding = ' '.repeat(indent);
+  return items.map(item => `${padding}${bullet} ${item}`).join('\n');
+}
+
+const semantic = {
+  path: (text) => colorize('blue', text),
+  slug: (text) => colorize('cyan', bold(text)),
+  branch: (text) => colorize('magenta', text),
+  sha: (text) => colorize('yellow', text),
+  command: (text) => colorize('green', text),
+};
+
+let currentLogger = {
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+};
+
+const 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;
+  },
+};
+
+function setLogger(newLogger) {
+  const old = currentLogger;
+  currentLogger = {
+    log: newLogger.log || newLogger,
+    error: newLogger.error || newLogger.log || newLogger,
+  };
+  return old;
+}
+
+module.exports = {
+  colors,
+  status,
+  agent,
+  bold,
+  dim,
+  colorize,
+  stripAnsi,
+  visibleWidth,
+  padVisibleEnd,
+  kv,
+  table,
+  list,
+  ...semantic,
+  log,
+  setLogger,
+};

package/lib/core/git.js

@@ -0,0 +1,73 @@
+const childProcess = require('child_process');
+
+function git(args, options = {}) {
+  const spawnOptions = {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...options
+  };
+  const result = childProcess.spawnSync('git', args, spawnOptions);
+  if (result.error && result.status == null) {
+    throw result.error;
+  }
+  return result;
+}
+
+function run(command, args, options = {}) {
+  const spawnOptions = {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...options
+  };
+  const result = childProcess.spawnSync(command, args, spawnOptions);
+  if (result.error && result.status == null) {
+    throw result.error;
+  }
+  return result;
+}
+
+function getCurrentBranch(cwd = process.cwd()) {
+  const result = git(['-C', cwd, 'branch', '--show-current']);
+  return result.stdout.trim();
+}
+
+function getWorktreeStatus(cwd = process.cwd()) {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  return result.stdout
+    .split('\n')
+    .map(line => line.trimEnd())
+    .filter(Boolean);
+}
+
+function isDirty(cwd = process.cwd()) {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  return result.stdout.trim().length > 0;
+}
+
+function getUncommittedCount(cwd = process.cwd()) {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  if (!result.stdout.trim()) return 0;
+  return result.stdout.trim().split('\n').length;
+}
+
+function getLastCommit() {
+  const result = git(['log', '-1', '--format=%H|%ad|%s']);
+  const [sha, date, subject] = result.stdout.trim().split('|');
+  return { sha, date, subject };
+}
+
+function getLastThreeCommits() {
+  const result = git(['log', '-3', '--format=%s']);
+  return result.stdout.trim().split('\n');
+}
+
+module.exports = {
+  git,
+  run,
+  getCurrentBranch,
+  getWorktreeStatus,
+  isDirty,
+  getUncommittedCount,
+  getLastCommit,
+  getLastThreeCommits
+};

package/lib/core/gitignore.js

@@ -0,0 +1,110 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Workflow-generated paths that must be gitignored in enterprise repositories.
+ * These are paths created by the px workflow toolkit that should never be
+ * committed to version control.
+ */
+const WORKFLOW_ENTRIES = [
+  '.workflow/',
+  '.sessions/',
+  '.forgejo-local/',
+  'workflow/.cache/',
+  'workflow/.sessions/',
+  'workflow/config/agents.local.json',
+  'agents.local.json',
+];
+
+/**
+ * Ensure that a repository's .gitignore contains all workflow-generated paths.
+ *
+ * Handles:
+ * - Missing .gitignore: creates one with all 7 entries
+ * - Existing .gitignore: appends only missing entries, skips duplicates
+ * - Symlinked .gitignore: skips modification, logs warning
+ * - Non-git directories: skips gracefully without crashing
+ *
+ * @param {string} rootDir - Path to the repository root
+ * @param {object} options - Injected dependencies
+ * @param {Function} [options.existsSyncFn] - fs.existsSync replacement
+ * @param {Function} [options.lstatSyncFn] - fs.lstatSync replacement
+ * @param {Function} [options.readFileSyncFn] - fs.readFileSync replacement
+ * @param {Function} [options.writeFileSyncFn] - fs.writeFileSync replacement
+ * @param {Function} [options.logFn] - Logger function
+ * @returns {{ ok: boolean, created: boolean, appended: number, skipped: boolean, reason?: string }}
+ */
+function ensureWorkflowGitignore(rootDir, options = {}) {
+  const {
+    existsSyncFn = fs.existsSync,
+    lstatSyncFn = fs.lstatSync,
+    readFileSyncFn = fs.readFileSync,
+    writeFileSyncFn = fs.writeFileSync,
+    logFn = () => {},
+  } = options;
+
+  const gitignorePath = path.join(rootDir, '.gitignore');
+  const gitDirPath = path.join(rootDir, '.git');
+
+  // Check if this is a git repository
+  if (!existsSyncFn(gitDirPath)) {
+    logFn(`[gitignore] Skipping ${rootDir}: not a git repository (no .git directory)`);
+    return { ok: true, created: false, appended: 0, skipped: true, reason: 'not-a-git-repo' };
+  }
+
+  // Check if .gitignore exists
+  if (!existsSyncFn(gitignorePath)) {
+    // Create new .gitignore with all entries
+    const content = WORKFLOW_ENTRIES.join('\n') + '\n';
+    writeFileSyncFn(gitignorePath, content, 'utf8');
+    logFn(`[gitignore] Created ${gitignorePath} with ${WORKFLOW_ENTRIES.length} entries`);
+    return { ok: true, created: true, appended: WORKFLOW_ENTRIES.length, skipped: false };
+  }
+
+  // .gitignore exists - check for symlink
+  try {
+    const stat = lstatSyncFn(gitignorePath);
+    if (stat.isSymbolicLink()) {
+      logFn(`[gitignore] Skipping ${gitignorePath}: symbolic link, not modifying`);
+      return { ok: true, created: false, appended: 0, skipped: true, reason: 'symlink' };
+    }
+  } catch (_) {
+    // If we can't stat, fall through to read - it might exist but be inaccessible
+  }
+
+  // Read existing .gitignore
+  let existingContent;
+  try {
+    existingContent = readFileSyncFn(gitignorePath, 'utf8');
+  } catch (err) {
+    logFn(`[gitignore] Could not read ${gitignorePath}: ${err.message}`);
+    return { ok: false, created: false, appended: 0, skipped: false, reason: `read-error: ${err.message}` };
+  }
+
+  // Parse existing entries
+  const existingLines = existingContent.split(/\r?\n/);
+  const existingEntries = new Set(
+    existingLines
+      .map(line => line.trim())
+      .filter(line => line.length > 0 && !line.startsWith('#'))
+  );
+
+  // Find missing entries
+  const missingEntries = WORKFLOW_ENTRIES.filter(entry => !existingEntries.has(entry));
+
+  if (missingEntries.length === 0) {
+    logFn(`[gitignore] ${gitignorePath} already contains all ${WORKFLOW_ENTRIES.length} workflow entries`);
+    return { ok: true, created: false, appended: 0, skipped: false };
+  }
+
+  // Append missing entries
+  const newContent = existingContent + '\n' + missingEntries.join('\n') + '\n';
+  writeFileSyncFn(gitignorePath, newContent, 'utf8');
+  logFn(`[gitignore] Appended ${missingEntries.length} missing entries to ${gitignorePath}`);
+
+  return { ok: true, created: false, appended: missingEntries.length, skipped: false };
+}
+
+module.exports = ensureWorkflowGitignore;
+module.exports.ensureWorkflowGitignore = ensureWorkflowGitignore;
+module.exports.WORKFLOW_ENTRIES = WORKFLOW_ENTRIES;