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

package/dist/src/commands/dist.js

@@ -0,0 +1,435 @@
+// @bun
+// packages/cli-surface-plugin/src/commands/dist.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readlinkSync,
+  rmSync,
+  statSync,
+  symlinkSync,
+  unlinkSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { resolve as resolve3 } from "path";
+
+// 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/dist.ts
+import {
+  computeRuntimeImageFingerprint,
+  computeRuntimeImageId
+} from "@rig/runtime/control-plane/runtime/image/index";
+import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
+
+// packages/cli-surface-plugin/src/commands/_parsers.ts
+import { homedir } from "os";
+import { resolve } from "path";
+function parseInstallScope(value) {
+  if (!value || value === "user") {
+    return "user";
+  }
+  if (value === "system") {
+    return "system";
+  }
+  throw new CliError(`Invalid --scope value: ${value}. Use user|system.`);
+}
+function resolveInstallDir(scope, explicitPath) {
+  if (explicitPath) {
+    return resolve(explicitPath);
+  }
+  if (scope === "system") {
+    return "/usr/local/bin";
+  }
+  return resolve(homedir(), ".local/bin");
+}
+
+// packages/cli-surface-plugin/src/commands/_paths.ts
+import { resolve as resolve2 } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/layout";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+function resolveControlPlaneHostStateRoot(projectRoot) {
+  return resolve2(projectRoot, ".rig");
+}
+function resolveControlPlaneHostBinDir(projectRoot) {
+  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "bin");
+}
+function resolveControlPlaneHostDistDir(projectRoot) {
+  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "dist");
+}
+function resolveControlPlaneMonorepoStateRoot(projectRoot) {
+  return resolve2(resolveControlPlaneMonorepoRoot(projectRoot), ".rig");
+}
+function resolveControlPlaneMonorepoRuntimeDir(projectRoot) {
+  return resolve2(resolveControlPlaneMonorepoStateRoot(projectRoot), "runtime");
+}
+
+// packages/cli-surface-plugin/src/commands/_probes.ts
+async function runQuietBinaryProbe(binaryPath, args, cwd) {
+  try {
+    const run = await Bun.$`${binaryPath} ${args}`.cwd(cwd).quiet().nothrow();
+    return run.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/dist.ts
+function collectRigValidatorBuildTargets(input) {
+  const validatorsRoot = resolve3(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
+  if (!existsSync(validatorsRoot))
+    return [];
+  const targets = [];
+  for (const category of readdirSync(validatorsRoot, { withFileTypes: true })) {
+    if (!category.isDirectory())
+      continue;
+    const categoryDir = resolve3(validatorsRoot, category.name);
+    for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".ts"))
+        continue;
+      const check = entry.name.replace(/\.ts$/, "");
+      if (!check || check === "index" || check === "shared")
+        continue;
+      const validatorName = `${category.name}-${check}`;
+      targets.push({
+        source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
+        dest: resolve3(input.imageDir, `bin/validators/${validatorName}`),
+        cwd: input.hostProjectRoot
+      });
+    }
+  }
+  return targets;
+}
+async function findLatestDistBinary(projectRoot) {
+  const distRoot = resolveControlPlaneHostDistDir(projectRoot);
+  if (!existsSync(distRoot)) {
+    return null;
+  }
+  const candidates = [];
+  for (const entry of readdirSync(distRoot, { withFileTypes: true })) {
+    if (!entry.name.startsWith("rig-") && entry.name !== "rig")
+      continue;
+    const entryPath = resolve3(distRoot, entry.name);
+    const binary = entry.isDirectory() ? resolve3(entryPath, "bin", "rig") : entryPath;
+    try {
+      const stat = statSync(binary);
+      if (stat.isFile())
+        candidates.push({ path: binary, mtimeMs: stat.mtimeMs });
+    } catch {}
+  }
+  candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const { path } of candidates) {
+    if (await isRunnableRigBinary(path, projectRoot))
+      return path;
+  }
+  return null;
+}
+async function isRunnableRigBinary(binaryPath, projectRoot) {
+  return runQuietBinaryProbe(binaryPath, ["help"], projectRoot);
+}
+async function runDistDoctor(projectRoot) {
+  const bunPath = Bun.which("bun");
+  const rigPath = Bun.which("rig");
+  const userBinDir = resolve3(homedir2(), ".local/bin");
+  const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
+  let rigRunnable = false;
+  if (rigPath) {
+    rigRunnable = await runQuietBinaryProbe(rigPath, ["help"], projectRoot);
+  }
+  return {
+    bun: {
+      available: Boolean(bunPath),
+      path: bunPath || null,
+      version: Bun.version
+    },
+    rig: {
+      onPath: Boolean(rigPath),
+      path: rigPath || null,
+      runnable: rigRunnable
+    },
+    userBinDir,
+    userBinInPath,
+    latestDistBinary: await findLatestDistBinary(projectRoot)
+  };
+}
+function rigRunSiblingOf(binaryPath) {
+  const name = binaryPath.split(/[\\/]/).pop() ?? "rig";
+  const suffix = name.toLowerCase().endsWith(".exe") ? ".exe" : "";
+  const stem = suffix ? name.slice(0, -suffix.length) : name;
+  const sibling = stem === "rig" ? `rig-run${suffix}` : stem.startsWith("rig-") ? `${stem.replace(/^rig/, "rig-run")}${suffix}` : `rig-run${suffix}`;
+  return resolve3(binaryPath, "..", sibling);
+}
+function installExecutable(source, target) {
+  if (resolve3(source) !== resolve3(target)) {
+    if (existsSync(target)) {
+      unlinkSync(target);
+    }
+    copyFileSync(source, target);
+  }
+  chmodSync(target, 493);
+}
+async function executeDist(context, args) {
+  const [command = "build", ...rest] = args;
+  switch (command) {
+    case "build": {
+      const { value: outputDir, rest: pending } = takeOption(rest, "--output-dir");
+      requireNoExtraArgs(pending, "rig dist build [--output-dir <dir>]");
+      const commandParts = ["bun", "run", "packages/cli/bin/build-rig-binaries.ts"];
+      if (outputDir)
+        commandParts.push("--output-dir", outputDir);
+      await context.runCommand(commandParts);
+      return { ok: true, group: "dist", command, details: { outputDir: outputDir || null } };
+    }
+    case "install": {
+      let pending = rest;
+      const scopeResult = takeOption(pending, "--scope");
+      pending = scopeResult.rest;
+      const pathResult = takeOption(pending, "--dir");
+      pending = pathResult.rest;
+      requireNoExtraArgs(pending, "rig dist install [--scope user|system] [--dir <dir>]");
+      const scope = parseInstallScope(scopeResult.value);
+      const installDir = resolveInstallDir(scope, pathResult.value);
+      mkdirSync(installDir, { recursive: true });
+      let source = await findLatestDistBinary(context.projectRoot);
+      let buildDir = null;
+      if (!source) {
+        buildDir = resolve3(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
+        await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
+        source = resolve3(buildDir, "bin", "rig");
+      }
+      if (!existsSync(source)) {
+        throw new CliError(`Unable to locate rig binary at ${source}.`, 2, { hint: "Build it first with `rig dist build`, then re-run `rig dist install`." });
+      }
+      const installedPath = resolve3(installDir, "rig");
+      const installedRigRunPath = rigRunSiblingOf(installedPath);
+      const sourceRigRun = rigRunSiblingOf(source);
+      installExecutable(source, installedPath);
+      installExecutable(existsSync(sourceRigRun) ? sourceRigRun : source, installedRigRunPath);
+      const pathEntries = (process.env.PATH || "").split(":").filter(Boolean);
+      const inPath = pathEntries.includes(installDir);
+      if (context.outputMode === "text") {
+        console.log(`Installed: ${installedPath}`);
+        console.log(`Installed: ${installedRigRunPath}`);
+        if (!inPath) {
+          console.log(`PATH note: add ${installDir} to PATH to run 'rig' directly.`);
+        }
+      }
+      return {
+        ok: true,
+        group: "dist",
+        command,
+        details: {
+          scope,
+          installDir,
+          installedPath,
+          installedRigRunPath,
+          sourcePath: source,
+          sourceRigRunPath: existsSync(sourceRigRun) ? sourceRigRun : null,
+          builtNow: Boolean(buildDir),
+          inPath
+        }
+      };
+    }
+    case "doctor": {
+      requireNoExtraArgs(rest, "rig dist doctor");
+      const details = await runDistDoctor(context.projectRoot);
+      if (context.outputMode === "text") {
+        console.log(`bun: ${details.bun.available ? `ok (${details.bun.version})` : "missing"}`);
+        console.log(`rig on PATH: ${details.rig.onPath ? details.rig.path : "missing"}`);
+        console.log(`user bin dir: ${details.userBinDir} (${details.userBinInPath ? "in PATH" : "not in PATH"})`);
+        console.log(`latest dist binary: ${details.latestDistBinary || "none"}`);
+      }
+      return { ok: true, group: "dist", command, details };
+    }
+    case "rebuild-agent": {
+      requireNoExtraArgs(rest, "rig dist rebuild-agent");
+      const fp = await computeRuntimeImageFingerprint(context.projectRoot);
+      const currentId = computeRuntimeImageId(fp);
+      const imagesDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
+      mkdirSync(imagesDir, { recursive: true });
+      let pruned = 0;
+      for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && entry.name !== currentId) {
+          rmSync(resolve3(imagesDir, entry.name), { recursive: true, force: true });
+          pruned++;
+        }
+      }
+      if (pruned > 0 && context.outputMode === "text") {
+        console.log(`Pruned ${pruned} stale image(s).`);
+      }
+      const imageDir = resolve3(imagesDir, currentId);
+      mkdirSync(resolve3(imageDir, "bin/hooks"), { recursive: true });
+      mkdirSync(resolve3(imageDir, "bin/plugins"), { recursive: true });
+      mkdirSync(resolve3(imageDir, "bin/validators"), { recursive: true });
+      const hookNames = [
+        "scope-guard",
+        "import-guard",
+        "safety-guard",
+        "test-integrity-guard",
+        "audit-trail",
+        "post-edit-lint",
+        "completion-verification",
+        "inject-context",
+        "task-runtime-start"
+      ];
+      const targets = [];
+      const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || context.projectRoot;
+      targets.push({ source: "packages/cli/bin/rig-agent.ts", dest: resolve3(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
+      for (const hookName of hookNames) {
+        const src = `packages/runtime/src/control-plane/hooks/${hookName}.ts`;
+        targets.push({ source: src, dest: resolve3(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve3(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
+      }
+      const pluginsDir = resolve3(context.projectRoot, "rig/plugins");
+      const binPluginsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
+      const validatorsRoot = resolve3(hostProjectRoot, "packages/runtime/src/control-plane/validators");
+      const binValidatorsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
+      mkdirSync(binPluginsDir, { recursive: true });
+      mkdirSync(binValidatorsDir, { recursive: true });
+      if (existsSync(pluginsDir)) {
+        for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
+          const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
+          if (!m)
+            continue;
+          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve3(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
+        }
+      }
+      targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
+      for (const { source, dest, cwd } of targets) {
+        if (context.outputMode === "text") {
+          console.log(`Building: ${dest}`);
+        }
+        const isValidator = dest.includes("/bin/validators/");
+        await buildBinary2(source, dest, cwd, isValidator ? { AGENT_BUN_PATH: Bun.which("bun") || "bun" } : { AGENT_PROJECT_ROOT: context.projectRoot });
+      }
+      if (existsSync(pluginsDir)) {
+        for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
+          const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
+          if (!m)
+            continue;
+          const pluginName = m[1];
+          const imageBin = resolve3(imageDir, `bin/plugins/${pluginName}`);
+          if (!pluginName)
+            continue;
+          const symlinkPath = resolve3(binPluginsDir, pluginName);
+          if (existsSync(imageBin)) {
+            try {
+              unlinkSync(symlinkPath);
+            } catch {}
+            symlinkSync(imageBin, symlinkPath);
+          }
+        }
+      }
+      if (existsSync(validatorsRoot)) {
+        const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+        for (const category of categories) {
+          const categoryDir = resolve3(validatorsRoot, category.name);
+          for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".ts"))
+              continue;
+            const check = entry.name.replace(/\.ts$/, "");
+            if (!check || check === "index" || check === "shared")
+              continue;
+            const validatorName = `${category.name}-${check}`;
+            const imageBin = resolve3(imageDir, `bin/validators/${validatorName}`);
+            const symlinkPath = resolve3(binValidatorsDir, validatorName);
+            if (existsSync(imageBin)) {
+              try {
+                unlinkSync(symlinkPath);
+              } catch {}
+              symlinkSync(imageBin, symlinkPath);
+            }
+          }
+        }
+      }
+      const agentsDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
+      if (existsSync(agentsDir)) {
+        let relinkCount = 0;
+        for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
+          if (!agentEntry.isDirectory())
+            continue;
+          const agentBinDir = resolve3(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
+          if (!existsSync(agentBinDir))
+            continue;
+          const walkDir = (dir) => {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+              const fullPath = resolve3(dir, entry.name);
+              if (entry.isDirectory()) {
+                walkDir(fullPath);
+              } else if (entry.isSymbolicLink()) {
+                const target = readlinkSync(fullPath);
+                if (target.includes("/.rig/runtime/images/") && !target.includes(`/${currentId}/`)) {
+                  const newTarget = target.replace(/\/\.rig\/runtime\/images\/[^/]+\//, `/.rig/runtime/images/${currentId}/`);
+                  try {
+                    unlinkSync(fullPath);
+                    symlinkSync(newTarget, fullPath);
+                    relinkCount++;
+                  } catch {}
+                }
+              }
+            }
+          };
+          walkDir(agentBinDir);
+        }
+        if (relinkCount > 0 && context.outputMode === "text") {
+          console.log(`Re-linked ${relinkCount} worktree symlink(s) to image ${currentId}.`);
+        }
+      }
+      if (context.outputMode === "text") {
+        console.log(`Rebuilt ${targets.length} binaries into image ${currentId}.`);
+      }
+      return { ok: true, group: "dist", command, details: { imageId: currentId, count: targets.length } };
+    }
+    default:
+      throw new CliError(`Unknown dist command: ${command}`, 1, { hint: "Run `rig dist --help` \u2014 commands are build|install|doctor|rebuild-agent." });
+  }
+}
+export {
+  executeDist,
+  collectRigValidatorBuildTargets
+};

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

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

package/dist/src/commands/doctor.js

@@ -0,0 +1,171 @@
+// @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 requireNoExtraArgs(args, usage) {
+  if (args.length > 0) {
+    throw new CliError(`Unexpected arguments: ${args.join(" ")}
+Usage: ${usage}`);
+  }
+}
+
+// packages/cli-surface-plugin/src/commands/_doctor-checks.ts
+import { countDoctorFailures, runDoctorChecks } from "@rig/client";
+var runRigDoctorChecks = runDoctorChecks;
+function formatDoctorChecks(checks) {
+  return checks.map((entry) => {
+    const status = String(entry.status ?? entry.level ?? "warn");
+    const marker = status === "pass" || status === "ok" ? "OK" : status === "warn" ? "WARN" : "FAIL";
+    return `${marker}: ${entry.label}${entry.detail ? ` \u2014 ${entry.detail}` : ""}${entry.remediation ? `
+  fix: ${entry.remediation}` : ""}`;
+  }).join(`
+`);
+}
+
+// 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/doctor.ts
+async function executeDoctor(context, args) {
+  requireNoExtraArgs(args, "legacy diagnostic: rig doctor");
+  const checks = await withSpinner("Running doctor checks\u2026", (update) => runRigDoctorChecks({ projectRoot: context.projectRoot, onProgress: update }), { outputMode: context.outputMode });
+  if (context.outputMode === "text") {
+    console.log(formatDoctorChecks(checks));
+  }
+  return {
+    ok: countDoctorFailures(checks) === 0,
+    group: "doctor",
+    command: "check",
+    details: { checks, failures: countDoctorFailures(checks) }
+  };
+}
+export {
+  executeDoctor
+};

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

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