@h-rig/cli-surface-plugin 0.0.6-alpha.146

package/dist/src/commands/stats.js

@@ -0,0 +1,219 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/stats.ts
+import { computeStats } from "@rig/client";
+
+// packages/cli-surface-plugin/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+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}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
+      }
+      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-surface-plugin/src/commands/_cli-format.ts
+import pc from "picocolors";
+import { runStatusColorRole, runStatusText, statusColorRole } from "@rig/client";
+var dim = pc.dim;
+var faintBar = pc.dim("\u2502");
+var accent = pc.cyan;
+function compactValue(value) {
+  if (value === null || value === undefined)
+    return "\u2014";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value);
+}
+function printFormattedOutput(message) {
+  console.log(message);
+}
+function formatStatsTable(rows) {
+  return rows.map(([label, value]) => `${faintBar} ${dim(label.padEnd(20))} ${compactValue(value)}`).join(`
+`);
+}
+
+// packages/cli-surface-plugin/src/commands/_help-catalog.ts
+import pc2 from "picocolors";
+import {
+  ADVANCED_COMMANDS,
+  ADVANCED_GROUPS,
+  ALL_GROUPS,
+  helpCatalog,
+  TOP_LEVEL_SECTIONS
+} from "@rig/contracts";
+function heading(title) {
+  return pc2.bold(pc2.cyan(title));
+}
+function commandLine(command, description) {
+  const commandColumn = command.length >= 38 ? `${command}  ` : command.padEnd(38);
+  return `${pc2.dim("\u2502")} ${pc2.bold(commandColumn)} ${description}`;
+}
+function renderCommandBlock(commands) {
+  const indent = `${pc2.dim("\u2502")} ${" ".repeat(38)} `;
+  return commands.map((entry) => {
+    const lines = [commandLine(entry.command, entry.description)];
+    if (entry.usecase) {
+      lines.push(`${indent}${pc2.dim("when:")} ${pc2.dim(entry.usecase)}`);
+    }
+    for (const example of entry.examples ?? []) {
+      lines.push(`${indent}${pc2.dim("$")} ${pc2.cyan(example)}`);
+    }
+    return lines.join(`
+`);
+  }).join(`
+`);
+}
+function renderGroup(group) {
+  const lines = [
+    `${heading(`rig ${group.name}`)} \u2014 ${group.summary}`,
+    "",
+    pc2.bold("Usage"),
+    ...group.usage.map((line) => `  ${line}`),
+    "",
+    pc2.bold("Commands"),
+    ...group.commands.map((entry) => commandLine(entry.command, entry.description))
+  ];
+  if (group.examples?.length) {
+    lines.push("", pc2.bold("Examples"), ...group.examples.map((line) => `  ${pc2.dim("$")} ${line}`));
+  }
+  if (group.next?.length) {
+    lines.push("", pc2.bold("Next steps"), ...group.next.map((line) => `  ${pc2.dim("\u203A")} ${line}`));
+  }
+  if (group.advanced?.length) {
+    lines.push("", pc2.bold("Compatibility / advanced"), ...group.advanced.map((line) => `  ${pc2.dim("\u203A")} ${line}`));
+  }
+  return lines.join(`
+`);
+}
+function renderTopLevelHelp() {
+  return [
+    `${heading("rig")} ${pc2.dim("\u2014 Rig Cockpit for autonomous coding agents")}`,
+    pc2.dim("The loop: bare `rig` \u2192 Cockpit \u2192 Server target \u2192 Tasks \u2192 Task detail \u2192 Dispatch/Attach; every run uses OMP collaboration as the session substrate."),
+    "",
+    ...TOP_LEVEL_SECTIONS.flatMap((section) => [
+      `${pc2.bold(pc2.magenta(`\u25C7 ${section.title}`))} \u2014 ${pc2.dim(section.subtitle)}`,
+      renderCommandBlock(section.commands),
+      ""
+    ]),
+    pc2.dim("More: `rig help --advanced` for fenced legacy/diagnostic commands; `rig <group> --help` for per-group compatibility help; `rig --version` for the installed version."),
+    "",
+    pc2.bold("Root options"),
+    commandLine("--workspace <path>", "Open Rig Cockpit for a workspace instead of the current directory."),
+    commandLine("--json", "Compatibility flag for fenced legacy/diagnostic subcommands."),
+    commandLine("--dry-run", "Compatibility flag for fenced legacy/diagnostic subcommands.")
+  ].join(`
+`).trimEnd();
+}
+function renderGroupHelp(groupName) {
+  const group = ALL_GROUPS.find((candidate) => candidate.name === groupName);
+  return group ? renderGroup(group) : null;
+}
+function printGroupHelpDocument(groupName) {
+  console.log(renderGroupHelp(groupName) ?? renderTopLevelHelp());
+}
+
+// packages/cli-surface-plugin/src/commands/stats.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+function parseSinceOption(value, now = new Date) {
+  if (!value?.trim())
+    return null;
+  const trimmed = value.trim();
+  const relative = trimmed.match(/^(\d+)d$/i);
+  if (relative?.[1]) {
+    const days = Number.parseInt(relative[1], 10);
+    if (!Number.isFinite(days) || days <= 0)
+      throw new CliError(`Invalid --since value: ${value}`, 2, { hint: "Use an ISO date or a relative window like `7d`." });
+    return new Date(now.getTime() - days * DAY_MS);
+  }
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed))
+    throw new CliError(`Invalid --since value: ${value}`, 2, { hint: "Use an ISO date or a relative window like `7d`." });
+  return new Date(parsed);
+}
+function formatPercent(value) {
+  return value === null ? "\u2014" : `${Math.round(value * 100)}%`;
+}
+function formatDuration(ms) {
+  if (ms === null)
+    return "\u2014";
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.round(ms / 60000);
+  if (minutes < 60)
+    return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder === 0 ? `${hours}h` : `${hours}h ${remainder}m`;
+}
+function formatStatsRows(stats) {
+  return [
+    ["window", stats.since ? `since ${stats.since}` : "all runs"],
+    ["total runs", stats.totalRuns],
+    ["completed", `${stats.completedRuns} (${formatPercent(stats.completionRate)})`],
+    ["failed", `${stats.failedRuns} (${formatPercent(stats.failureRate)})`],
+    ["needs attention", `${stats.needsAttentionRuns} (${formatPercent(stats.needsAttentionRate)})`],
+    ["median run time", formatDuration(stats.medianCompletionMs)],
+    ["steering", stats.steeringTotal],
+    ["stalls", stats.stallTotal],
+    ["pending approvals", stats.approvalsPending]
+  ];
+}
+async function executeStats(context, args, deps = {}) {
+  const [first = "show", ...rest] = args;
+  const command = first.startsWith("-") ? "show" : first;
+  const commandArgs = first.startsWith("-") ? args : rest;
+  if (command === "help") {
+    printGroupHelpDocument("stats");
+    return { ok: true, group: "stats", command };
+  }
+  if (command !== "show")
+    throw new CliError(`Unknown stats command: ${command}`, 1, { hint: "Run `rig stats --help` \u2014 the default command is `show`." });
+  const sinceResult = takeOption(commandArgs, "--since");
+  requireNoExtraArgs(sinceResult.rest, "rig stats [show] [--since <7d|30d|ISO date>]");
+  const statsOptions = deps.listRuns ? { since: parseSinceOption(sinceResult.value), listRuns: deps.listRuns } : { since: parseSinceOption(sinceResult.value) };
+  const details = await computeStats(context.projectRoot, statsOptions);
+  if (context.outputMode === "text")
+    printFormattedOutput(formatStatsTable(formatStatsRows(details)));
+  return { ok: true, group: "stats", command, details };
+}
+export {
+  parseSinceOption,
+  formatStatsRows,
+  executeStats
+};

package/dist/src/commands/task-run-driver.d.ts

@@ -0,0 +1,93 @@
+export type TaskRunReviewState = Record<string, unknown>;
+export type TaskRunStageName = "Connect" | "Prepare" | "Execute" | "Validate" | "Review" | "Publish" | "Complete" | "Needs attention" | "Failed";
+export type SubmitTaskRunInput = {
+    runId: string;
+    taskId?: string;
+    title?: string;
+    runtimeAdapter: "pi";
+    model?: string;
+    runtimeMode: string;
+    interactionMode: string;
+    initialPrompt?: string;
+    baselineMode?: "head" | "dirty-snapshot";
+    prMode?: "auto" | "ask" | "off";
+};
+type TaskRunAutomationConfig = {
+    review?: {
+        mode?: string;
+        provider?: string;
+    };
+    automation?: {
+        maxValidationAttempts?: number;
+        maxPrFixIterations?: number;
+    };
+};
+export declare function canonicalPiRunStages(): string[];
+export declare function buildPiRigBridgeEnv(input: {
+    projectRoot: string;
+    runId: string;
+    taskId?: string | null;
+    runtimeMode?: string | null;
+    model?: string | null;
+}): Record<string, string>;
+export declare function applyDirtyBaselineSnapshot(input: {
+    sourceRoot: string;
+    targetRoot: string;
+}): {
+    applied: boolean;
+    copiedUntracked: number;
+    detail: string;
+};
+export declare function buildTaskRunReviewEnv(config?: TaskRunAutomationConfig | null): Record<string, string>;
+export declare function buildDirtyBaselineHandshakeEnv(input: {
+    projectRoot: string;
+    runId: string;
+    baselineMode: "head" | "dirty-snapshot";
+}): Record<string, string>;
+export declare function resolveTaskRunAutomationLimits(config?: TaskRunAutomationConfig | null, env?: Record<string, string | undefined>): {
+    maxValidationAttempts: number;
+    maxPrFixIterations: number;
+};
+export type PlanningClassification = {
+    needsPlanning: boolean;
+    reason: string;
+};
+export declare function classifyPlanningNeed(input: {
+    prompt: string;
+    acceptanceCriteria?: string | null;
+}): PlanningClassification;
+export declare function buildPiValidationRetrySteeringPrompt(input: {
+    taskId?: string | null;
+    attempt: number;
+    failureDetail: string;
+}): string;
+export declare function classifyValidationRetryOutcome(input: {
+    attempt: number;
+    maxAttempts: number;
+    failureDetail: string;
+}): {
+    stage: "Validate failed";
+    status: "retry" | "needs_attention";
+    failureDetail: string;
+};
+export declare function taskRunStageLogId(runId: string, stage: TaskRunStageName): string;
+export declare function createRunLogIdFactory(runId: string): () => string;
+export declare function summarizeTaskRunProcessFailure(input: {
+    stage: string;
+    exitCode?: number | null;
+    stderr?: string | null;
+    stdout?: string | null;
+    fallback?: string | null;
+}): string;
+export declare function classifyCompletionVerificationLine(line: string): {
+    isCompletionLine: boolean;
+    stage: string | null;
+    status: "started" | "passed" | "failed" | null;
+};
+export declare function readTaskRunAcceptedArtifactState(input: {
+    artifactPath: string;
+}): {
+    accepted: boolean;
+    reason: string | null;
+};
+export {};

package/dist/src/commands/task-run-driver.js

@@ -0,0 +1,136 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/task-run-driver.ts
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "fs";
+import { resolve } from "path";
+var PI_CANONICAL_RUN_STAGES = ["Connect", "Prepare", "Execute", "Validate", "Review", "Publish", "Complete"];
+function canonicalPiRunStages() {
+  return [...PI_CANONICAL_RUN_STAGES];
+}
+function buildPiRigBridgeEnv(input) {
+  return {
+    PROJECT_RIG_ROOT: input.projectRoot,
+    RIG_RUN_ID: input.runId,
+    ...input.taskId ? { RIG_TASK_ID: input.taskId } : {},
+    ...input.runtimeMode ? { RIG_RUNTIME_MODE: input.runtimeMode } : {},
+    ...input.model ? { RIG_MODEL: input.model } : {}
+  };
+}
+function copyTree(sourceRoot, targetRoot) {
+  if (!existsSync(sourceRoot))
+    return 0;
+  let copied = 0;
+  for (const entry of readdirSync(sourceRoot, { withFileTypes: true })) {
+    const sourcePath = resolve(sourceRoot, entry.name);
+    const targetPath = resolve(targetRoot, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(targetPath, { recursive: true });
+      copied += copyTree(sourcePath, targetPath);
+      continue;
+    }
+    mkdirSync(resolve(targetPath, ".."), { recursive: true });
+    copyFileSync(sourcePath, targetPath);
+    copied += 1;
+  }
+  return copied;
+}
+function applyDirtyBaselineSnapshot(input) {
+  mkdirSync(input.targetRoot, { recursive: true });
+  const copied = copyTree(input.sourceRoot, input.targetRoot);
+  return {
+    applied: copied > 0,
+    copiedUntracked: copied,
+    detail: copied > 0 ? `Copied ${copied} file(s) into the runtime workspace.` : "No files copied."
+  };
+}
+function buildTaskRunReviewEnv(config) {
+  return {
+    ...config?.review?.mode ? { AI_REVIEW_MODE: config.review.mode } : {},
+    ...config?.review?.provider ? { AI_REVIEW_PROVIDER: config.review.provider } : {}
+  };
+}
+function buildDirtyBaselineHandshakeEnv(input) {
+  return {
+    RIG_DIRTY_BASELINE_MODE: input.baselineMode,
+    RIG_DIRTY_BASELINE_READY_FILE: resolve(input.projectRoot, ".rig", "state", `${input.runId}.dirty-ready`)
+  };
+}
+function resolveTaskRunAutomationLimits(config, env = process.env) {
+  const maxValidationAttempts = Number.parseInt(env.RIG_MAX_VALIDATION_ATTEMPTS ?? "", 10);
+  const maxPrFixIterations = Number.parseInt(env.RIG_MAX_PR_FIX_ITERATIONS ?? "", 10);
+  return {
+    maxValidationAttempts: Number.isFinite(maxValidationAttempts) && maxValidationAttempts > 0 ? maxValidationAttempts : config?.automation?.maxValidationAttempts ?? 30,
+    maxPrFixIterations: Number.isFinite(maxPrFixIterations) && maxPrFixIterations > 0 ? maxPrFixIterations : config?.automation?.maxPrFixIterations ?? 100500
+  };
+}
+function classifyPlanningNeed(input) {
+  const text = `${input.prompt}
+${input.acceptanceCriteria ?? ""}`.toLowerCase();
+  const needsPlanning = /plan|design|approach|architecture|multi-step/.test(text);
+  return { needsPlanning, reason: needsPlanning ? "operator requested a planning pass" : "no planning trigger detected" };
+}
+function buildPiValidationRetrySteeringPrompt(input) {
+  return [
+    `Validation failed on attempt ${input.attempt}${input.taskId ? ` for task ${input.taskId}` : ""}.`,
+    input.failureDetail.trim(),
+    "Fix the issue, rerun validation, and continue only after it passes."
+  ].join(`
+
+`);
+}
+function classifyValidationRetryOutcome(input) {
+  return {
+    stage: "Validate failed",
+    status: input.attempt < input.maxAttempts ? "retry" : "needs_attention",
+    failureDetail: input.failureDetail
+  };
+}
+function taskRunStageLogId(runId, stage) {
+  return `log:${runId}:stage:${stage.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+}
+function createRunLogIdFactory(runId) {
+  let next = 0;
+  return () => `${runId}:log:${++next}`;
+}
+function summarizeTaskRunProcessFailure(input) {
+  const detail = [input.stderr?.trim(), input.stdout?.trim()].filter(Boolean)[0];
+  return `${input.stage} failed${input.exitCode !== null && input.exitCode !== undefined ? ` (exit ${input.exitCode})` : ""}${detail ? `: ${detail}` : input.fallback ? `: ${input.fallback}` : ""}`;
+}
+function classifyCompletionVerificationLine(line) {
+  if (line.startsWith("=== Completion Verification:")) {
+    return { isCompletionLine: true, stage: line.replace(/^=== Completion Verification:\s*/, "").replace(/\s*=+$/, "").trim(), status: "started" };
+  }
+  if (/^PASS\b/.test(line))
+    return { isCompletionLine: true, stage: null, status: "passed" };
+  if (/^FAIL\b/.test(line))
+    return { isCompletionLine: true, stage: null, status: "failed" };
+  return { isCompletionLine: false, stage: null, status: null };
+}
+function readTaskRunAcceptedArtifactState(input) {
+  if (!existsSync(input.artifactPath))
+    return { accepted: false, reason: null };
+  try {
+    const parsed = JSON.parse(readFileSync(input.artifactPath, "utf8"));
+    return {
+      accepted: parsed.accepted === true,
+      reason: typeof parsed.reason === "string" ? parsed.reason : null
+    };
+  } catch {
+    return { accepted: false, reason: null };
+  }
+}
+export {
+  taskRunStageLogId,
+  summarizeTaskRunProcessFailure,
+  resolveTaskRunAutomationLimits,
+  readTaskRunAcceptedArtifactState,
+  createRunLogIdFactory,
+  classifyValidationRetryOutcome,
+  classifyPlanningNeed,
+  classifyCompletionVerificationLine,
+  canonicalPiRunStages,
+  buildTaskRunReviewEnv,
+  buildPiValidationRetrySteeringPrompt,
+  buildPiRigBridgeEnv,
+  buildDirtyBaselineHandshakeEnv,
+  applyDirtyBaselineSnapshot
+};

package/dist/src/commands/task.d.ts

@@ -0,0 +1,46 @@
+import type { RegisteredTaskSource } from "@rig/contracts";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+import type { TaskLike } from "@rig/client";
+import { type RunnerContext } from "../runner";
+export type { TaskLike } from "@rig/client";
+type TaskDispatch = (input: {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+}) => Promise<{
+    readonly runId: string;
+}>;
+export type TaskCommandDeps = {
+    readonly listTasks?: (projectRoot: string) => Promise<readonly TaskLike[]>;
+    readonly getTask?: (projectRoot: string, taskId: string) => Promise<TaskLike | null>;
+    readonly dispatch?: TaskDispatch;
+    readonly spawnRun?: TaskDispatch;
+    readonly taskReady?: (projectRoot: string) => Promise<void> | void;
+    readonly taskValidate?: (projectRoot: string, taskId?: string) => Promise<boolean> | boolean;
+    readonly taskVerify?: (projectRoot: string, taskId?: string) => Promise<boolean> | boolean;
+    readonly taskReopen?: (projectRoot: string, options: {
+        all: boolean;
+        taskId?: string;
+        dryRun?: boolean;
+    }) => Promise<{
+        reopened?: readonly string[];
+        kept?: readonly string[];
+        [key: string]: unknown;
+    }>;
+    readonly taskArtifacts?: (projectRoot: string, taskId?: string) => void;
+    readonly taskArtifactDir?: (projectRoot: string, taskId?: string) => string;
+    readonly taskArtifactWrite?: (projectRoot: string, filename: string, content: string, taskId?: string) => void;
+    readonly taskInfo?: (projectRoot: string, taskId?: string) => void;
+    readonly taskScope?: (projectRoot: string, includeFiles: boolean, taskId?: string) => void;
+    readonly taskDeps?: (projectRoot: string, taskId?: string) => void;
+    readonly taskStatus?: (projectRoot: string) => void;
+    readonly taskLookup?: (projectRoot: string, taskId: string) => string;
+    readonly taskRecord?: (projectRoot: string, type: string, text: string, taskId?: string) => void;
+    readonly loadTaskSource?: (projectRoot: string) => Promise<{
+        readonly kind: string;
+        readonly source: RegisteredTaskSource;
+    }>;
+};
+export declare function executeTask(context: RunnerContext, args: string[], deps?: TaskCommandDeps): Promise<CommandOutcome>;