@h-rig/cli 0.0.6-alpha.94 → 0.0.6-alpha.96

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

@@ -1,28 +0,0 @@
-import { type RunnerContext } from "../runner";
-import type { CommandOutcome } from "@rig/runtime";
-export type DistDoctorDetails = {
-    bun: {
-        available: boolean;
-        path: string | null;
-        version: string;
-    };
-    rig: {
-        onPath: boolean;
-        path: string | null;
-        runnable: boolean;
-    };
-    userBinDir: string;
-    userBinInPath: boolean;
-    latestDistBinary: string | null;
-};
-export type BuildTarget = {
-    source: string;
-    dest: string;
-    cwd: string;
-};
-export declare function collectRigValidatorBuildTargets(input: {
-    contextProjectRoot: string;
-    hostProjectRoot: string;
-    imageDir: string;
-}): BuildTarget[];
-export declare function executeDist(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

package/dist/src/commands/dist.js

@@ -1,417 +0,0 @@
-// @bun
-// packages/cli/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/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/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/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/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/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/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)
-  };
-}
-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");
-      if (existsSync(installedPath)) {
-        unlinkSync(installedPath);
-      }
-      copyFileSync(source, installedPath);
-      chmodSync(installedPath, 493);
-      const pathEntries = (process.env.PATH || "").split(":").filter(Boolean);
-      const inPath = pathEntries.includes(installDir);
-      if (context.outputMode === "text") {
-        console.log(`Installed: ${installedPath}`);
-        if (!inPath) {
-          console.log(`PATH note: add ${installDir} to PATH to run 'rig' directly.`);
-        }
-      }
-      return {
-        ok: true,
-        group: "dist",
-        command,
-        details: {
-          scope,
-          installDir,
-          installedPath,
-          sourcePath: source,
-          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/runtime/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

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