@h-rig/cli 0.0.6-alpha.0

package/dist/src/commands/profile-and-review.js

@@ -0,0 +1,178 @@
+// @bun
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+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}`);
+      }
+      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/profile-and-review.ts
+import {
+  setProfile,
+  setReviewProfile,
+  showProfile,
+  showReviewProfile
+} from "@rig/runtime/control-plane/native/profile-ops";
+
+// packages/cli/src/withMutedConsole.ts
+function isPromise(value) {
+  if (typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return value !== null && typeof value.then === "function";
+}
+function withMutedConsole(mute, fn) {
+  if (!mute) {
+    return fn();
+  }
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalInfo = console.info;
+  const restore = () => {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.info = originalInfo;
+  };
+  console.log = () => {};
+  console.warn = () => {};
+  console.info = () => {};
+  try {
+    const result = fn();
+    if (isPromise(result)) {
+      return result.finally(restore);
+    }
+    restore();
+    return result;
+  } catch (error) {
+    restore();
+    throw error;
+  } finally {
+    if (console.log === originalLog) {
+      restore();
+    }
+  }
+}
+
+// packages/cli/src/commands/profile-and-review.ts
+async function executeProfile(context, args) {
+  const [command = "show", ...rest] = args;
+  switch (command) {
+    case "show":
+      requireNoExtraArgs(rest, "bun run rig profile show");
+      await withMutedConsole(context.outputMode === "json", () => showProfile(context.projectRoot));
+      return { ok: true, group: "profile", command };
+    case "set": {
+      if (rest.length === 0) {
+        throw new CliError2("Usage: bun run rig profile set <claude-code|codex-cli|pi> or set [--model ...] [--runtime ...] [--plugin ...]");
+      }
+      const preset = rest[0];
+      if (preset && !preset.startsWith("-")) {
+        if (rest.length !== 1) {
+          throw new CliError2("Usage: bun run rig profile set <claude-code|codex-cli|pi>");
+        }
+        try {
+          await withMutedConsole(context.outputMode === "json", () => setProfile(context.projectRoot, { preset }));
+        } catch (error) {
+          throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+        }
+        return { ok: true, group: "profile", command, details: { preset } };
+      }
+      let pending = rest;
+      const modelResult = takeOption(pending, "--model");
+      pending = modelResult.rest;
+      const runtimeResult = takeOption(pending, "--runtime");
+      pending = runtimeResult.rest;
+      const pluginResult = takeOption(pending, "--plugin");
+      pending = pluginResult.rest;
+      requireNoExtraArgs(pending, "bun run rig profile set [--model ...] [--runtime ...] [--plugin ...]");
+      if (!modelResult.value && !runtimeResult.value && !pluginResult.value) {
+        throw new CliError2("Provide at least one of --model, --runtime, or --plugin.");
+      }
+      try {
+        await withMutedConsole(context.outputMode === "json", () => setProfile(context.projectRoot, {
+          model: modelResult.value,
+          runtime: runtimeResult.value,
+          plugin: pluginResult.value
+        }));
+      } catch (error) {
+        throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+      }
+      return {
+        ok: true,
+        group: "profile",
+        command,
+        details: {
+          model: modelResult.value || null,
+          runtime: runtimeResult.value || null,
+          plugin: pluginResult.value || null
+        }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown profile command: ${command}`);
+  }
+}
+async function executeReview(context, args) {
+  const [command = "show", ...rest] = args;
+  switch (command) {
+    case "show":
+      requireNoExtraArgs(rest, "bun run rig review show");
+      await withMutedConsole(context.outputMode === "json", () => showReviewProfile(context.projectRoot));
+      return { ok: true, group: "review", command };
+    case "set": {
+      if (rest.length === 0) {
+        throw new CliError2("Usage: bun run rig review set <off|advisory|required> [--provider greptile]");
+      }
+      const mode = rest[0];
+      if (!mode) {
+        throw new CliError2("Usage: bun run rig review set <off|advisory|required> [--provider greptile]");
+      }
+      let pending = rest.slice(1);
+      const providerResult = takeOption(pending, "--provider");
+      pending = providerResult.rest;
+      requireNoExtraArgs(pending, "bun run rig review set <off|advisory|required> [--provider greptile]");
+      try {
+        await withMutedConsole(context.outputMode === "json", () => {
+          return setReviewProfile(context.projectRoot, mode, providerResult.value);
+        });
+      } catch (error) {
+        throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+      }
+      return { ok: true, group: "review", command, details: { mode, provider: providerResult.value || null } };
+    }
+    default:
+      throw new CliError2(`Unknown review command: ${command}`);
+  }
+}
+export {
+  executeReview,
+  executeProfile
+};

package/dist/src/commands/queue.js

@@ -0,0 +1,197 @@
+// @bun
+// packages/cli/src/runner.ts
+import { EventBus } from "@rig/runtime/control-plane/runtime/events";
+import { CliError } from "@rig/runtime/control-plane/errors";
+import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
+import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
+import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
+import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+function takeFlag(args, flag) {
+  const rest = [];
+  let value = false;
+  for (const arg of args) {
+    if (arg === flag) {
+      value = true;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return { value, rest };
+}
+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}`);
+      }
+      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/queue.ts
+import { runPriorityQueue } from "@rig/runtime/control-plane/runtime/queue";
+
+// packages/cli/src/commands/_parsers.ts
+function parsePositiveInt(value, option, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError2(`Invalid ${option} value: ${value}`);
+  }
+  return parsed;
+}
+function parseAction(value) {
+  if (!value || value === "validate") {
+    return "validate";
+  }
+  if (value === "verify") {
+    return "verify";
+  }
+  if (value === "pipeline") {
+    return "pipeline";
+  }
+  throw new CliError2(`Invalid --action value: ${value}. Use validate, verify, or pipeline.`);
+}
+function parseIsolationMode(value, allowOff) {
+  if (!value) {
+    return "worktree";
+  }
+  if (value === "worktree") {
+    return value;
+  }
+  if (allowOff && value === "off") {
+    return value;
+  }
+  throw new CliError2(`Invalid isolation mode: ${value}. Use ${allowOff ? "off|" : ""}worktree.`);
+}
+
+// packages/cli/src/commands/_preflight.ts
+import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/project-main-pre-run-sync";
+
+// packages/cli/src/commands/_server-client.ts
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_preflight.ts
+async function runProjectMainSyncPreflight(context, options) {
+  if (context.dryRun) {
+    if (context.outputMode === "text" && !options.disabled) {
+      console.log("[dry-run] project-rig pre-run sync check");
+    }
+    return;
+  }
+  const result = await ensureProjectMainFreshBeforeRun({
+    projectRoot: context.projectRoot,
+    disabled: options.disabled,
+    runBootstrap: async () => {
+      const bootstrap = await context.runCommand(["bun", "run", "bootstrap"]);
+      if (bootstrap.exitCode !== 0) {
+        throw new CliError2(bootstrap.stderr || bootstrap.stdout || "bun run bootstrap failed during project pre-run sync", bootstrap.exitCode || 1);
+      }
+    }
+  });
+  if (context.outputMode !== "text") {
+    return;
+  }
+  switch (result.status) {
+    case "disabled":
+      console.log("Project pre-run sync skipped (--skip-project-sync).");
+      break;
+    case "skipped_not_main":
+      console.log(`Project pre-run sync skipped (current branch: ${result.branch}).`);
+      break;
+    case "up_to_date":
+      break;
+    case "local_ahead":
+      console.log(`Project pre-run sync skipped (local main ahead by ${result.localAhead} commit(s)).`);
+      break;
+    case "updated":
+      console.log(`Project pre-run sync updated local main from origin/main (+${result.remoteAhead}) and bootstrapped.`);
+      break;
+  }
+}
+
+// packages/cli/src/commands/queue.ts
+async function executeQueue(context, args) {
+  const [command = "run", ...rest] = args;
+  switch (command) {
+    case "run": {
+      let pending = rest;
+      const workersResult = takeOption(pending, "--workers");
+      pending = workersResult.rest;
+      const maxTasksResult = takeOption(pending, "--max-tasks");
+      pending = maxTasksResult.rest;
+      const actionResult = takeOption(pending, "--action");
+      pending = actionResult.rest;
+      const isolationResult = takeOption(pending, "--isolation");
+      pending = isolationResult.rest;
+      const noRuntimeReuseResult = takeFlag(pending, "--no-runtime-reuse");
+      pending = noRuntimeReuseResult.rest;
+      const failFastResult = takeFlag(pending, "--fail-fast");
+      pending = failFastResult.rest;
+      const skipProjectSyncResult = takeFlag(pending, "--skip-project-sync");
+      pending = skipProjectSyncResult.rest;
+      requireNoExtraArgs(pending, "bun run rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]");
+      const workers = parsePositiveInt(workersResult.value, "--workers", 2);
+      const maxTasks = parsePositiveInt(maxTasksResult.value, "--max-tasks", 10);
+      const action = parseAction(actionResult.value);
+      const isolation = parseIsolationMode(isolationResult.value, true);
+      const reuseRuntime = !noRuntimeReuseResult.value;
+      await runProjectMainSyncPreflight(context, { disabled: skipProjectSyncResult.value });
+      const summary = await runPriorityQueue(context, {
+        workers,
+        maxTasks,
+        action,
+        isolation,
+        reuseRuntime,
+        failFast: failFastResult.value
+      });
+      if (context.outputMode === "text") {
+        console.log(`Processed: ${summary.processed}`);
+        console.log(`Succeeded: ${summary.succeeded}`);
+        console.log(`Failed: ${summary.failed}`);
+      }
+      if (summary.failed > 0) {
+        throw new CliError2(`Queue finished with ${summary.failed} failed task(s).`, 3);
+      }
+      return {
+        ok: true,
+        group: "queue",
+        command,
+        details: {
+          workers,
+          maxTasks,
+          action,
+          isolation,
+          reuseRuntime,
+          failFast: failFastResult.value,
+          summary
+        }
+      };
+    }
+    default:
+      throw new CliError2(`Unknown queue command: ${command}`);
+  }
+}
+export {
+  executeQueue
+};