@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-IUKOPCCE.js

@@ -0,0 +1,441 @@
+import {
+  filterProcessEntries,
+  formatRegistryAccessErrorJson,
+  validateProcessAction,
+  validateProcessFilters
+} from "./chunk-OC7Z6AJQ.js";
+import {
+  processScanner
+} from "./chunk-47X5LM7B.js";
+import {
+  RegistryStateAccessError,
+  isSignalEligible,
+  processRegistry
+} from "./chunk-QP5ST7RI.js";
+import {
+  reapOrphanedTmuxSessions
+} from "./chunk-B7PYTV72.js";
+import {
+  ExitCodeError,
+  isExitCodeError
+} from "./chunk-Y4ZDDHB6.js";
+import {
+  isYesAnswer
+} from "./chunk-O5X6BKAO.js";
+
+// src/cli/commands/processes.ts
+import chalk from "chalk";
+import { Command } from "commander";
+var CLEANUP_HEALTH_STATUSES = ["orphaned", "stale", "zombie"];
+var isCleanupHealthStatus = (value) => CLEANUP_HEALTH_STATUSES.includes(value);
+function exitProcessesCommand(code = 1) {
+  throw new ExitCodeError(code);
+}
+function shouldPreviewCleanup(options) {
+  return Boolean(options.dryRun || options.json && !options.force);
+}
+function emitCleanupJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+function validateProcessFilters2(options) {
+  try {
+    return validateProcessFilters(options);
+  } catch (error) {
+    console.error(chalk.red(error.message));
+    exitProcessesCommand();
+  }
+}
+function validateRequestedAction(actionArg, options) {
+  const optionActions = [];
+  if (options.list) optionActions.push("list");
+  if (options.cleanup) optionActions.push("cleanup");
+  if (options.health) optionActions.push("health");
+  if (options.scan) optionActions.push("scan");
+  if (options.kill) optionActions.push("kill");
+  return validateProcessAction(actionArg, ["list", "cleanup", "health", "scan"], optionActions);
+}
+function summarizeProcessEntries(allEntries) {
+  const entries = allEntries.filter(
+    (entry) => entry.health === "healthy" || isSignalEligible(entry)
+  );
+  return {
+    totalProcesses: entries.length,
+    healthyCount: entries.filter((entry) => entry.health === "healthy").length,
+    orphanedCount: entries.filter((entry) => entry.health === "orphaned").length,
+    staleCount: entries.filter((entry) => entry.health === "stale").length,
+    zombieCount: entries.filter((entry) => entry.health === "zombie").length,
+    orphanedPids: entries.filter((entry) => entry.health === "orphaned").map((entry) => entry.pid)
+  };
+}
+var processesCommand = new Command("processes").description("Manage Build processes (list, cleanup, health)").argument("[action]", "Action to run: list, cleanup, health, or scan").option("-l, --list", "List all managed processes (default)", false).option("-c, --cleanup", "Clean up orphaned processes", false).option("--health", "Show health status", false).option("--scan", "Scan for all Build processes", false).option("--kill <taskId>", "Kill processes for specific task").option("--category <type>", "Filter by category (cli, test, variant, etc.)").option("--type <type>", "Filter by type (spawned, detected, external)").option("--json", "Output as JSON", false).option("--dry-run", "Preview cleanup candidates without killing processes", false).option(
+  "-f, --force",
+  "Skip confirmation prompts (required with --json to execute cleanup)",
+  false
+).action(async (actionArg, options) => {
+  try {
+    const action = validateRequestedAction(actionArg, options);
+    await processRegistry.init();
+    switch (action) {
+      case "list":
+        await listProcesses(options);
+        break;
+      case "cleanup":
+        await cleanupProcesses(options);
+        break;
+      case "health":
+        await showHealth(options);
+        break;
+      case "scan":
+        await scanProcesses(options);
+        break;
+      case "kill":
+        await killTask(options.kill, options);
+        break;
+    }
+  } catch (error) {
+    if (isExitCodeError(error)) {
+      throw error;
+    }
+    if (error instanceof RegistryStateAccessError) {
+      if (options.json) {
+        console.log(formatRegistryAccessErrorJson(error));
+      } else {
+        console.error(chalk.red(`Error: ${error.message}`));
+      }
+      exitProcessesCommand();
+    }
+    console.error(chalk.red(`Error: ${error.message}`));
+    exitProcessesCommand();
+  }
+});
+async function listProcesses(options) {
+  await processRegistry.scan();
+  let entries = await processRegistry.getAll();
+  const filters = validateProcessFilters2(options);
+  entries = filterProcessEntries(entries, filters);
+  if (options.json) {
+    console.log(JSON.stringify(entries, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log(chalk.gray("No managed processes found."));
+    return;
+  }
+  console.log(chalk.bold(`
+Managed Processes (${entries.length})
+`));
+  console.log(
+    chalk.gray(
+      `${"PID".padEnd(8)}${"Category".padEnd(14)}${"Health".padEnd(12)}${"Age".padEnd(10)}${"Task ID".padEnd(20)}`
+    )
+  );
+  console.log(chalk.gray("-".repeat(70)));
+  for (const entry of entries) {
+    const pid = entry.pid.toString().padEnd(8);
+    const category = entry.category.padEnd(14);
+    const health = formatHealth(entry.health).padEnd(12);
+    const age = formatAge(entry.startedAt);
+    const taskId = (entry.taskId || "-").substring(0, 18).padEnd(20);
+    console.log(`${pid}${category}${health}${age}${taskId}`);
+  }
+  console.log("");
+}
+async function cleanupProcesses(options) {
+  const preview = shouldPreviewCleanup(options);
+  if (!options.json) {
+    console.log(chalk.gray("Scanning for processes..."));
+  }
+  await processScanner.scan({ includeAll: true });
+  await processRegistry.scan();
+  const orphaned = await processRegistry.getOrphaned();
+  const unhealthy = (await processRegistry.getAll()).filter(
+    (entry) => isCleanupHealthStatus(entry.health)
+  );
+  let candidates = [...orphaned, ...unhealthy].filter(isSignalEligible);
+  if (options.category) {
+    candidates = candidates.filter((e) => e.category === options.category);
+  }
+  if (options.type) {
+    candidates = candidates.filter((e) => e.type === options.type);
+  }
+  const uniquePids = new Set(candidates.map((c) => c.pid));
+  candidates = Array.from(uniquePids).map((pid) => candidates.find((c) => c.pid === pid));
+  const filters = validateProcessFilters2(options);
+  const tmuxSessionCandidates = await reapOrphanedTmuxSessions({
+    dryRun: true,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  if (candidates.length === 0 && tmuxSessionCandidates.length === 0) {
+    if (options.json) {
+      emitCleanupJson({
+        action: "cleanup",
+        dryRun: preview,
+        candidateCount: 0,
+        candidates: [],
+        tmuxSessions: [],
+        message: "No processes need cleanup"
+      });
+      return;
+    }
+    console.log(chalk.green("OK: No processes need cleanup"));
+    return;
+  }
+  if (preview) {
+    if (options.json) {
+      emitCleanupJson({
+        action: "cleanup",
+        dryRun: true,
+        candidateCount: candidates.length + tmuxSessionCandidates.length,
+        candidates,
+        tmuxSessions: tmuxSessionCandidates,
+        hint: "Add --force to execute cleanup (or omit --json/--dry-run for interactive cleanup)"
+      });
+      return;
+    }
+    console.log(
+      chalk.yellow(
+        `
+Dry run: Found ${candidates.length + tmuxSessionCandidates.length} process/session item(s) to clean up:
+`
+      )
+    );
+    for (const entry of candidates) {
+      const status = entry.health === "orphaned" ? chalk.red("orphaned") : chalk.yellow("stale");
+      console.log(
+        `  PID ${entry.pid} (${entry.category}) - ${status} - ${formatAge(entry.startedAt)}`
+      );
+    }
+    for (const session of tmuxSessionCandidates) {
+      console.log(`  tmux session ${session} - orphaned`);
+    }
+    console.log(chalk.gray("\nRe-run without --dry-run to execute cleanup."));
+    return;
+  }
+  if (!options.json) {
+    console.log(
+      chalk.yellow(
+        `
+Warning: Found ${candidates.length + tmuxSessionCandidates.length} process/session item(s) to clean up:
+`
+      )
+    );
+    for (const entry of candidates) {
+      const status = entry.health === "orphaned" ? chalk.red("orphaned") : chalk.yellow("stale");
+      console.log(
+        `  PID ${entry.pid} (${entry.category}) - ${status} - ${formatAge(entry.startedAt)}`
+      );
+    }
+    for (const session of tmuxSessionCandidates) {
+      console.log(`  tmux session ${session} - orphaned`);
+    }
+  }
+  if (!options.force) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk.bold("\nKill these processes? [y/N] "), resolve);
+    });
+    rl.close();
+    if (!isYesAnswer(answer)) {
+      if (options.json) {
+        emitCleanupJson({
+          action: "cleanup",
+          dryRun: true,
+          candidateCount: candidates.length + tmuxSessionCandidates.length,
+          candidates,
+          tmuxSessions: tmuxSessionCandidates,
+          message: "Aborted by user"
+        });
+      } else {
+        console.log(chalk.gray("Aborted."));
+      }
+      return;
+    }
+  }
+  if (!options.json) {
+    console.log(chalk.gray("\nCleaning up processes..."));
+  }
+  const result = await processRegistry.cleanup({
+    health: CLEANUP_HEALTH_STATUSES,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  const tmuxSessionsReaped = await reapOrphanedTmuxSessions({
+    dryRun: false,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  if (options.json) {
+    emitCleanupJson({
+      action: "cleanup",
+      dryRun: false,
+      candidateCount: candidates.length + tmuxSessionCandidates.length,
+      candidates,
+      tmuxSessions: tmuxSessionCandidates,
+      result: {
+        ...result,
+        tmuxSessionsReaped
+      }
+    });
+    return;
+  }
+  console.log(chalk.green("\nOK: Cleanup complete:"));
+  console.log(`  Attempted: ${result.attempted}`);
+  console.log(`  Killed: ${result.killed}`);
+  if (tmuxSessionsReaped.length > 0) {
+    console.log(`  Tmux sessions: ${tmuxSessionsReaped.length}`);
+  }
+  if (result.failed > 0) {
+    console.log(chalk.yellow(`  Failed: ${result.failed}`));
+  }
+  if (result.errors.length > 0) {
+    console.log(chalk.red("\nErrors:"));
+    for (const error of result.errors) {
+      console.log(`  PID ${error.pid}: ${error.error}`);
+    }
+  }
+}
+async function showHealth(options) {
+  const filters = validateProcessFilters2(options);
+  if (!options.json) {
+    console.log(chalk.gray("Scanning processes..."));
+  }
+  await processScanner.scan({ includeAll: true });
+  const unfilteredHealth = await processRegistry.scan();
+  const health = filters.category || filters.type ? summarizeProcessEntries(filterProcessEntries(await processRegistry.getAll(), filters)) : unfilteredHealth;
+  const tmuxSessions = await reapOrphanedTmuxSessions({
+    dryRun: true,
+    ...filters.category && { category: [filters.category] },
+    ...filters.type && { type: [filters.type] }
+  });
+  const tmuxOrphanedCount = tmuxSessions.length;
+  const unhealthyCount = health.orphanedCount + health.staleCount + health.zombieCount + tmuxOrphanedCount;
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...health,
+          tmuxOrphanedCount,
+          ...tmuxOrphanedCount > 0 ? { tmuxSessions } : {}
+        },
+        null,
+        2
+      )
+    );
+    if (unhealthyCount > 0) {
+      exitProcessesCommand(1);
+    }
+    return;
+  }
+  console.log(chalk.bold("\nHealth Report\n"));
+  console.log(`Total processes: ${health.totalProcesses}`);
+  console.log(`  Healthy: ${health.healthyCount}`);
+  console.log(`  Orphaned: ${health.orphanedCount}`);
+  console.log(`  Stale: ${health.staleCount}`);
+  console.log(`  Zombie: ${health.zombieCount}`);
+  console.log(`  Orphaned tmux sessions: ${tmuxOrphanedCount}`);
+  if (unhealthyCount > 0) {
+    console.log(
+      chalk.yellow(`
+Warning: Recommendation: Run ${chalk.bold("build processes --cleanup")}`)
+    );
+    console.log("");
+    exitProcessesCommand(1);
+  } else {
+    console.log(chalk.green("\nOK: All processes healthy"));
+  }
+  console.log("");
+}
+async function scanProcesses(options) {
+  if (!options.json) {
+    console.log(chalk.gray("Scanning for all Build processes..."));
+  }
+  const detected = await processScanner.scan({ includeAll: true });
+  if (options.json) {
+    console.log(JSON.stringify(detected, null, 2));
+    return;
+  }
+  console.log(chalk.bold(`
+Detected ${detected.length} process(es):
+`));
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const proc of detected) {
+    const list = byCategory.get(proc.category) || [];
+    list.push(proc);
+    byCategory.set(proc.category, list);
+  }
+  for (const [category, procs] of byCategory) {
+    console.log(chalk.bold(`${category.toUpperCase()} (${procs.length}):`));
+    for (const proc of procs) {
+      const orphan = proc.ppid === 1 ? chalk.red(" [ORPHANED]") : "";
+      console.log(`  PID ${proc.pid}${orphan}`);
+      console.log(chalk.gray(`    ${proc.command.substring(0, 80)}`));
+    }
+    console.log("");
+  }
+}
+async function killTask(taskId, options) {
+  const processes = await processRegistry.getByTaskId(taskId);
+  if (processes.length === 0) {
+    console.log(chalk.yellow(`No processes found for task: ${taskId}`));
+    return;
+  }
+  console.log(chalk.yellow(`Found ${processes.length} process(es) for task ${taskId}`));
+  if (!options.force) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(chalk.bold("Kill these processes? [y/N] "), resolve);
+    });
+    rl.close();
+    if (!isYesAnswer(answer)) {
+      console.log(chalk.gray("Aborted."));
+      return;
+    }
+  }
+  const registryPids = processes.map((entry) => entry.pid).filter((pid) => typeof pid === "number" && Number.isFinite(pid));
+  const registryResult = registryPids.length > 0 ? await processRegistry.cleanup({ pids: registryPids }) : { killed: 0, failed: 0, errors: [] };
+  const killed = Math.min(processes.length, registryResult.killed);
+  if (registryResult.failed > 0) {
+    console.log(
+      chalk.yellow(
+        `Warning: Failed to kill ${registryResult.failed} process(es) for task ${taskId}`
+      )
+    );
+  }
+  console.log(chalk.green(`OK: Killed ${killed} process(es)`));
+}
+function formatHealth(health) {
+  switch (health) {
+    case "healthy":
+      return chalk.green("healthy");
+    case "orphaned":
+      return chalk.red("orphaned");
+    case "stale":
+      return chalk.yellow("stale");
+    case "zombie":
+      return chalk.gray("zombie");
+    default:
+      return health;
+  }
+}
+function formatAge(startedAt) {
+  const started = new Date(startedAt).getTime();
+  const age = (Date.now() - started) / 1e3;
+  if (age < 60) return `${Math.floor(age)}s`;
+  if (age < 3600) return `${Math.floor(age / 60)}m`;
+  if (age < 86400) return `${Math.floor(age / 3600)}h`;
+  return `${Math.floor(age / 86400)}d`;
+}
+
+export {
+  processesCommand
+};
+//# sourceMappingURL=chunk-IUKOPCCE.js.map

package/dist/chunk-IVEPZQJO.js

@@ -0,0 +1,33 @@
+import {
+  getBucketArchivePath,
+  getBucketPath,
+  getBuckets
+} from "./chunk-V3KLVK7B.js";
+
+// src/core/git/managed-planning-dirs.ts
+import * as fs from "fs";
+import * as path from "path";
+function readManagedPlanningDirs(repoRoot) {
+  try {
+    const root = fs.realpathSync(repoRoot);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const bucket of getBuckets(repoRoot)) {
+      for (const absolute of [
+        getBucketPath(bucket, repoRoot),
+        getBucketArchivePath(bucket, repoRoot)
+      ]) {
+        const relative2 = path.relative(root, absolute).split(path.sep).join("/");
+        if (relative2 === "" || relative2 === ".." || relative2.startsWith("../")) continue;
+        dirs.add(relative2);
+      }
+    }
+    return [...dirs];
+  } catch {
+    return [];
+  }
+}
+
+export {
+  readManagedPlanningDirs
+};
+//# sourceMappingURL=chunk-IVEPZQJO.js.map

package/dist/chunk-IVZEONFC.js

@@ -0,0 +1,43 @@
+// src/core/config/judge-run-set.ts
+var SUPPORTED_JUDGE_IDS = ["ai", "multi-lens"];
+function retiredJudgeSelectionError(token) {
+  const normalized = token?.trim().toLowerCase();
+  if (normalized !== "multi-agent" && normalized !== "agentic") return void 0;
+  return new Error(
+    `The multi-agent judge was retired and can no longer be selected. Supported judges: ${SUPPORTED_JUDGE_IDS.join(", ")}.`
+  );
+}
+function canonicalJudgeId(token) {
+  const normalized = token?.trim().toLowerCase();
+  if (normalized === "ai") return "ai";
+  if (normalized === "multi-lens") return "multi-lens";
+  return null;
+}
+function parseJudgeRunSet(raw) {
+  const judges = [];
+  for (const value of raw.split(",")) {
+    const retired = retiredJudgeSelectionError(value);
+    if (retired) throw retired;
+    const judge = canonicalJudgeId(value);
+    if (judge && !judges.includes(judge)) judges.push(judge);
+  }
+  return judges;
+}
+function resolveJudgeRunSet(options, shadow) {
+  const retired = retiredJudgeSelectionError(options.aiJudgePrimary);
+  if (retired) throw retired;
+  const validPrimary = canonicalJudgeId(options.aiJudgePrimary) ?? void 0;
+  const judges = typeof options.aiJudgeRun === "string" ? parseJudgeRunSet(options.aiJudgeRun) : shadow ? ["ai", "multi-lens"] : options.aiJudgeRun === true ? ["ai"] : [validPrimary ?? "ai"];
+  if (judges.length === 0) judges.push("ai");
+  if (shadow && !judges.includes("multi-lens")) judges.push("multi-lens");
+  return judges;
+}
+
+export {
+  SUPPORTED_JUDGE_IDS,
+  retiredJudgeSelectionError,
+  canonicalJudgeId,
+  parseJudgeRunSet,
+  resolveJudgeRunSet
+};
+//# sourceMappingURL=chunk-IVZEONFC.js.map