@magnusekdahl/parallix 1.2.0 → 1.2.1

package/lib/core/runtime-matrix.ts

@@ -0,0 +1,84 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { eligibleAgentsForStep, workflowLauncherStatus } from '../agents/agents.js';
+
+const CONFIG_PATH = path.join(__dirname, '..', '..', 'config', 'agents.json');
+
+interface LauncherStatusResult {
+  supported: boolean;
+  detail: string;
+  health?: string;
+  reason?: string;
+}
+
+interface BuildMatrixOptions {
+  step?: string;
+  eligibleAgentsForStepFn?: typeof eligibleAgentsForStep;
+  workflowLauncherStatusFn?: typeof workflowLauncherStatus;
+  configPath?: string;
+  existsSyncFn?: typeof fs.existsSync;
+}
+
+export function launcherStatus(agent: string, options: { workflowLauncherStatusFn?: typeof workflowLauncherStatus } = {}): LauncherStatusResult {
+  const { workflowLauncherStatusFn = workflowLauncherStatus } = options;
+  return workflowLauncherStatusFn(agent);
+}
+
+export function buildAutonomousReviewMatrix(options: BuildMatrixOptions = {}): { step: string; agents: string[]; configPath: string; configPresent: boolean; launchers: Record<string, LauncherStatusResult> } {
+  const {
+    step = 'review',
+    eligibleAgentsForStepFn = eligibleAgentsForStep,
+    workflowLauncherStatusFn = workflowLauncherStatus,
+    configPath = CONFIG_PATH,
+    existsSyncFn = fs.existsSync
+  } = options;
+
+  const agents = eligibleAgentsForStepFn(step);
+  const launchers: Record<string, LauncherStatusResult> = Object.fromEntries(
+    agents.map((agent: string) => [agent, workflowLauncherStatusFn(agent)])
+  );
+
+  return {
+    step,
+    agents,
+    configPath,
+    configPresent: existsSyncFn(configPath),
+    launchers
+  };
+}
+
+export function formatMatrixSummary(matrix: { step: string; agents: string[]; configPath: string; configPresent: boolean; launchers: Record<string, LauncherStatusResult> }): string[] {
+  const lines: string[] = [];
+
+  lines.push(`Agent eligibility config: ${matrix.configPresent ? 'present' : 'missing'} (${matrix.configPath})`);
+  lines.push(`Launcher support matrix (step: ${matrix.step}):`);
+  for (const agent of matrix.agents) {
+    const launcher = matrix.launchers[agent];
+    const status = launcher.supported ? 'supported' : 'blocked';
+    const health = launcher.health ? `, ${launcher.health}` : '';
+    const reason = launcher.reason ? `; ${launcher.reason}` : '';
+    lines.push(`  - ${agent}: ${status} (${launcher.detail}${health}${reason})`);
+  }
+  lines.push(
+    'Reviewer is chosen at runtime from the eligible-and-supported pool, ' +
+    'excluding the implementer (config-driven via agents.json; no hardcoded routing).'
+  );
+
+  return lines;
+}
+
+interface RunnableDiffFamilyOptions {
+  step?: string;
+  eligibleAgentsForStepFn?: typeof eligibleAgentsForStep;
+  workflowLauncherStatusFn?: typeof workflowLauncherStatus;
+}
+
+export function runnableDifferentFamilyExists(implementer: string, options: RunnableDiffFamilyOptions = {}): boolean {
+  const {
+    step = 'review',
+    eligibleAgentsForStepFn = eligibleAgentsForStep,
+    workflowLauncherStatusFn = workflowLauncherStatus
+  } = options;
+  const agents = eligibleAgentsForStepFn(step);
+  return agents.some((a: string) => a !== implementer && workflowLauncherStatusFn(a).supported);
+}

package/lib/core/spawn-tee.js

@@ -1,200 +1,160 @@
-'use strict';
-
-const childProcess = require('child_process');
-const path = require('path');
-
-// Bound the in-memory transcript so a noisy or long-running agent cannot
-// turn the harness into an O(total-output) memory hog. Detection only needs
-// a recent window to find limit-hit phrases (limit-hit.js clips ~200 chars
-// around the match), so a tail buffer is sufficient. The cap is generous
-// enough that a real limit-hit message and its surrounding reset-time
-// context land in the buffer even if the agent printed a lot before exiting.
-const DEFAULT_MAX_TAIL_BYTES = 64 * 1024;
-
-/** @typedef {Buffer|string} ChunkType */
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TailBuffer = exports.DEFAULT_MAX_TAIL_BYTES = void 0;
+exports.spawnAndTee = spawnAndTee;
+const node_child_process_1 = __importDefault(require("node:child_process"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.DEFAULT_MAX_TAIL_BYTES = 64 * 1024;
 class TailBuffer {
-  /** @param {number} maxBytes */
-  constructor(maxBytes) {
-    /** @type {number} */
-    this.maxBytes = maxBytes;
-    /** @type {ChunkType[]} */
-    this.chunks = [];
-    /** @type {number} */
-    this.size = 0;
-  }
-
-  /** @param {ChunkType} chunk */
-  push(chunk) {
-    this.chunks.push(chunk);
-    this.size += chunk.length;
-    while (this.size > this.maxBytes && this.chunks.length > 0) {
-      const head = this.chunks[0];
-      const overflow = this.size - this.maxBytes;
-      if (head.length <= overflow) {
-        this.chunks.shift();
-        this.size -= head.length;
-      } else {
-        if (Buffer.isBuffer(head)) {
-          this.chunks[0] = head.subarray(overflow);
-        } else {
-          this.chunks.shift();
-          this.size -= head.length;
+    maxBytes;
+    chunks;
+    size;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+        this.chunks = [];
+        this.size = 0;
+    }
+    push(chunk) {
+        this.chunks.push(chunk);
+        this.size += chunk.length;
+        while (this.size > this.maxBytes && this.chunks.length > 0) {
+            const head = this.chunks[0];
+            const overflow = this.size - this.maxBytes;
+            if (head.length <= overflow) {
+                this.chunks.shift();
+                this.size -= head.length;
+            }
+            else {
+                if (Buffer.isBuffer(head)) {
+                    this.chunks[0] = head.subarray(overflow);
+                }
+                else {
+                    this.chunks.shift();
+                    this.size -= head.length;
+                }
+                this.size -= overflow;
+            }
+        }
+    }
+    toString() {
+        if (this.chunks.length === 0) {
+            return '';
         }
-        this.size -= overflow;
-      }
+        return Buffer.concat(this.chunks).toString('utf8');
     }
-  }
-
-  toString() {
-    if (this.chunks.length === 0) {return '';}
-    return Buffer.concat(/** @type {Buffer[]} */(this.chunks)).toString('utf8');
-  }
 }
-
-/**
- * Spawn a child process and tee its stdout/stderr to the parent's streams
- * while keeping a bounded tail of the output in memory. Returns a Promise
- * resolving with a result shaped like `spawnSync` (status, signal, stdout,
- * stderr, error) but with stdout/stderr as utf-8 strings populated even
- * when stdio:'inherit' is requested. Forces stdio to ['inherit', 'pipe',
- * 'pipe'] internally so the parent's stdin is preserved while child output
- * remains capturable.
- *
- * Pure I/O wrapper: no policy, no retry, no agent knowledge.
- */
-/**
- * @param {string} command
- * @param {string[]} args
- * @param {{stdoutSink?: NodeJS.WriteStream, stderrSink?: NodeJS.WriteStream, maxTailBytes?: number, noOutputWatchdog?: {onNoOutput?: Function, initialDelayMs?: number, intervalMs?: number}, cwd?: string, env?: Record<string, string>, [key: string]: any}} [options]
- */
+exports.TailBuffer = TailBuffer;
 function spawnAndTee(command, args, options = {}) {
-  const {
-    stdoutSink = process.stdout,
-    stderrSink = process.stderr,
-    maxTailBytes = DEFAULT_MAX_TAIL_BYTES,
-    noOutputWatchdog = null,
-    ...spawnOptions
-  } = options;
-
-  return new Promise((resolve) => {
-    const stdoutTail = new TailBuffer(maxTailBytes);
-    const stderrTail = new TailBuffer(maxTailBytes);
-    /** @type {boolean} */
-    let settled = false;
-    /** @type {boolean} */
-    let sawOutput = false;
-    /** @type {ReturnType<typeof setTimeout> | null} */
-    let watchdogTimer = null;
-    const startTime = Date.now();
-    const resolvedCwd = path.resolve(spawnOptions.cwd || process.cwd());
-    const env = {
-      ...process.env,
-      ...(spawnOptions.env || {}),
-      PWD: resolvedCwd
-    };
-
-    let child;
-    try {
-      child = childProcess.spawn(command, args, {
-        ...spawnOptions,
-        env,
-        stdio: ['inherit', 'pipe', 'pipe']
-      });
-    } catch (err) {
-      resolve({
-        status: null, signal: null, stdout: '', stderr: '', error: err,
-        startedAt: new Date(startTime).toISOString(), endedAt: new Date().toISOString()
-      });
-      return;
-    }
-
-    const clearWatchdog = () => {
-      if (watchdogTimer) {
-        clearTimeout(watchdogTimer);
-        watchdogTimer = null;
-      }
-    };
-
-    /** @param {{status: number|null, signal: string|null, stdout: string, stderr: string, error: any, startedAt: string, endedAt: string}} payload */
-    const finish = (payload) => {
-      if (settled) {return;}
-      settled = true;
-      clearWatchdog();
-      payload.startedAt = new Date(startTime).toISOString();
-      payload.endedAt = new Date().toISOString();
-      resolve(payload);
-    };
-
-    /** @param {number} delayMs */
-    const scheduleWatchdog = (delayMs) => {
-      if (!noOutputWatchdog || typeof noOutputWatchdog.onNoOutput !== 'function') {return;}
-      const delay = Number.isFinite(delayMs) && delayMs >= 0 ? delayMs : 0;
-      watchdogTimer = setTimeout(() => {
-        watchdogTimer = null;
-        if (settled || sawOutput) {return;}
-        if (typeof noOutputWatchdog.onNoOutput === 'function') {
-          noOutputWatchdog.onNoOutput({
-          command,
-          args,
-          pid: child.pid,
-          elapsedMs: Date.now() - startTime
+    const { stdoutSink = process.stdout, stderrSink = process.stderr, maxTailBytes = exports.DEFAULT_MAX_TAIL_BYTES, noOutputWatchdog = null, ...spawnOptions } = options;
+    return new Promise((resolve) => {
+        const stdoutTail = new TailBuffer(maxTailBytes);
+        const stderrTail = new TailBuffer(maxTailBytes);
+        let settled = false;
+        let sawOutput = false;
+        let watchdogTimer = null;
+        const startTime = Date.now();
+        const resolvedCwd = node_path_1.default.resolve(spawnOptions.cwd || process.cwd());
+        const env = {
+            ...process.env,
+            ...(spawnOptions.env || {}),
+            PWD: resolvedCwd
+        };
+        let child;
+        try {
+            child = node_child_process_1.default.spawn(command, args, {
+                ...spawnOptions,
+                env,
+                stdio: ['inherit', 'pipe', 'pipe']
+            });
+        }
+        catch (err) {
+            resolve({
+                status: null, signal: null, stdout: '', stderr: '', error: err,
+                startedAt: new Date(startTime).toISOString(), endedAt: new Date().toISOString()
+            });
+            return;
+        }
+        const clearWatchdog = () => {
+            if (watchdogTimer) {
+                clearTimeout(watchdogTimer);
+                watchdogTimer = null;
+            }
+        };
+        const finish = (payload) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearWatchdog();
+            payload.startedAt = new Date(startTime).toISOString();
+            payload.endedAt = new Date().toISOString();
+            resolve(payload);
+        };
+        const scheduleWatchdog = (delayMs) => {
+            if (!noOutputWatchdog || typeof noOutputWatchdog.onNoOutput !== 'function') {
+                return;
+            }
+            const delay = Number.isFinite(delayMs) && delayMs >= 0 ? delayMs : 0;
+            watchdogTimer = setTimeout(() => {
+                watchdogTimer = null;
+                if (settled || sawOutput) {
+                    return;
+                }
+                if (typeof noOutputWatchdog.onNoOutput === 'function') {
+                    noOutputWatchdog.onNoOutput({
+                        command,
+                        args,
+                        pid: child.pid,
+                        elapsedMs: Date.now() - startTime
+                    });
+                }
+                scheduleWatchdog(noOutputWatchdog.intervalMs ?? 0);
+            }, delay);
+            if (typeof watchdogTimer.unref === 'function') {
+                watchdogTimer.unref();
+            }
+        };
+        const noteOutput = () => {
+            sawOutput = true;
+            clearWatchdog();
+        };
+        if (noOutputWatchdog) {
+            scheduleWatchdog(noOutputWatchdog.initialDelayMs ?? 0);
+        }
+        child.stdout?.on('data', (chunk) => {
+            noteOutput();
+            stdoutTail.push(chunk);
+            if (stdoutSink && typeof stdoutSink.write === 'function') {
+                stdoutSink.write(chunk);
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            noteOutput();
+            stderrTail.push(chunk);
+            if (stderrSink && typeof stderrSink.write === 'function') {
+                stderrSink.write(chunk);
+            }
+        });
+        child.on('error', (err) => {
+            finish({
+                status: null,
+                signal: null,
+                stdout: stdoutTail.toString(),
+                stderr: stderrTail.toString(),
+                error: err,
+            });
+        });
+        child.on('close', (code, signal) => {
+            finish({
+                status: code,
+                signal,
+                stdout: stdoutTail.toString(),
+                stderr: stderrTail.toString(),
+                error: null,
+            });
         });
-      }
-        scheduleWatchdog(noOutputWatchdog.intervalMs ?? 0);
-      }, delay);
-      if (typeof watchdogTimer.unref === 'function') {
-        watchdogTimer.unref();
-      }
-    };
-
-    const noteOutput = () => {
-      sawOutput = true;
-      clearWatchdog();
-    };
-
-    if (noOutputWatchdog) {
-      scheduleWatchdog(noOutputWatchdog.initialDelayMs ?? 0);
-    }
-
-    child.stdout.on('data', (chunk) => {
-      noteOutput();
-      stdoutTail.push(chunk);
-      if (stdoutSink && typeof stdoutSink.write === 'function') {
-        stdoutSink.write(chunk);
-      }
-    });
-    child.stderr.on('data', (chunk) => {
-      noteOutput();
-      stderrTail.push(chunk);
-      if (stderrSink && typeof stderrSink.write === 'function') {
-        stderrSink.write(chunk);
-      }
-    });
-
-    child.on('error', (/** @type {Error} */ err) => {
-      finish({
-        status: null,
-        signal: null,
-        stdout: stdoutTail.toString(),
-        stderr: stderrTail.toString(),
-        error: err,
-        startedAt: new Date(startTime).toISOString(),
-        endedAt: new Date().toISOString()
-      });
-    });
-
-    child.on('close', (/** @type {number|null} */ code, /** @type {string|null} */ signal) => {
-      finish({
-        status: code,
-        signal,
-        stdout: stdoutTail.toString(),
-        stderr: stderrTail.toString(),
-        error: null,
-        startedAt: new Date(startTime).toISOString(),
-        endedAt: new Date().toISOString()
-      });
     });
-  });
 }
-
-module.exports = { spawnAndTee, DEFAULT_MAX_TAIL_BYTES };

package/lib/core/spawn-tee.ts

@@ -0,0 +1,202 @@
+import childProcess from 'node:child_process';
+import type { SpawnOptions, ChildProcess } from 'node:child_process';
+import path from 'node:path';
+
+export const DEFAULT_MAX_TAIL_BYTES = 64 * 1024;
+
+type ChunkType = Buffer | string;
+
+interface SpawnTeeResult {
+  status: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+  error: unknown | null;
+  startedAt: string;
+  endedAt: string;
+}
+
+interface NoOutputWatchdog {
+  onNoOutput?: (event: { command: string; args: string[]; pid: number | undefined; elapsedMs: number }) => void;
+  initialDelayMs?: number;
+  intervalMs?: number;
+}
+
+interface SpawnTeeOptions {
+  stdoutSink?: NodeJS.WriteStream;
+  stderrSink?: NodeJS.WriteStream;
+  maxTailBytes?: number;
+  noOutputWatchdog?: NoOutputWatchdog | null;
+  cwd?: string;
+  env?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export class TailBuffer {
+  maxBytes: number;
+  chunks: ChunkType[];
+  size: number;
+
+  constructor(maxBytes: number) {
+    this.maxBytes = maxBytes;
+    this.chunks = [];
+    this.size = 0;
+  }
+
+  push(chunk: ChunkType): void {
+    this.chunks.push(chunk);
+    this.size += chunk.length;
+    while (this.size > this.maxBytes && this.chunks.length > 0) {
+      const head = this.chunks[0];
+      const overflow = this.size - this.maxBytes;
+      if (head.length <= overflow) {
+        this.chunks.shift();
+        this.size -= head.length;
+      } else {
+        if (Buffer.isBuffer(head)) {
+          this.chunks[0] = head.subarray(overflow);
+        } else {
+          this.chunks.shift();
+          this.size -= head.length;
+        }
+        this.size -= overflow;
+      }
+    }
+  }
+
+  toString(): string {
+    if (this.chunks.length === 0) {return '';}
+    return Buffer.concat(this.chunks as Buffer[]).toString('utf8');
+  }
+}
+
+interface FinishPayload {
+  status: number | null;
+  signal: string | null;
+  stdout: string;
+  stderr: string;
+  error: unknown | null;
+  startedAt?: string;
+  endedAt?: string;
+}
+
+export function spawnAndTee(command: string, args: string[], options: SpawnTeeOptions = {}): Promise<SpawnTeeResult> {
+  const {
+    stdoutSink = process.stdout,
+    stderrSink = process.stderr,
+    maxTailBytes = DEFAULT_MAX_TAIL_BYTES,
+    noOutputWatchdog = null,
+    ...spawnOptions
+  } = options;
+
+  return new Promise((resolve) => {
+    const stdoutTail = new TailBuffer(maxTailBytes);
+    const stderrTail = new TailBuffer(maxTailBytes);
+    let settled = false;
+    let sawOutput = false;
+    let watchdogTimer: ReturnType<typeof setTimeout> | null = null;
+    const startTime = Date.now();
+    const resolvedCwd = path.resolve((spawnOptions.cwd as string) || process.cwd());
+    const env: Record<string, string> = {
+      ...process.env,
+      ...(spawnOptions.env || {}),
+      PWD: resolvedCwd
+    };
+
+    let child: ChildProcess;
+    try {
+      child = childProcess.spawn(command, args, {
+        ...spawnOptions,
+        env,
+        stdio: ['inherit', 'pipe', 'pipe']
+      } as SpawnOptions);
+    } catch (err) {
+      resolve({
+        status: null, signal: null, stdout: '', stderr: '', error: err,
+        startedAt: new Date(startTime).toISOString(), endedAt: new Date().toISOString()
+      });
+      return;
+    }
+
+    const clearWatchdog = (): void => {
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
+    };
+
+    const finish = (payload: FinishPayload): void => {
+      if (settled) {return;}
+      settled = true;
+      clearWatchdog();
+      payload.startedAt = new Date(startTime).toISOString();
+      payload.endedAt = new Date().toISOString();
+      resolve(payload as SpawnTeeResult);
+    };
+
+    const scheduleWatchdog = (delayMs: number): void => {
+      if (!noOutputWatchdog || typeof noOutputWatchdog.onNoOutput !== 'function') {return;}
+      const delay = Number.isFinite(delayMs) && delayMs >= 0 ? delayMs : 0;
+      watchdogTimer = setTimeout(() => {
+        watchdogTimer = null;
+        if (settled || sawOutput) {return;}
+        if (typeof noOutputWatchdog.onNoOutput === 'function') {
+          noOutputWatchdog.onNoOutput({
+            command,
+            args,
+            pid: child.pid,
+            elapsedMs: Date.now() - startTime
+          });
+        }
+        scheduleWatchdog(noOutputWatchdog.intervalMs ?? 0);
+      }, delay);
+      if (typeof watchdogTimer.unref === 'function') {
+        watchdogTimer.unref();
+      }
+    };
+
+    const noteOutput = (): void => {
+      sawOutput = true;
+      clearWatchdog();
+    };
+
+    if (noOutputWatchdog) {
+      scheduleWatchdog(noOutputWatchdog.initialDelayMs ?? 0);
+    }
+
+    child.stdout?.on('data', (chunk: Buffer) => {
+      noteOutput();
+      stdoutTail.push(chunk);
+      if (stdoutSink && typeof stdoutSink.write === 'function') {
+        stdoutSink.write(chunk);
+      }
+    });
+    child.stderr?.on('data', (chunk: Buffer) => {
+      noteOutput();
+      stderrTail.push(chunk);
+      if (stderrSink && typeof stderrSink.write === 'function') {
+        stderrSink.write(chunk);
+      }
+    });
+
+    child.on('error', (err: Error) => {
+      finish({
+        status: null,
+        signal: null,
+        stdout: stdoutTail.toString(),
+        stderr: stderrTail.toString(),
+        error: err,
+      });
+    });
+
+    child.on('close', (code: number | null, signal: string | null) => {
+      finish({
+        status: code,
+        signal,
+        stdout: stdoutTail.toString(),
+        stderr: stderrTail.toString(),
+        error: null,
+      });
+    });
+  });
+}