@magnusekdahl/parallix 1.2.0 → 1.3.0

package/lib/core/fmt.ts

@@ -0,0 +1,189 @@
+/**
+ * Shared formatting and palette layer for workflow-owned output.
+ * Uses Node.js built-in util.styleText for color rendering (ADR 0042).
+ * No external dependencies.
+ */
+
+import { styleText } from '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: Record<string, string> = {
+  PASS: 'green',
+  FAIL: 'red',
+  WARN: 'yellow',
+  INFO: 'cyan',
+  DEBUG: 'gray',
+};
+
+const agentMap: Record<string, string> = {
+  codex: 'magenta',
+  claude: 'blue',
+  gemini: 'cyan',
+  custom: 'yellow',
+};
+
+export function colorize(format: string, text: string): string {
+  return styleText(format as import('node:util').InspectColor, String(text ?? ''));
+}
+
+export function stripAnsi(text: string): string {
+  return String(text ?? '').replace(/\x1B\[[0-9;]*m/g, '');
+}
+
+export function visibleWidth(text: string): number {
+  return stripAnsi(text).length;
+}
+
+export function padVisibleEnd(text: string, width: number): string {
+  const stringValue = String(text ?? '');
+  const padLength = Math.max(0, width - visibleWidth(stringValue));
+  return stringValue + ' '.repeat(padLength);
+}
+
+export function status(type: string, text: string): string {
+  const format = statusMap[type];
+  if (!format) {return `[${type}] ${text}`;}
+  return `${colorize(format, `[${type}]`)} ${text}`;
+}
+
+export function agent(family: string, text: string = family): string {
+  let label = text;
+  if (family === 'custom' && text !== 'custom') {
+    label = 'custom (opencode)';
+  }
+  const format = agentMap[family];
+  if (!format) {return label;}
+  return colorize(format, label);
+}
+
+export function bold(text: string): string {
+  return colorize('bold', text);
+}
+
+export function dim(text: string): string {
+  return colorize('gray', text);
+}
+
+export function kv(key: string, value: string, width: number = 30): string {
+  return `${bold(key.padEnd(width))} ${value}`;
+}
+
+export function table(rows: string[][], { indent = 2, colPadding = 2 }: { indent?: number; colPadding?: number } = {}): string {
+  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');
+}
+
+export function list(items: string[], { bullet = '-', indent = 2 }: { bullet?: string; indent?: number } = {}): string {
+  const padding = ' '.repeat(indent);
+  return items.map(item => `${padding}${bullet} ${item}`).join('\n');
+}
+
+export function path(text: string): string { return colorize('blue', text); }
+export function slug(text: string): string { return colorize('cyan', bold(text)); }
+export function branch(text: string): string { return colorize('magenta', text); }
+export function sha(text: string): string { return colorize('yellow', text); }
+export function command(text: string): string { return colorize('green', text); }
+
+type LogFn = (...args: unknown[]) => void;
+type LogFunc = (text: string) => string | null;
+
+type Logger = {
+  log: LogFn;
+  error: LogFn;
+};
+
+type LoggerInput = { log?: LogFn; error?: LogFn } | LogFn;
+
+let currentLogger: Logger = {
+  log: (...args: unknown[]) => console.log(...args),
+  error: (...args: unknown[]) => console.error(...args),
+};
+
+export const log: {
+  info: LogFunc;
+  pass: LogFunc;
+  fail: LogFunc;
+  warn: LogFunc;
+  error: LogFunc;
+  debug: LogFunc;
+  plain: LogFunc;
+  plainError: LogFunc;
+} = {
+  info: (text: string): string => {
+    return text.toString().split('\n').map(line => {
+      const s = status('INFO', line);
+      currentLogger.log(s);
+      return s;
+    }).join('\n');
+  },
+  pass: (text: string): string => {
+    return text.toString().split('\n').map(line => {
+      const s = status('PASS', line);
+      currentLogger.log(s);
+      return s;
+    }).join('\n');
+  },
+  fail: (text: string): string => {
+    return text.toString().split('\n').map(line => {
+      const s = status('FAIL', line);
+      currentLogger.error(s);
+      return s;
+    }).join('\n');
+  },
+  warn: (text: string): string => {
+    return text.toString().split('\n').map(line => {
+      const s = status('WARN', line);
+      currentLogger.log(s);
+      return s;
+    }).join('\n');
+  },
+  error: (text: string): string => {
+    return text.toString().split('\n').map(line => {
+      const s = status('FAIL', line);
+      currentLogger.error(s);
+      return s;
+    }).join('\n');
+  },
+  debug: (text: string): string | null => {
+    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: string): string => {
+    text.toString().split('\n').forEach(line => currentLogger.log(line));
+    return text;
+  },
+  plainError: (text: string): string => {
+    text.toString().split('\n').forEach(line => currentLogger.error(line));
+    return text;
+  },
+};
+
+export function setLogger(newLogger: LoggerInput): Logger {
+  const old = currentLogger;
+  const logger = newLogger as { log?: LogFn; error?: LogFn };
+  currentLogger = {
+    log: typeof logger.log === 'function' ? logger.log : (() => {}),
+    error: typeof logger.error === 'function' ? logger.error : (typeof logger.log === 'function' ? logger.log : (() => {})),
+  };
+  return old;
+}
+
+export { colors };

package/lib/core/git.js

@@ -1,121 +1,140 @@
-const childProcess = require('child_process');
-
-/** @param {string[]} args @param {object} options */
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.git = git;
+exports.run = run;
+exports.getCurrentBranch = getCurrentBranch;
+exports.getWorktreeStatus = getWorktreeStatus;
+exports.isDirty = isDirty;
+exports.getUncommittedCount = getUncommittedCount;
+exports.parseUnmergedFiles = parseUnmergedFiles;
+exports.detectRebaseState = detectRebaseState;
+exports.getLastCommit = getLastCommit;
+exports.getLastThreeCommits = getLastThreeCommits;
+const node_child_process_1 = require("node:child_process");
+const fsMod = __importStar(require("node:fs"));
+const pathMod = __importStar(require("node:path"));
 function git(args, options = {}) {
-  const spawnOptions = {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    ...options
-  };
-  const result = childProcess.spawnSync('git', args, /** @type {import('child_process').SpawnSyncOptionsWithStringEncoding} */(spawnOptions));
-  if (result.error && result.status === null) {
-    throw result.error;
-  }
-  return result;
+    const spawnOptions = {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        ...options
+    };
+    const result = (0, node_child_process_1.spawnSync)('git', args, spawnOptions);
+    if (result.error && result.status === null) {
+        throw result.error;
+    }
+    return { status: result.status, signal: result.signal, stdout: String(result.stdout ?? ''), stderr: String(result.stderr ?? ''), error: result.error };
 }
-
-/** @param {string} command @param {string[]} args @param {object} options */
 function run(command, args, options = {}) {
-  const spawnOptions = {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    ...options
-  };
-  const result = childProcess.spawnSync(command, args, /** @type {import('child_process').SpawnSyncOptionsWithStringEncoding} */(spawnOptions));
-  if (result.error && result.status === null) {
-    throw result.error;
-  }
-  return result;
+    const spawnOptions = {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        ...options
+    };
+    const result = (0, node_child_process_1.spawnSync)(command, args, spawnOptions);
+    if (result.error && result.status === null) {
+        throw result.error;
+    }
+    return { status: result.status, signal: result.signal, stdout: String(result.stdout ?? ''), stderr: String(result.stderr ?? ''), error: result.error };
 }
-
 function getCurrentBranch(cwd = process.cwd()) {
-  const result = git(['-C', cwd, 'branch', '--show-current']);
-  return result.stdout.trim();
+    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);
+    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;
+    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;
+    const result = git(['-C', cwd, 'status', '--porcelain']);
+    if (!result.stdout.trim()) {
+        return 0;
+    }
+    return result.stdout.trim().split('\n').length;
 }
-
 function parseUnmergedFiles(output = '') {
-  return Array.from(new Set(
-    output
-      .split('\n')
-      .map(line => line.trim())
-      .filter(Boolean)
-      .map(line => line.split('\t')[1])
-      .filter(Boolean)
-  ));
+    return Array.from(new Set(output
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => line.split('\t')[1])
+        .filter(Boolean)));
 }
-
-function detectRebaseState(cwd = process.cwd(), { gitRunner = git, fsModule = require('fs'), pathModule = require('path') } = {}) {
-  const gitDirResult = gitRunner(['-C', cwd, 'rev-parse', '--git-dir']);
-  const resolvedGitDir = gitDirResult.status === 0
-    ? gitDirResult.stdout.trim()
-    : '.git';
-  const gitDir = pathModule.isAbsolute(resolvedGitDir)
-    ? resolvedGitDir
-    : pathModule.join(cwd, resolvedGitDir);
-  const rebaseMergeDir = pathModule.join(gitDir, 'rebase-merge');
-  const rebaseApplyDir = pathModule.join(gitDir, 'rebase-apply');
-  const rebaseDir = fsModule.existsSync(rebaseMergeDir)
-    ? rebaseMergeDir
-    : (fsModule.existsSync(rebaseApplyDir) ? rebaseApplyDir : null);
-
-  const headResult = gitRunner(['-C', cwd, 'symbolic-ref', '--quiet', '--short', 'HEAD']);
-  const detached = headResult.status !== 0;
-
-  const showCurrentResult = gitRunner(['-C', cwd, 'rebase', '--show-current']);
-  const rebaseHead = showCurrentResult.status === 0 ? showCurrentResult.stdout.trim() : '';
-
-  const unmergedResult = gitRunner(['-C', cwd, 'ls-files', '-u']);
-  const unmergedFiles = unmergedResult.status === 0 ? parseUnmergedFiles(unmergedResult.stdout) : [];
-
-  const inProgress = Boolean(rebaseDir || rebaseHead || unmergedFiles.length > 0);
-
-  return {
-    inProgress,
-    rebaseHead,
-    detached,
-    unmergedFiles,
-    rebaseDir
-  };
+function detectRebaseState(cwd = process.cwd(), options = {}) {
+    const { gitRunner = git, fsModule = fsMod, pathModule = pathMod } = options;
+    const gitDirResult = gitRunner(['-C', cwd, 'rev-parse', '--git-dir']);
+    const resolvedGitDir = gitDirResult.status === 0
+        ? gitDirResult.stdout.trim()
+        : '.git';
+    const gitDir = pathModule.isAbsolute(resolvedGitDir)
+        ? resolvedGitDir
+        : pathModule.join(cwd, resolvedGitDir);
+    const rebaseMergeDir = pathModule.join(gitDir, 'rebase-merge');
+    const rebaseApplyDir = pathModule.join(gitDir, 'rebase-apply');
+    const rebaseDir = fsModule.existsSync(rebaseMergeDir)
+        ? rebaseMergeDir
+        : (fsModule.existsSync(rebaseApplyDir) ? rebaseApplyDir : null);
+    const headResult = gitRunner(['-C', cwd, 'symbolic-ref', '--quiet', '--short', 'HEAD']);
+    const detached = headResult.status !== 0;
+    const showCurrentResult = gitRunner(['-C', cwd, 'rebase', '--show-current']);
+    const rebaseHead = showCurrentResult.status === 0 ? showCurrentResult.stdout.trim() : '';
+    const unmergedResult = gitRunner(['-C', cwd, 'ls-files', '-u']);
+    const unmergedFiles = unmergedResult.status === 0 ? parseUnmergedFiles(unmergedResult.stdout) : [];
+    const inProgress = Boolean(rebaseDir || rebaseHead || unmergedFiles.length > 0);
+    return {
+        inProgress,
+        rebaseHead,
+        detached,
+        unmergedFiles,
+        rebaseDir
+    };
 }
-
 function getLastCommit() {
-  const result = git(['log', '-1', '--format=%H|%ad|%s']);
-  const [sha, date, subject] = result.stdout.trim().split('|');
-  return { sha, date, subject };
+    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');
+    const result = git(['log', '-3', '--format=%s']);
+    return result.stdout.trim().split('\n');
 }
-
-module.exports = {
-  git,
-  run,
-  getCurrentBranch,
-  getWorktreeStatus,
-  isDirty,
-  getUncommittedCount,
-  detectRebaseState,
-  getLastCommit,
-  getLastThreeCommits
-};

package/lib/core/git.ts

@@ -0,0 +1,146 @@
+import childProcess, { spawnSync } from 'node:child_process';
+import type { SpawnSyncOptions } from 'node:child_process';
+import * as fsMod from 'node:fs';
+import * as pathMod from 'node:path';
+
+interface GitOptions {
+  encoding?: BufferEncoding;
+  stdio?: import('node:child_process').StdioOptions;
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  maxBuffer?: number;
+  [key: string]: unknown;
+}
+
+interface GitResult {
+  status: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+  error?: Error | null;
+}
+
+export function git(args: string[], options: GitOptions = {}): GitResult {
+  const spawnOptions: SpawnSyncOptions = {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'] as const,
+    ...options
+  };
+  const result = spawnSync('git', args, spawnOptions);
+  if (result.error && result.status === null) {
+    throw result.error;
+  }
+  return { status: result.status, signal: result.signal, stdout: String(result.stdout ?? ''), stderr: String(result.stderr ?? ''), error: result.error };
+}
+
+export function run(command: string, args: string[], options: GitOptions = {}): GitResult {
+  const spawnOptions: SpawnSyncOptions = {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'] as const,
+    ...options
+  };
+  const result = spawnSync(command, args, spawnOptions);
+  if (result.error && result.status === null) {
+    throw result.error;
+  }
+  return { status: result.status, signal: result.signal, stdout: String(result.stdout ?? ''), stderr: String(result.stderr ?? ''), error: result.error };
+}
+
+export function getCurrentBranch(cwd: string = process.cwd()): string {
+  const result = git(['-C', cwd, 'branch', '--show-current']);
+  return result.stdout.trim();
+}
+
+export function getWorktreeStatus(cwd: string = process.cwd()): string[] {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  return result.stdout
+    .split('\n')
+    .map(line => line.trimEnd())
+    .filter(Boolean);
+}
+
+export function isDirty(cwd: string = process.cwd()): boolean {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  return result.stdout.trim().length > 0;
+}
+
+export function getUncommittedCount(cwd: string = process.cwd()): number {
+  const result = git(['-C', cwd, 'status', '--porcelain']);
+  if (!result.stdout.trim()) {return 0;}
+  return result.stdout.trim().split('\n').length;
+}
+
+export function parseUnmergedFiles(output: string = ''): string[] {
+  return Array.from(new Set(
+    output
+      .split('\n')
+      .map(line => line.trim())
+      .filter(Boolean)
+      .map(line => line.split('\t')[1])
+      .filter(Boolean)
+  ));
+}
+
+interface RebaseStateResult {
+  inProgress: boolean;
+  rebaseHead: string;
+  detached: boolean;
+  unmergedFiles: string[];
+  rebaseDir: string | null;
+}
+
+interface GitRunner {
+  (args: string[]): GitResult;
+}
+
+interface DetectRebaseOptions {
+  gitRunner?: GitRunner;
+  fsModule?: typeof fsMod;
+  pathModule?: typeof pathMod;
+}
+
+export function detectRebaseState(cwd: string = process.cwd(), options: DetectRebaseOptions = {}): RebaseStateResult {
+  const { gitRunner = git, fsModule = fsMod, pathModule = pathMod } = options;
+  const gitDirResult = gitRunner(['-C', cwd, 'rev-parse', '--git-dir']);
+  const resolvedGitDir = gitDirResult.status === 0
+    ? gitDirResult.stdout.trim()
+    : '.git';
+  const gitDir = pathModule.isAbsolute(resolvedGitDir)
+    ? resolvedGitDir
+    : pathModule.join(cwd, resolvedGitDir);
+  const rebaseMergeDir = pathModule.join(gitDir, 'rebase-merge');
+  const rebaseApplyDir = pathModule.join(gitDir, 'rebase-apply');
+  const rebaseDir = fsModule.existsSync(rebaseMergeDir)
+    ? rebaseMergeDir
+    : (fsModule.existsSync(rebaseApplyDir) ? rebaseApplyDir : null);
+
+  const headResult = gitRunner(['-C', cwd, 'symbolic-ref', '--quiet', '--short', 'HEAD']);
+  const detached = headResult.status !== 0;
+
+  const showCurrentResult = gitRunner(['-C', cwd, 'rebase', '--show-current']);
+  const rebaseHead = showCurrentResult.status === 0 ? showCurrentResult.stdout.trim() : '';
+
+  const unmergedResult = gitRunner(['-C', cwd, 'ls-files', '-u']);
+  const unmergedFiles = unmergedResult.status === 0 ? parseUnmergedFiles(unmergedResult.stdout) : [];
+
+  const inProgress = Boolean(rebaseDir || rebaseHead || unmergedFiles.length > 0);
+
+  return {
+    inProgress,
+    rebaseHead,
+    detached,
+    unmergedFiles,
+    rebaseDir
+  };
+}
+
+export function getLastCommit(): { sha: string; date: string; subject: string } {
+  const result = git(['log', '-1', '--format=%H|%ad|%s']);
+  const [sha, date, subject] = result.stdout.trim().split('|');
+  return { sha, date, subject };
+}
+
+export function getLastThreeCommits(): string[] {
+  const result = git(['log', '-3', '--format=%s']);
+  return result.stdout.trim().split('\n');
+}