@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/inspect.js

@@ -0,0 +1,174 @@
+// @bun
+// packages/cli/src/commands/inspect.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`);
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+
+// packages/cli/src/commands/inspect.ts
+import {
+  listAuthorityRuns,
+  readAuthorityRun,
+  resolveAuthorityRunDir,
+  resolveTaskArtifactDirs
+} from "@rig/runtime/control-plane/authority-files";
+import { changedFilesForTask } from "@rig/runtime/control-plane/native/task-ops";
+import { resolveHarnessPaths, resolveMonorepoRoot, runCapture } from "@rig/runtime/control-plane/native/utils";
+import { readTaskArtifactPreview } from "@rig/runtime/control-plane/native/workspace-ops";
+async function executeInspect(context, args) {
+  const [command = "failures", ...rest] = args;
+  switch (command) {
+    case "logs": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig inspect logs --task <beads-id>");
+      const requiredTask = requireTask(task, "bun run rig inspect logs --task <beads-id>");
+      const latestRun = listAuthorityRuns(context.projectRoot).map((entry) => readAuthorityRun(context.projectRoot, entry.runId)).filter((run) => Boolean(run)).filter((run) => run.taskId === requiredTask).sort((left, right) => String(right.updatedAt ?? "").localeCompare(String(left.updatedAt ?? "")))[0];
+      if (!latestRun) {
+        throw new CliError2(`No runs found for ${requiredTask}.`);
+      }
+      const logsPath = resolve(resolveAuthorityRunDir(context.projectRoot, latestRun.runId), "logs.jsonl");
+      if (!existsSync(logsPath)) {
+        throw new CliError2(`No logs found for run ${latestRun.runId}.`);
+      }
+      await context.runCommand(["cat", logsPath]);
+      return { ok: true, group: "inspect", command, details: { task: requiredTask, runId: latestRun.runId } };
+    }
+    case "artifacts": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig inspect artifacts --task <beads-id>");
+      const requiredTask = requireTask(task, "bun run rig inspect artifacts --task <beads-id>");
+      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync(path));
+      if (!artifactRoot) {
+        throw new CliError2(`No artifacts found for ${requiredTask}.`);
+      }
+      await context.runCommand(["ls", "-la", artifactRoot]);
+      return { ok: true, group: "inspect", command, details: { task: requiredTask } };
+    }
+    case "artifact": {
+      let previewPending = rest;
+      const task = takeOption(previewPending, "--task");
+      previewPending = task.rest;
+      const file = takeOption(previewPending, "--file");
+      previewPending = file.rest;
+      requireNoExtraArgs(previewPending, "bun run rig inspect artifact --task <beads-id> --file <name>");
+      const requiredTask = requireTask(task.value, "bun run rig inspect artifact --task <beads-id> --file <name>");
+      if (!file.value) {
+        throw new CliError2("Missing --file for rig inspect artifact.");
+      }
+      const preview = readTaskArtifactPreview(context.projectRoot, requiredTask, file.value);
+      if (context.outputMode === "text") {
+        console.log(preview.contents);
+        if (preview.truncated) {
+          console.log(`
+[preview truncated at ${preview.maxBytes} bytes of ${preview.sizeBytes}]`);
+        }
+      }
+      return {
+        ok: true,
+        group: "inspect",
+        command,
+        details: {
+          task: requiredTask,
+          fileName: file.value,
+          path: preview.path,
+          sizeBytes: preview.sizeBytes,
+          truncated: preview.truncated,
+          maxBytes: preview.maxBytes,
+          contents: context.outputMode === "json" ? preview.contents : null
+        }
+      };
+    }
+    case "diff": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig inspect diff [--task <beads-id>]");
+      if (task) {
+        const files = changedFilesForTask(context.projectRoot, task, false);
+        for (const file of files) {
+          console.log(file);
+        }
+      } else {
+        await context.runCommand(["git", "diff", "--stat"]);
+      }
+      return { ok: true, group: "inspect", command, details: { task: task || null } };
+    }
+    case "failures": {
+      requireNoExtraArgs(rest, "bun run rig inspect failures");
+      const failed = resolveHarnessPaths(context.projectRoot).failedApproachesPath;
+      if (!existsSync(failed)) {
+        console.log("No failures recorded.");
+      } else {
+        process.stdout.write(readFileSync(failed, "utf-8"));
+      }
+      return { ok: true, group: "inspect", command };
+    }
+    case "graph":
+      requireNoExtraArgs(rest, "bun run rig inspect graph");
+      {
+        const monorepoRoot = resolveMonorepoRoot(context.projectRoot);
+        const result = runCapture(["br", "--no-db", "list", "--pretty"], monorepoRoot);
+        if (result.exitCode !== 0) {
+          throw new CliError2(result.stderr || result.stdout || "Failed to inspect graph");
+        }
+        process.stdout.write(result.stdout);
+      }
+      return { ok: true, group: "inspect", command };
+    case "audit": {
+      requireNoExtraArgs(rest, "bun run rig inspect audit");
+      const auditPath = resolve(resolveHarnessPaths(context.projectRoot).logsDir, "audit.jsonl");
+      if (!existsSync(auditPath)) {
+        console.log("No audit log found.");
+      } else {
+        const lines = readFileSync(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-20);
+        for (const line of lines) {
+          console.log(line);
+        }
+      }
+      return { ok: true, group: "inspect", command };
+    }
+    default:
+      throw new CliError2(`Unknown inspect command: ${command}`);
+  }
+}
+export {
+  executeInspect
+};

package/dist/src/commands/inspector.js

@@ -0,0 +1,256 @@
+// @bun
+// packages/cli/src/commands/inspector.ts
+import { iterateServerSentEvents } from "@rig/client";
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`);
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli/src/commands/inspector.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_parsers.ts
+function parseRequiredPositiveInt(value, option) {
+  if (!value) {
+    throw new CliError2(`Missing value for ${option}.`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError2(`Invalid ${option} value: ${value}`);
+  }
+  return parsed;
+}
+
+// packages/cli/src/commands/inspector.ts
+function formatInspectorStreamLine(payload) {
+  const emittedAt = payload.emittedAt ?? new Date().toISOString();
+  const agentStatus = String(payload.agent?.status ?? "unknown");
+  const queueDepth = Number(payload.agent?.queueDepth ?? 0);
+  const activeRuns = Array.isArray(payload.snapshot?.activeRuns) ? payload.snapshot?.activeRuns.length : 0;
+  const lines = [
+    `[${emittedAt}] seq=${String(payload.sequence ?? "?")} agent=${agentStatus} queue=${queueDepth} activeRuns=${activeRuns}`
+  ];
+  const lastAssistantMessage = payload.agent?.lastAssistantMessage?.trim();
+  if (lastAssistantMessage) {
+    lines.push(`  assistant: ${lastAssistantMessage.split(`
+`)[0].slice(0, 240)}`);
+  }
+  const recentProtocol = payload.agent?.recentProtocolEvents;
+  const latestProtocol = Array.isArray(recentProtocol) && recentProtocol.length > 0 ? recentProtocol[recentProtocol.length - 1] : null;
+  if (latestProtocol?.method) {
+    lines.push(`  protocol: ${String(latestProtocol.direction ?? "recv")} ${String(latestProtocol.kind ?? "notification")} ${latestProtocol.method}`);
+  }
+  const finding = Array.isArray(payload.journal?.recentFindings) && payload.journal?.recentFindings.length > 0 ? payload.journal?.recentFindings[0] : null;
+  if (finding?.summary) {
+    lines.push(`  finding: ${String(finding.source ?? "journal")} \xB7 ${finding.summary}`);
+  }
+  const action = Array.isArray(payload.journal?.recentActions) && payload.journal?.recentActions.length > 0 ? payload.journal?.recentActions[0] : null;
+  if (action?.actionType) {
+    lines.push(`  action: ${action.actionType} (${String(action.status ?? "unknown")})${action.target ? ` -> ${action.target}` : ""}`);
+  }
+  return lines;
+}
+async function executeInspector(context, args) {
+  const [command = "stream", ...rest] = args;
+  switch (command) {
+    case "stream": {
+      let pending = rest;
+      const onceResult = takeFlag(pending, "--once");
+      pending = onceResult.rest;
+      const secondsResult = takeOption(pending, "--seconds");
+      pending = secondsResult.rest;
+      const pollMsResult = takeOption(pending, "--poll-ms");
+      pending = pollMsResult.rest;
+      requireNoExtraArgs(pending, "bun run rig inspector stream [--once] [--seconds <n>] [--poll-ms <n>]");
+      const seconds = secondsResult.value ? parseRequiredPositiveInt(secondsResult.value, "--seconds") : null;
+      const pollMs = pollMsResult.value ? parseRequiredPositiveInt(pollMsResult.value, "--poll-ms") : null;
+      if (context.outputMode === "json" && !onceResult.value && !seconds) {
+        throw new CliError2("--json inspector stream requires --once or --seconds <n>.", 2);
+      }
+      const connection = await ensureLocalRigServerConnection(context.projectRoot);
+      const streamUrl = new URL("/api/inspector/stream", connection.baseUrl);
+      if (onceResult.value) {
+        streamUrl.searchParams.set("once", "1");
+      }
+      if (pollMs) {
+        streamUrl.searchParams.set("pollMs", String(pollMs));
+      }
+      const controller = new AbortController;
+      const deadline = seconds ? setTimeout(() => controller.abort(), seconds * 1000) : null;
+      let interrupted = false;
+      const onSignal = () => {
+        interrupted = true;
+        controller.abort();
+      };
+      if (!onceResult.value) {
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+      }
+      try {
+        const response = await fetch(streamUrl, {
+          headers: connection.authToken ? { authorization: `Bearer ${connection.authToken}` } : undefined,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          throw new CliError2(`Inspector stream request failed (${response.status}).`, response.status);
+        }
+        let received = 0;
+        let lastEvent = null;
+        for await (const event of iterateServerSentEvents(response)) {
+          const payload = JSON.parse(event.data);
+          lastEvent = { event: event.event, payload };
+          received += 1;
+          if (context.outputMode === "text" && event.event === "snapshot") {
+            for (const line of formatInspectorStreamLine(payload)) {
+              console.log(line);
+            }
+          } else if (context.outputMode === "text") {
+            console.log(`[inspector:${event.event}] ${event.data}`);
+          }
+          if (onceResult.value) {
+            break;
+          }
+        }
+        return {
+          ok: true,
+          group: "inspector",
+          command,
+          details: {
+            streamUrl: streamUrl.toString(),
+            received,
+            interrupted,
+            once: onceResult.value,
+            seconds,
+            lastEvent
+          }
+        };
+      } catch (error) {
+        if (controller.signal.aborted && !onceResult.value) {
+          return {
+            ok: true,
+            group: "inspector",
+            command,
+            details: {
+              streamUrl: streamUrl.toString(),
+              received: 0,
+              interrupted: true,
+              once: onceResult.value,
+              seconds,
+              lastEvent: null
+            }
+          };
+        }
+        throw error;
+      } finally {
+        if (deadline) {
+          clearTimeout(deadline);
+        }
+        if (!onceResult.value) {
+          process.off("SIGINT", onSignal);
+          process.off("SIGTERM", onSignal);
+        }
+      }
+    }
+    case "scan-upstream-drift": {
+      let pending = rest;
+      const scanIdResult = takeOption(pending, "--scan-id");
+      pending = scanIdResult.rest;
+      requireNoExtraArgs(pending, "bun run rig inspector scan-upstream-drift [--scan-id <id>]");
+      const connection = await ensureLocalRigServerConnection(context.projectRoot);
+      const response = await fetch(new URL("/api/inspector/tools/invoke", connection.baseUrl), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...connection.authToken ? { authorization: `Bearer ${connection.authToken}` } : {}
+        },
+        body: JSON.stringify({
+          name: "scan_upstream_drift",
+          input: scanIdResult.value ? { scanId: scanIdResult.value } : {}
+        })
+      });
+      if (!response.ok) {
+        throw new CliError2(`Upstream drift scan request failed (${response.status}).`, response.status);
+      }
+      const result = await response.json();
+      if (context.outputMode === "text") {
+        console.log(String(result.summary ?? "Upstream drift scan completed"));
+        const details = result.details;
+        if (details && typeof details === "object" && !Array.isArray(details)) {
+          const record = details;
+          if (typeof record.scannedCommitCount === "number") {
+            console.log(`  scanned commits: ${record.scannedCommitCount}`);
+          }
+          if (typeof record.ignoredCommitCount === "number") {
+            console.log(`  ignored commits: ${record.ignoredCommitCount}`);
+          }
+          if (typeof record.followupCount === "number") {
+            console.log(`  follow-up tasks: ${record.followupCount}`);
+          }
+          if (Array.isArray(record.createdTaskIds) && record.createdTaskIds.length > 0) {
+            console.log(`  created tasks: ${record.createdTaskIds.join(", ")}`);
+          }
+          if (typeof record.latestHeadSha === "string" && record.latestHeadSha.length > 0) {
+            console.log(`  latest upstream head: ${record.latestHeadSha}`);
+          }
+        }
+      }
+      return {
+        ok: true,
+        group: "inspector",
+        command,
+        details: {
+          scanId: scanIdResult.value ?? null,
+          result
+        }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown inspector command: ${command}`);
+  }
+}
+export {
+  executeInspector
+};

package/dist/src/commands/plugin.js

@@ -0,0 +1,167 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function takeOption(args, option) {
+  const rest = [];
+  let value;
+  for (let index = 0;index < args.length; index += 1) {
+    const current = args[index];
+    if (current === option) {
+      const next = args[index + 1];
+      if (!next || next.startsWith("-")) {
+        throw new CliError(`Missing value for ${option}`);
+      }
+      value = next;
+      index += 1;
+      continue;
+    }
+    if (current !== undefined) {
+      rest.push(current);
+    }
+  }
+  return { value, rest };
+}
+function requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+function requireTask(taskId, usage) {
+  if (!taskId) {
+    throw new CliError(`Missing --task option.
+Usage: ${usage}`);
+  }
+  return taskId;
+}
+
+// packages/cli/src/commands/_parsers.ts
+async function loadRigConfigOrNull(projectRoot) {
+  try {
+    const { loadConfig } = await import("@rig/core/load-config");
+    return await loadConfig(projectRoot);
+  } catch {
+    return null;
+  }
+}
+
+// packages/cli/src/commands/plugin.ts
+async function executePlugin(context, args) {
+  const [command = "list", ...rest] = args;
+  switch (command) {
+    case "list": {
+      requireNoExtraArgs(rest, "bun run rig plugin list");
+      const legacyPlugins = context.plugins.list();
+      const declarative = [];
+      const config = await loadRigConfigOrNull(context.projectRoot);
+      if (config && Array.isArray(config.plugins)) {
+        for (const plugin of config.plugins) {
+          const c = plugin.contributes ?? {};
+          declarative.push({
+            name: plugin.name,
+            version: plugin.version,
+            validators: (c.validators ?? []).map((v) => v.id),
+            hooks: (c.hooks ?? []).map((h) => h.id),
+            agentRoles: (c.agentRoles ?? []).map((r) => r.id),
+            repoSources: (c.repoSources ?? []).map((r) => r.id),
+            taskSources: (c.taskSources ?? []).map((s) => s.id),
+            skills: (c.skills ?? []).map((s) => s.id),
+            taskFieldExtensions: (c.taskFieldSchemas ?? []).map((f) => f.id),
+            cliCommands: (c.cliCommands ?? []).map((c2) => c2.id)
+          });
+        }
+      }
+      if (context.outputMode === "text") {
+        if (legacyPlugins.length === 0 && declarative.length === 0) {
+          console.log("No plugins loaded.");
+        }
+        if (declarative.length > 0) {
+          console.log("Declarative plugins (rig.config.ts):");
+          for (const p of declarative) {
+            console.log(`  ${p.name}@${p.version}`);
+            const lines = [];
+            if (p.validators.length)
+              lines.push(`    validators: ${p.validators.join(", ")}`);
+            if (p.hooks.length)
+              lines.push(`    hooks: ${p.hooks.join(", ")}`);
+            if (p.agentRoles.length)
+              lines.push(`    agent-roles: ${p.agentRoles.join(", ")}`);
+            if (p.repoSources.length)
+              lines.push(`    repo-sources: ${p.repoSources.join(", ")}`);
+            if (p.taskSources.length)
+              lines.push(`    task-sources: ${p.taskSources.join(", ")}`);
+            if (p.skills.length)
+              lines.push(`    skills: ${p.skills.join(", ")}`);
+            if (p.taskFieldExtensions.length)
+              lines.push(`    task-fields: ${p.taskFieldExtensions.join(", ")}`);
+            if (p.cliCommands.length)
+              lines.push(`    cli-commands: ${p.cliCommands.join(", ")}`);
+            for (const line of lines)
+              console.log(line);
+          }
+        }
+        if (legacyPlugins.length > 0) {
+          console.log("Legacy disk-scan plugins (rig/plugins/):");
+          for (const plugin of legacyPlugins) {
+            const validators = plugin.validators.length > 0 ? plugin.validators.join(", ") : "none";
+            console.log(`  ${plugin.name} (validators: ${validators})`);
+          }
+        }
+      }
+      return {
+        ok: true,
+        group: "plugin",
+        command,
+        details: { declarative, legacy: legacyPlugins }
+      };
+    }
+    case "validate": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig plugin validate --task <beads-id>");
+      const taskId = requireTask(task, "bun run rig plugin validate --task <beads-id>");
+      const results = await context.plugins.runValidators(taskId);
+      const passed = results.filter((result) => result.passed).length;
+      const failed = results.length - passed;
+      if (context.outputMode === "text") {
+        if (results.length === 0) {
+          console.log("No plugin validators registered.");
+        } else {
+          for (const result of results) {
+            const icon = result.passed ? "PASS" : "FAIL";
+            console.log(`[${icon}] ${result.id}: ${result.summary}`);
+            if (result.details && !result.passed) {
+              console.log(result.details);
+            }
+          }
+        }
+      }
+      if (failed > 0) {
+        throw new CliError2(`Plugin validation failed for ${failed} validator(s).`, 2);
+      }
+      return {
+        ok: true,
+        group: "plugin",
+        command,
+        details: {
+          taskId,
+          passed,
+          failed,
+          results
+        }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown plugin command: ${command}`);
+  }
+}
+export {
+  executePlugin
+};