@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.91

package/dist/src/commands/repo-git-harness.d.ts

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

package/dist/src/commands/repo-git-harness.js

@@ -1,12 +1,19 @@
 // @bun
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
+import { CliError as RuntimeCliError } 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";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
 function formatCommand(parts) {
   return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
 }
@@ -30,7 +37,7 @@ function takeOption(args, option) {
     if (current === option) {
       const next = args[index + 1];
       if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
+        throw new CliError(`Missing value for ${option}`, 1, { hint: `Provide a value after ${option}, e.g. \`${option} <value>\`.` });
       }
       value = next;
       index += 1;
@@ -93,23 +100,67 @@ function withMutedConsole(mute, fn) {
 }
 
 // packages/cli/src/commands/_policy.ts
-import { appendFileSync, mkdirSync } from "fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// packages/cli/src/commands/_paths.ts
 import { resolve } from "path";
-import { evaluate as evaluate2, loadPolicy as loadPolicy2, resolveAction as resolveAction2 } from "@rig/runtime/control-plane/runtime/guard";
-import { resolveHarnessPaths } from "@rig/runtime/control-plane/native/utils";
+import { resolveMonorepoRoot } from "@rig/runtime/layout";
+function resolveControlPlaneHostStateRoot(projectRoot) {
+  return resolve(projectRoot, ".rig");
+}
+function resolveControlPlaneHostLogsDir(projectRoot) {
+  return resolve(resolveControlPlaneHostStateRoot(projectRoot), "logs");
+}
+function resolveControlPlaneDefinitionRoot(projectRoot) {
+  return resolve(projectRoot, "rig");
+}
+
+// packages/cli/src/commands/_policy.ts
+function loadPolicyFile(projectRoot) {
+  const policyPath = resolve2(resolveControlPlaneDefinitionRoot(projectRoot), "policy", "policy.json");
+  if (!existsSync(policyPath)) {
+    return { mode: "observe", rules: [] };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(policyPath, "utf8"));
+    const mode = parsed.mode === "off" || parsed.mode === "observe" || parsed.mode === "enforce" ? parsed.mode : "observe";
+    const rules = Array.isArray(parsed.rules) ? parsed.rules.filter((value) => Boolean(value && typeof value === "object" && !Array.isArray(value))).map((value, index) => ({
+      id: typeof value.id === "string" && value.id.trim() ? value.id.trim() : `rule-${index + 1}`,
+      reason: typeof value.reason === "string" && value.reason.trim() ? value.reason.trim() : undefined,
+      match: typeof value.match === "string" && value.match.trim() ? value.match.trim() : undefined,
+      command: typeof value.command === "string" && value.command.trim() ? value.command.trim() : undefined
+    })) : [];
+    return { mode, rules };
+  } catch {
+    return { mode: "observe", rules: [] };
+  }
+}
+function matchingRules(command, rules) {
+  return rules.filter((rule) => {
+    const rawPattern = rule.command ?? rule.match;
+    if (!rawPattern)
+      return false;
+    try {
+      return new RegExp(rawPattern, "i").test(command);
+    } catch {
+      return command.includes(rawPattern);
+    }
+  });
+}
 function resolveEffectivePolicyMode(context) {
   const envMode = process.env.RIG_BASH_MODE;
   if (envMode === "off" || envMode === "observe" || envMode === "enforce") {
     return envMode;
   }
-  return context.policyMode || loadPolicy2(context.projectRoot).mode;
+  return context.policyMode ?? loadPolicyFile(context.projectRoot).mode;
 }
 function appendControlledBashAudit(context, mode, command, args, matchedRuleIds, action) {
   if (mode === "off") {
     return;
   }
-  const logsDir = resolveHarnessPaths(context.projectRoot).logsDir;
-  const logFile = resolve(logsDir, "controlled-bash.jsonl");
+  const logsDir = resolveControlPlaneHostLogsDir(context.projectRoot);
+  const logFile = resolve2(logsDir, "controlled-bash.jsonl");
   mkdirSync(logsDir, { recursive: true });
   const payload = {
     timestamp: new Date().toISOString(),
@@ -130,25 +181,24 @@ function appendControlledBashAudit(context, mode, command, args, matchedRuleIds,
 async function enforceNativeCommandPolicy(context, args, options) {
   const mode = resolveEffectivePolicyMode(context);
   const command = formatCommand([options.commandPrefix, ...args]);
-  const decision = evaluate2({
-    projectRoot: context.projectRoot,
-    evaluation: { type: "command", command }
-  });
-  const action = resolveAction2(mode, decision.matchedRules);
-  const matchedRuleIds = decision.matchedRules.map((rule) => rule.id);
+  const rules = matchingRules(command, loadPolicyFile(context.projectRoot).rules);
+  const matchedRuleIds = rules.map((rule) => rule.id);
+  const action = rules.length === 0 ? "allow" : mode === "enforce" ? "block" : "warn";
   await context.emitEvent("policy.decision", {
     target: "command",
     command,
     mode,
     allowed: action !== "block",
     matchedRuleIds,
-    reasons: decision.matchedRules.map((rule) => rule.reason)
+    reasons: rules.map((rule) => rule.reason).filter(Boolean)
   });
   if (options.writeAuditLog) {
     appendControlledBashAudit(context, mode, command, args, matchedRuleIds, action === "block" ? "blocked" : action === "warn" ? "warn" : undefined);
   }
   if (action === "block") {
-    throw new CliError2(`Policy blocked command: ${command}`, 126);
+    throw new CliError(`Policy blocked command: ${command}`, 126, {
+      hint: "Review rig/policy/policy.json, or re-run with `--policy-mode observe` to log instead of block."
+    });
   }
 }
 
@@ -158,23 +208,23 @@ async function executeRepo(context, args) {
   switch (command) {
     case "sync": {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
-      requireNoExtraArgs(remaining, "bun run rig repo sync [--task <beads-id>]");
+      requireNoExtraArgs(remaining, "rig repo sync [--task <task-id>]");
       withMutedConsole(context.outputMode === "json", () => repoEnsure(context.projectRoot, task || undefined));
       return { ok: true, group: "repo", command, details: { task: task || null } };
     }
     case "reset-baseline": {
       const { value: keepTaskStatusFlag, rest: remaining } = takeFlag(rest, "--keep-task-status");
-      requireNoExtraArgs(remaining, "bun run rig repo reset-baseline [--keep-task-status]");
+      requireNoExtraArgs(remaining, "rig repo reset-baseline [--keep-task-status]");
       withMutedConsole(context.outputMode === "json", () => resetBaseline(context.projectRoot, keepTaskStatusFlag));
       return { ok: true, group: "repo", command, details: { keepTaskStatus: keepTaskStatusFlag } };
     }
     default:
-      throw new CliError2(`Unknown repo command: ${command}`);
+      throw new CliError(`Unknown repo command: ${command}`, 1, { hint: "Run `rig repo --help` \u2014 commands are sync|reset-baseline." });
   }
 }
 async function executeGit(context, args) {
   if (args.length === 0) {
-    throw new CliError2("Usage: bun run rig git <git-flow args...>");
+    throw new CliError("Usage: rig git <git-flow args...>");
   }
   await enforceNativeCommandPolicy(context, args, {
     commandPrefix: "rig-agent git",
@@ -187,15 +237,15 @@ async function executeGit(context, args) {
     return { ok: true, group: "git", command: args[0] ?? "git" };
   }
   try {
-    await executeHarnessCommand(context.projectRoot, context.plugins, ["git", ...args]);
+    await executeHarnessCommand(context.projectRoot, ["git", ...args]);
   } catch (error) {
-    throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+    throw new CliError(error instanceof Error ? error.message : String(error), 2);
   }
   return { ok: true, group: "git", command: args[0] ?? "git" };
 }
 async function executeHarness(context, args) {
   if (args.length === 0) {
-    throw new CliError2("Usage: bun run rig harness <harness args...>");
+    throw new CliError("Usage: rig harness <harness args...>");
   }
   await enforceNativeCommandPolicy(context, args, {
     commandPrefix: "rig-agent",
@@ -208,9 +258,9 @@ async function executeHarness(context, args) {
     return { ok: true, group: "harness", command: args[0] ?? "harness" };
   }
   try {
-    await executeHarnessCommand(context.projectRoot, context.plugins, args);
+    await executeHarnessCommand(context.projectRoot, args);
   } catch (error) {
-    throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+    throw new CliError(error instanceof Error ? error.message : String(error), 2);
   }
   return { ok: true, group: "harness", command: args[0] ?? "harness" };
 }

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

@@ -0,0 +1,21 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime";
+import { type RigExtensionTask, type RunControl } from "./_run-bridge";
+import { type RunJoinTarget, type RunProjectionRecord } from "./_run-projection";
+export type RunTaskLike = RigExtensionTask & Record<string, unknown>;
+export interface RunExecutorDeps {
+    readonly listRuns?: (projectRoot: string) => Promise<RunProjectionRecord[]>;
+    readonly getRun?: (projectRoot: string, runId: string) => Promise<RunProjectionRecord | null>;
+    readonly resolveJoin?: (projectRoot: string, runId: string) => Promise<RunJoinTarget | null>;
+    readonly dispatch?: (input: {
+        readonly projectRoot: string;
+        readonly taskId: string;
+        readonly title?: string | null;
+    }) => Promise<{
+        readonly runId: string;
+    }>;
+    readonly listTasks?: (projectRoot: string) => Promise<readonly RunTaskLike[]>;
+    readonly appendLocal?: (record: RunProjectionRecord, text: string) => Promise<void>;
+    readonly deliverRemote?: (projectRoot: string, runId: string, control: RunControl) => Promise<void>;
+}
+export declare function executeRun(context: RunnerContext, args: string[], deps?: RunExecutorDeps): Promise<CommandOutcome>;