@h-rig/run-plugin 0.0.6-alpha.186

package/dist/src/read-model/inspect-command.d.ts

@@ -0,0 +1,19 @@
+import type { CommandOutcome, RunReadModelDetails, RunRecord, TaskArtifactReadResult } from "@rig/contracts";
+import type { RuntimeCliContext } from "@rig/core/config";
+type MaybePromise<T> = T | Promise<T>;
+type InspectCommandDeps = {
+    getRunProjection?: (projectRoot: string, taskId: string) => Promise<RunRecord | null>;
+    listRunProjections?: (projectRoot: string) => Promise<readonly RunRecord[]>;
+    getRunDetails?: (projectRoot: string, runId: string, options?: {
+        includeLogs?: boolean;
+    }) => Promise<RunReadModelDetails | null>;
+    taskArtifactRead?: (projectRoot: string, filename: string, options?: {
+        taskId?: string;
+        maxBytes?: number;
+    }) => MaybePromise<TaskArtifactReadResult>;
+    taskArtifacts?: (projectRoot: string, taskId?: string) => MaybePromise<void>;
+    taskDeps?: (projectRoot: string, taskId?: string) => MaybePromise<void>;
+    changedFilesForTask?: (projectRoot: string, taskId: string, scoped: boolean) => string[];
+};
+export declare function executeInspect(context: RuntimeCliContext, args: string[], deps?: InspectCommandDeps): Promise<CommandOutcome>;
+export {};

package/dist/src/read-model/inspect-command.js

@@ -0,0 +1,341 @@
+// @bun
+// packages/run-plugin/src/read-model/inspect-command.ts
+import { RUN_READ_MODEL, TASK_CLI_DATA_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { requireCapabilityForRoot } from "@rig/core/capability-loaders";
+import { CliError, requireNoExtraArgs, requireOption, takeOption } from "@rig/std-shared/cli-args";
+import { printFormattedOutput } from "@rig/std-shared/cli-format";
+
+// packages/run-plugin/src/read-model/run-format.ts
+import pc from "picocolors";
+import { formatSection, formatSuccessCard, formatNextSteps } from "@rig/std-shared/cli-format";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+var STATUS_ROLES = new Set([
+  "success",
+  "action-yellow",
+  "active-cyan",
+  "failure",
+  "muted",
+  "neutral"
+]);
+function projectedStatusRole(value) {
+  return typeof value === "string" && STATUS_ROLES.has(value) ? value : null;
+}
+function truncate(value, width) {
+  return value.length <= width ? value : `${value.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function colorForRole(role) {
+  switch (role) {
+    case "success":
+      return pc.green;
+    case "action-yellow":
+      return pc.yellow;
+    case "active-cyan":
+      return pc.cyan;
+    case "failure":
+      return pc.red;
+    case "muted":
+    case "neutral":
+      return pc.dim;
+  }
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function runLikeStatusText(run) {
+  const record = run;
+  const status = typeof record.status === "string" ? record.status.trim() : "";
+  return status || "unclassified";
+}
+function runLikeStatusColor(run) {
+  const record = run;
+  return colorForRole(projectedStatusRole(record.statusRole) ?? "neutral");
+}
+function formatLegacyAutomationSurface() {
+  return [];
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? dim("No runs recorded on the selected server.") : dim("No runs recorded in local state."),
+      "",
+      ...formatLegacyAutomationSurface()
+    ].join(`
+`);
+  }
+  const body = runs.map((run) => {
+    const row = run;
+    const runId = runIdOf(row);
+    const status = runLikeStatusText(run);
+    const runtime = firstString(row, ["runtime", "runtimeAdapter"], "");
+    return [
+      pc.bold(runId),
+      runLikeStatusColor(run)(pad(truncate(status, 12), 12)),
+      `${runTitleOf(row)}${runtime ? dim(`  ${runtime}`) : ""}`
+    ].join("  ");
+  });
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), ...body, "", ...formatLegacyAutomationSurface()].join(`
+`);
+}
+
+// packages/run-plugin/src/read-model/inspect-command.ts
+var RunReadModelCap = defineCapability(RUN_READ_MODEL);
+var TaskCliDataCap = defineCapability(TASK_CLI_DATA_CAPABILITY);
+var taskCliData = (projectRoot) => requireCapabilityForRoot(projectRoot, TaskCliDataCap, "CLI task-data capability unavailable: load @rig/tasks-plugin (default bundle).");
+var INSPECT_USAGE = "rig inspect <logs|artifact|artifacts|run-logs|runs|failures|graph|diff>";
+function inspectHelpText() {
+  return [
+    `Usage: ${INSPECT_USAGE}`,
+    "",
+    "Commands:",
+    "  logs --task <id>              Print log lines from a projected run for a task.",
+    "  artifact --task <id> --file <name>",
+    "                                Preview a single task artifact.",
+    "  artifacts --task <id>         List task artifacts.",
+    "  run-logs --run <id>           Print log lines from a run journal.",
+    "  runs                          List projected runs.",
+    "  diff --task <id>              List files changed by a task.",
+    "  graph [--task <id>]           Print the task dependency graph.",
+    "  failures --task <id>          Print run read-model failure summaries for a task."
+  ].join(`
+`);
+}
+function printInspectHelp() {
+  printFormattedOutput(inspectHelpText());
+}
+function toRunLike(run, classification) {
+  return {
+    runId: run.runId,
+    taskId: run.taskId,
+    title: run.title,
+    status: classification?.status ?? run.status,
+    runStatus: classification?.runStatus,
+    statusPhase: classification?.phase,
+    statusRole: classification?.role,
+    statusRank: classification?.rank,
+    isActive: classification?.isActive,
+    isTerminal: classification?.isTerminal,
+    isNeedsAttention: classification?.isNeedsAttention,
+    source: run.source,
+    live: run.live,
+    stale: run.stale,
+    startedAt: run.startedAt,
+    updatedAt: run.updatedAt,
+    completedAt: run.completedAt,
+    joinLink: run.joinLink,
+    prUrl: run.prUrl,
+    pendingApprovals: run.pendingApprovals,
+    pendingInputs: run.pendingInputs,
+    steeringCount: run.steeringCount,
+    stallCount: run.stallCount
+  };
+}
+function requireRunId(value, usage) {
+  if (!value || !value.trim())
+    throw new CliError(`${usage} requires a run id.`, 2, { hint: "Run `rig inspect runs` to find run ids." });
+  return value.trim();
+}
+async function loadRunReadModel(projectRoot) {
+  return requireCapabilityForRoot(projectRoot, RunReadModelCap, "RUN_READ_MODEL capability unavailable for this project root: load @rig/run-plugin (standard bundle).");
+}
+async function listRunRecords(projectRoot, deps) {
+  return deps.listRunProjections ? deps.listRunProjections(projectRoot) : (await loadRunReadModel(projectRoot)).listRuns({ projectRoot });
+}
+async function getRunRecord(projectRoot, runId, deps) {
+  return deps.getRunProjection ? deps.getRunProjection(projectRoot, runId) : (await loadRunReadModel(projectRoot)).getRun({ projectRoot, selector: { id: runId, kind: "any" } });
+}
+async function getRunDetails(projectRoot, runId, deps, options = {}) {
+  return deps.getRunDetails ? deps.getRunDetails(projectRoot, runId, options) : (await loadRunReadModel(projectRoot)).getRunDetails({ projectRoot, selector: { id: runId, kind: "any" }, ...options.includeLogs === undefined ? {} : { includeLogs: options.includeLogs } });
+}
+async function runsForTaskId(projectRoot, taskId, deps) {
+  try {
+    if (!deps.listRunProjections) {
+      const runs = await (await loadRunReadModel(projectRoot)).listRuns({ projectRoot, taskId });
+      if (runs.length > 0)
+        return runs;
+    } else {
+      const runs = await listRunRecords(projectRoot, deps);
+      const filtered = runs.filter((run2) => run2.taskId === taskId || run2.runId === taskId);
+      if (filtered.length > 0)
+        return filtered;
+    }
+  } catch {}
+  const run = await getRunRecord(projectRoot, taskId, deps);
+  return run ? [run] : [];
+}
+async function representativeRunForTaskId(projectRoot, taskId, deps) {
+  if (deps.listRunProjections) {
+    const runs = await runsForTaskId(projectRoot, taskId, deps);
+    for (const run of runs)
+      return run;
+    return null;
+  }
+  return (await loadRunReadModel(projectRoot)).getRepresentativeRun({ projectRoot, taskId, purpose: "inspect" });
+}
+function failureLine(failure) {
+  return failure.detail ? `${failure.summary} \u2014 ${failure.detail}` : failure.summary;
+}
+async function executeLogs(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  requireNoExtraArgs(taskResult.rest, "rig inspect logs --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect logs --task <id>");
+  const projection = await representativeRunForTaskId(context.projectRoot, taskId, deps);
+  if (!projection)
+    throw new CliError(`No projected runs found for task ${taskId}.`, 1, { hint: "Run `rig run list` to confirm the run journal is discoverable." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for task ${taskId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "logs", details: { taskId, runId: projection.runId, count: lines.length, lines } };
+}
+async function executeArtifact(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  const fileResult = takeOption(taskResult.rest, "--file");
+  requireNoExtraArgs(fileResult.rest, "rig inspect artifact --task <id> --file <name>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifact --task <id> --file <name>");
+  const filename = fileResult.value?.trim();
+  if (!filename)
+    throw new CliError("rig inspect artifact --task <id> --file <name> requires an artifact file name.", 2);
+  const preview = await (deps.taskArtifactRead ?? (await taskCliData(context.projectRoot)).taskArtifactRead)(context.projectRoot, filename, { taskId, maxBytes: 64 * 1024 });
+  if (context.outputMode === "text") {
+    console.log(preview.contents);
+    if (preview.truncated)
+      console.log(`
+[truncated at ${preview.maxBytes} bytes; artifact is ${preview.sizeBytes} bytes]`);
+  }
+  return { ok: true, group: "inspect", command: "artifact", details: { taskId, file: filename, ...preview } };
+}
+async function executeRunLogs(context, args, deps) {
+  const runResult = takeOption(args, "--run");
+  requireNoExtraArgs(runResult.rest, "rig inspect run-logs --run <id>");
+  const runId = requireRunId(runResult.value, "rig inspect run-logs --run <id>");
+  const projection = await getRunRecord(context.projectRoot, runId, deps);
+  if (!projection)
+    throw new CliError(`Run not found: ${runId}`, 2, { hint: "Run `rig inspect runs` to see runs." });
+  const details = await getRunDetails(context.projectRoot, projection.runId, deps, { includeLogs: true });
+  const lines = [...details?.logs ?? []];
+  if (context.outputMode === "text") {
+    if (lines.length === 0)
+      console.log(`No log entries found for run ${projection.runId}.`);
+    else
+      for (const line of lines)
+        console.log(line);
+  }
+  return { ok: true, group: "inspect", command: "run-logs", details: { runId: projection.runId, taskId: projection.taskId, count: lines.length, lines } };
+}
+async function executeRuns(context, args, deps) {
+  requireNoExtraArgs(args, "rig inspect runs");
+  let formatted;
+  if (deps.listRunProjections) {
+    formatted = (await listRunRecords(context.projectRoot, deps)).map((run) => toRunLike(run));
+  } else {
+    const readModel = await loadRunReadModel(context.projectRoot);
+    const runs = await readModel.listRuns({ projectRoot: context.projectRoot });
+    formatted = runs.map((run) => toRunLike(run, readModel.classifyRun(run)));
+  }
+  if (context.outputMode === "text")
+    printFormattedOutput(formatRunList(formatted));
+  return { ok: true, group: "inspect", command: "runs", details: { runs: formatted } };
+}
+async function executeArtifacts(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  requireNoExtraArgs(taskResult.rest, "rig inspect artifacts --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect artifacts --task <id>");
+  if (context.outputMode === "text")
+    await (deps.taskArtifacts ?? (await taskCliData(context.projectRoot)).taskArtifacts)(context.projectRoot, taskId);
+  return { ok: true, group: "inspect", command: "artifacts", details: { taskId, printed: context.outputMode === "text" } };
+}
+async function executeDiff(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  requireNoExtraArgs(taskResult.rest, "rig inspect diff --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect diff --task <id>");
+  const files = (deps.changedFilesForTask ?? (await taskCliData(context.projectRoot)).changedFilesForTask)(context.projectRoot, taskId, true);
+  if (context.outputMode === "text")
+    for (const file of files)
+      console.log(file);
+  return { ok: true, group: "inspect", command: "diff", details: { taskId, files } };
+}
+async function executeGraph(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  requireNoExtraArgs(taskResult.rest, "rig inspect graph [--task <id>]");
+  if (context.outputMode === "text")
+    await (deps.taskDeps ?? (await taskCliData(context.projectRoot)).taskDeps)(context.projectRoot, taskResult.value);
+  return { ok: true, group: "inspect", command: "graph", details: { taskId: taskResult.value ?? null, printed: context.outputMode === "text" } };
+}
+async function executeFailures(context, args, deps) {
+  const taskResult = takeOption(args, "--task");
+  requireNoExtraArgs(taskResult.rest, "rig inspect failures --task <id>");
+  const taskId = requireOption(taskResult.value, "--task", "rig inspect failures --task <id>");
+  const runs = await runsForTaskId(context.projectRoot, taskId, deps);
+  const failures = (await Promise.all(runs.map(async (run) => (await getRunDetails(context.projectRoot, run.runId, deps))?.failures ?? []))).flat().map(failureLine);
+  if (context.outputMode === "text") {
+    if (failures.length === 0)
+      console.log(`No failures recorded for task ${taskId}.`);
+    else
+      for (const failure of failures)
+        console.log(failure);
+  }
+  return { ok: true, group: "inspect", command: "failures", details: { taskId, count: failures.length, failures } };
+}
+function executeAudit(args) {
+  requireNoExtraArgs(args, "rig inspect audit");
+  throw new CliError("rig inspect audit cannot read the controlled-command audit trail yet: current code only writes audit JSONL and exposes no supported reader API.", 2, { hint: "Use the OMP session history for operator audit context until a controlled-bash audit reader is added." });
+}
+async function executeInspect(context, args, deps = {}) {
+  const [command = "failures", ...rest] = args;
+  if (command === "--help" || command === "-h" || command === "help") {
+    if (context.outputMode === "text")
+      printInspectHelp();
+    return { ok: true, group: "inspect", command: "help" };
+  }
+  switch (command) {
+    case "logs":
+      return executeLogs(context, rest, deps);
+    case "artifact":
+      return executeArtifact(context, rest, deps);
+    case "artifacts":
+      return executeArtifacts(context, rest, deps);
+    case "run-logs":
+      return executeRunLogs(context, rest, deps);
+    case "runs":
+      return executeRuns(context, rest, deps);
+    case "diff":
+      return executeDiff(context, rest, deps);
+    case "graph":
+      return executeGraph(context, rest, deps);
+    case "failures":
+      return executeFailures(context, rest, deps);
+    case "audit":
+      return executeAudit(rest);
+    default:
+      throw new CliError(`Unknown inspect command: ${command}`, 1, { hint: "Run `rig inspect --help` to list inspect commands." });
+  }
+}
+export {
+  executeInspect
+};

package/dist/src/read-model/plugin.d.ts

@@ -0,0 +1,4 @@
+import { type RigPlugin } from "@rig/core/config";
+export declare const RUN_READ_MODEL_PLUGIN_NAME = "@rig/run-plugin";
+export declare const runReadModelPlugin: RigPlugin;
+export declare function createRunReadModelPlugin(): RigPlugin;