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

package/dist/src/commands/triage.js

@@ -0,0 +1,224 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/triage.ts
+import { runIssueAnalysisTriage } from "@rig/runtime/control-plane/github";
+
+// 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/_async-ui.ts
+import pc from "picocolors";
+
+// packages/cli-surface-plugin/src/commands/_spinner.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createTtySpinner(input) {
+  const output = input.output ?? process.stdout;
+  const isTty = output.isTTY === true;
+  const frames = input.frames && input.frames.length > 0 ? input.frames : SPINNER_FRAMES;
+  let label = input.label;
+  let frame = 0;
+  let paused = false;
+  let stopped = false;
+  let lastPrintedLabel = "";
+  const render = () => {
+    if (stopped || paused)
+      return;
+    if (!isTty) {
+      if (label !== lastPrintedLabel) {
+        output.write(`${label}
+`);
+        lastPrintedLabel = label;
+      }
+      return;
+    }
+    frame = (frame + 1) % frames.length;
+    const glyph = frames[frame] ?? frames[0] ?? "";
+    output.write(`\r\x1B[2K${input.styleFrame ? input.styleFrame(glyph) : glyph} ${label}`);
+  };
+  const clearLine = () => {
+    if (isTty)
+      output.write("\r\x1B[2K");
+  };
+  render();
+  const timer = isTty ? setInterval(render, input.intervalMs ?? 16) : null;
+  return {
+    setLabel(next) {
+      label = next;
+      render();
+    },
+    pause() {
+      paused = true;
+      clearLine();
+    },
+    resume() {
+      if (stopped)
+        return;
+      paused = false;
+      render();
+    },
+    stop(finalLine) {
+      if (stopped)
+        return;
+      stopped = true;
+      if (timer)
+        clearInterval(timer);
+      clearLine();
+      if (finalLine)
+        output.write(`${finalLine}
+`);
+    }
+  };
+}
+
+// packages/cli-surface-plugin/src/commands/_async-ui.ts
+var FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+var DONE_SYMBOL = pc.green("\u25C7");
+var FAIL_SYMBOL = pc.red("\u25A0");
+var activeUpdate = null;
+async function withSpinner(label, work, options = {}) {
+  if (options.outputMode === "json") {
+    return work(() => {
+      return;
+    });
+  }
+  if (activeUpdate) {
+    activeUpdate(label);
+    return work(activeUpdate);
+  }
+  const output = options.output ?? process.stderr;
+  const isTty = output.isTTY === true;
+  let lastLabel = label;
+  if (!isTty) {
+    output.write(`${label}
+`);
+    const update2 = (next) => {
+      lastLabel = next;
+    };
+    activeUpdate = update2;
+    try {
+      return await work(update2);
+    } finally {
+      activeUpdate = null;
+    }
+  }
+  const spinner = createTtySpinner({
+    label,
+    output,
+    frames: FRAMES,
+    styleFrame: (frame) => pc.cyan(frame)
+  });
+  const update = (next) => {
+    lastLabel = next;
+    spinner.setLabel(next);
+  };
+  activeUpdate = update;
+  try {
+    const result = await work(update);
+    spinner.stop(options.doneLabel ? `${DONE_SYMBOL} ${options.doneLabel}` : undefined);
+    return result;
+  } catch (error) {
+    spinner.stop(`${FAIL_SYMBOL} ${lastLabel}`);
+    throw error;
+  } finally {
+    activeUpdate = null;
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/triage.ts
+function printTriageResult(context, result) {
+  if (context.outputMode !== "text")
+    return;
+  if (!result.enabled) {
+    const suffix = result.skippedReason === "no-config" ? "no rig.config task source was found" : "config.issueAnalysis is not enabled for continuous Pi analysis";
+    console.log(`Rig triage skipped: ${suffix}.`);
+    return;
+  }
+  console.log([
+    `Rig triage analyzed ${result.analyzedIssues} issue${result.analyzedIssues === 1 ? "" : "s"}.`,
+    `metadata patches: ${result.metadataPatches}`,
+    `labels added: ${result.labelsAdded}`,
+    `labels removed: ${result.labelsRemoved}`,
+    `generated issues: ${result.generatedIssues}`,
+    `snapshot refreshes: ${result.writeBackRefreshes}`
+  ].join(`
+`));
+}
+async function executeTriage(context, args, deps = {}) {
+  if (args[0] === "--help" || args[0] === "-h" || args[0] === "help") {
+    if (context.outputMode === "text")
+      console.log(`Usage: rig triage [--reason <text>]
+
+Runs the configured issueAnalysis pass once. Schedule this command externally for continuous triage.`);
+    return { ok: true, group: "triage", command: "help" };
+  }
+  const parsedReason = takeOption(args, "--reason");
+  requireNoExtraArgs(parsedReason.rest, "rig triage [--reason <text>]");
+  if (context.dryRun) {
+    const result2 = {
+      ok: true,
+      enabled: false,
+      reason: parsedReason.value?.trim() || "triage",
+      sourceId: null,
+      sourceKind: null,
+      analyzedIssues: 0,
+      metadataPatches: 0,
+      labelsAdded: 0,
+      labelsRemoved: 0,
+      generatedIssues: 0,
+      writeBackRefreshes: 0,
+      refreshedIssueCount: null,
+      skippedReason: "disabled",
+      dryRun: true
+    };
+    if (context.outputMode === "text")
+      console.log("[dry-run] rig triage would run the configured issueAnalysis pass once.");
+    return { ok: true, group: "triage", command: "run", details: result2 };
+  }
+  const result = await (deps.spinner ?? withSpinner)("Running Rig issue-analysis triage\u2026", () => (deps.runTriage ?? runIssueAnalysisTriage)({
+    projectRoot: context.projectRoot,
+    reason: parsedReason.value?.trim() || "triage"
+  }), { outputMode: context.outputMode });
+  printTriageResult(context, result);
+  return { ok: true, group: "triage", command: "run", details: result };
+}
+export {
+  executeTriage
+};

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

@@ -0,0 +1,3 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+export declare function executeWorkspace(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/workspace.js

@@ -0,0 +1,130 @@
+// @bun
+// 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/workspace.ts
+import {
+  mutateWorkspaceServiceFabric,
+  readWorkspaceRemoteFleet,
+  readWorkspaceSummary,
+  readWorkspaceTopology
+} from "@rig/runtime/control-plane/native/workspace-ops";
+async function executeWorkspace(context, args) {
+  const [command = "summary", ...rest] = args;
+  switch (command) {
+    case "summary": {
+      requireNoExtraArgs(rest, "rig workspace summary");
+      const summary = await readWorkspaceSummary(context.projectRoot);
+      if (context.outputMode === "text") {
+        console.log("Workspace Summary");
+        console.log(`  root:            ${summary.rootPath}`);
+        console.log(`  tasks:           ${summary.taskCounts.total} total \xB7 ${summary.taskCounts.ready} ready \xB7 ${summary.taskCounts.running} running \xB7 ${summary.taskCounts.blocked} blocked \xB7 ${summary.taskCounts.completed} completed \xB7 ${summary.taskCounts.unknown} unknown`);
+        console.log(`  runtimes:        ${summary.runtimeCount}`);
+        console.log(`  artifact tasks:  ${summary.artifactTaskCount}`);
+        console.log(`  topology:        ${summary.topology.status} \xB7 ${summary.topology.serviceCount} services from ${summary.topology.manifestCount} manifests`);
+        console.log(`  remote hosts:    ${summary.remoteFleet.status} \xB7 ${summary.remoteFleet.onlineHostCount} online of ${summary.remoteFleet.hostCount}`);
+        if (summary.serviceFabric) {
+          console.log(`  service fabric:  ${String(summary.serviceFabric.status ?? "unknown")} \xB7 ${String(summary.serviceFabric.healthyServiceCount ?? 0)} healthy of ${String(summary.serviceFabric.serviceCount ?? 0)}`);
+        }
+        console.log(`  failures log:    ${summary.failedApproachesPresent ? "present" : "missing"}`);
+        if (summary.warnings.length > 0) {
+          console.log(`
+Warnings:`);
+          for (const warning of summary.warnings) {
+            console.log(`  - ${warning}`);
+          }
+        }
+      }
+      return { ok: true, group: "workspace", command, details: summary };
+    }
+    case "topology": {
+      requireNoExtraArgs(rest, "rig workspace topology");
+      const topology = readWorkspaceTopology(context.projectRoot);
+      if (context.outputMode === "text") {
+        console.log(`Topology: ${topology.status}`);
+        for (const service of topology.services) {
+          const suffix = [service.runtime, service.port != null ? `:${service.port}` : null, service.healthcheck].filter(Boolean).join(" \xB7 ");
+          console.log(`- ${service.name}${suffix ? ` (${suffix})` : ""}`);
+          console.log(`  ${service.relativeRootPath}`);
+        }
+      }
+      return { ok: true, group: "workspace", command, details: topology };
+    }
+    case "remote-hosts": {
+      requireNoExtraArgs(rest, "rig workspace remote-hosts");
+      const fleet = readWorkspaceRemoteFleet(context.projectRoot);
+      if (context.outputMode === "text") {
+        console.log(`Remote Hosts: ${fleet.status}`);
+        for (const host of fleet.hosts) {
+          console.log(`- ${host.name} \xB7 ${host.status} \xB7 ${host.baseUrl}${host.workspacePath ? ` \xB7 ${host.workspacePath}` : ""}`);
+        }
+      }
+      return { ok: true, group: "workspace", command, details: fleet };
+    }
+    case "service-fabric": {
+      const [action = "status", ...serviceRest] = rest;
+      let pending = serviceRest;
+      const services = takeOption(pending, "--service");
+      pending = services.rest;
+      requireNoExtraArgs(pending, "rig workspace service-fabric <status|up|verify|down> [--service <name>]");
+      if (action !== "status" && action !== "up" && action !== "verify" && action !== "down") {
+        throw new CliError(`Unknown workspace service-fabric action: ${action}`, 1, { hint: "Use one of: `rig workspace service-fabric status|up|verify|down`." });
+      }
+      const selectedServices = services.value ? services.value.split(",").map((entry) => entry.trim()).filter(Boolean) : [];
+      const summary = action === "status" ? await mutateWorkspaceServiceFabric(context.projectRoot, "verify", selectedServices) : await mutateWorkspaceServiceFabric(context.projectRoot, action, selectedServices);
+      if (context.outputMode === "text") {
+        console.log(JSON.stringify(summary, null, 2));
+      }
+      return {
+        ok: true,
+        group: "workspace",
+        command: `service-fabric:${action}`,
+        details: summary
+      };
+    }
+    default:
+      throw new CliError(`Unknown workspace command: ${command}`, 1, { hint: "Run `rig workspace --help` \u2014 commands are summary|topology|remote-hosts|service-fabric." });
+  }
+}
+export {
+  executeWorkspace
+};

package/dist/src/kernel-dispatch.d.ts

@@ -0,0 +1,15 @@
+export type KernelDispatchInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly force?: boolean;
+    readonly prompt?: string | null;
+};
+export type KernelDispatchOptions = {
+    readonly placement?: unknown;
+};
+/** Dispatch a run through the resolved kernel transport capability. */
+export declare function dispatchThroughKernel(input: KernelDispatchInput, options?: KernelDispatchOptions): Promise<{
+    readonly runId: string;
+}>;

package/dist/src/kernel-dispatch.js

@@ -0,0 +1,16 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/cli-surface-plugin/src/kernel-dispatch.ts
+async function dispatchThroughKernel(input, options) {
+  const { getProcessKernel } = await import("@rig/kernel/boot-default");
+  const kernel = getProcessKernel();
+  if (!kernel) {
+    throw new Error("Kernel not booted: cannot dispatch a run through the transport capability.");
+  }
+  const runId = await kernel.transport.dispatch(input, options);
+  return { runId };
+}
+export {
+  dispatchThroughKernel
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const STANDARD_CLI_SURFACE_PLUGIN_NAME = "@rig/cli-surface-plugin";
+export declare function createStandardCliSurfacePlugin(): import("@rig/core").RigPluginWithRuntime;
+export declare const standardCliSurfacePlugin: import("@rig/core").RigPluginWithRuntime;