@h-rig/cli 0.0.6-alpha.0

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

@@ -0,0 +1,221 @@
+// @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 formatCommand(parts) {
+  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
+}
+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/repo-git-harness.ts
+import { executeHarnessCommand } from "@rig/runtime/control-plane/native/harness-cli";
+import { repoEnsure, resetBaseline } from "@rig/runtime/control-plane/native/repo-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/_policy.ts
+import { appendFileSync, mkdirSync } from "fs";
+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";
+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;
+}
+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");
+  mkdirSync(logsDir, { recursive: true });
+  const payload = {
+    timestamp: new Date().toISOString(),
+    mode,
+    cwd: process.cwd(),
+    pid: process.pid,
+    ppid: process.ppid,
+    argv: args,
+    command,
+    matchedRuleIds
+  };
+  if (action) {
+    payload.action = action;
+  }
+  appendFileSync(logFile, `${JSON.stringify(payload)}
+`, "utf-8");
+}
+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);
+  await context.emitEvent("policy.decision", {
+    target: "command",
+    command,
+    mode,
+    allowed: action !== "block",
+    matchedRuleIds,
+    reasons: decision.matchedRules.map((rule) => rule.reason)
+  });
+  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);
+  }
+}
+
+// packages/cli/src/commands/repo-git-harness.ts
+async function executeRepo(context, args) {
+  const [command = "sync", ...rest] = args;
+  switch (command) {
+    case "sync": {
+      const { value: task, rest: remaining } = takeOption(rest, "--task");
+      requireNoExtraArgs(remaining, "bun run rig repo sync [--task <beads-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]");
+      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}`);
+  }
+}
+async function executeGit(context, args) {
+  if (args.length === 0) {
+    throw new CliError2("Usage: bun run rig git <git-flow args...>");
+  }
+  await enforceNativeCommandPolicy(context, args, {
+    commandPrefix: "rig-agent git",
+    writeAuditLog: false
+  });
+  if (context.dryRun) {
+    if (context.outputMode === "text") {
+      console.log(`[dry-run] rig git ${args.join(" ")}`);
+    }
+    return { ok: true, group: "git", command: args[0] ?? "git" };
+  }
+  try {
+    await executeHarnessCommand(context.projectRoot, context.plugins, ["git", ...args]);
+  } catch (error) {
+    throw new CliError2(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...>");
+  }
+  await enforceNativeCommandPolicy(context, args, {
+    commandPrefix: "rig-agent",
+    writeAuditLog: true
+  });
+  if (context.dryRun) {
+    if (context.outputMode === "text") {
+      console.log(`[dry-run] rig harness ${args.join(" ")}`);
+    }
+    return { ok: true, group: "harness", command: args[0] ?? "harness" };
+  }
+  try {
+    await executeHarnessCommand(context.projectRoot, context.plugins, args);
+  } catch (error) {
+    throw new CliError2(error instanceof Error ? error.message : String(error), 2);
+  }
+  return { ok: true, group: "harness", command: args[0] ?? "harness" };
+}
+export {
+  executeRepo,
+  executeHarness,
+  executeGit
+};