@agentwares/agentguard 0.1.7 → 0.1.9

package/dist/chunk-6S7LYVOC.js

@@ -0,0 +1,1033 @@
+import {
+  HOOKS_POLICY_BLOCK,
+  hookTarget,
+  hooksCommand,
+  installedHandlers,
+  renderHooksStarterPolicy
+} from "./chunk-3O6KWT3E.js";
+import {
+  flagBool,
+  flagList,
+  flagString,
+  homeFrom,
+  parseArgs,
+  version
+} from "./chunk-SUXQTT3X.js";
+
+// src/commands/audit.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join4, resolve as resolve3 } from "path";
+import {
+  NOT_CHECKABLE_HINT,
+  applicableNoun,
+  describeStep,
+  evaluateChecks,
+  extractRules,
+  planEnforcement,
+  stableHash as stableHash2,
+  summarizeAudit
+} from "@agentwares/agentguard-core";
+
+// src/audit/cache.ts
+import { createHash } from "crypto";
+import { mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "fs";
+import { join } from "path";
+var CACHE_DIR = "audit-cache-v1";
+var ENGINE = "1";
+var sha = (text) => createHash("sha256").update(text).digest("hex");
+var WHAT = ["command", "path", "call"];
+function encodeBreak(b) {
+  return [
+    b.at,
+    b.session,
+    b.step,
+    b.file,
+    b.line,
+    WHAT.indexOf(b.what),
+    b.index,
+    b.asked === null ? 2 : b.asked ? 1 : 0,
+    b.refused ? 1 : 0
+  ];
+}
+function decodeBreak(w) {
+  return {
+    at: w[0],
+    session: w[1],
+    step: w[2],
+    file: w[3],
+    line: w[4],
+    what: WHAT[w[5]] ?? "call",
+    index: w[6],
+    asked: w[7] === 2 ? null : w[7] === 1,
+    refused: w[8] === 1
+  };
+}
+function fileSignature(group2) {
+  return group2.files.map((f) => [sha(f.path), f.size, Math.round(f.mtimeMs)]);
+}
+var AuditCache = class {
+  constructor(home, repo, enabled = true) {
+    this.repo = repo;
+    this.enabled = enabled;
+    this.dir = join(home, CACHE_DIR);
+    if (!enabled) return;
+    let names;
+    try {
+      names = readdirSync(this.dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      try {
+        const w = JSON.parse(readFileSync(join(this.dir, name), "utf8"));
+        if (w.v !== 1 || w.engine !== ENGINE || w.repo !== repo) continue;
+        this.entries.set(w.group, {
+          repo: w.repo,
+          group: w.group,
+          client: w.client,
+          files: w.files,
+          audit: {
+            sessions: w.sessions.map(([id, client, start, end, known]) => ({
+              id,
+              client,
+              start,
+              end,
+              turnsKnown: known === 1
+            })),
+            unread: w.unread,
+            checks: Object.fromEntries(
+              Object.entries(w.checks).map(([k, c]) => [
+                k,
+                { applicable: c.a, breaks: c.b.map(decodeBreak) }
+              ])
+            )
+          }
+        });
+      } catch {
+      }
+    }
+  }
+  repo;
+  enabled;
+  dir;
+  entries = /* @__PURE__ */ new Map();
+  groupKey(group2) {
+    return sha(`${this.repo}\0${group2.key}`);
+  }
+  /** The cached counts for a group, if its files are unchanged and every check is answered. */
+  lookup(group2, keys) {
+    const hit = this.entries.get(this.groupKey(group2));
+    if (!hit) return void 0;
+    if (JSON.stringify(hit.files) !== JSON.stringify(fileSignature(group2))) return void 0;
+    if (!keys.every((k) => hit.audit.checks[k])) return void 0;
+    return hit.audit;
+  }
+  /** Counts kept from groups whose transcripts are gone (deleted by the client's cleanup). */
+  retained(present, client) {
+    const out = [];
+    for (const e of this.entries.values())
+      if (e.client === client && !present.has(e.group)) out.push(e.audit);
+    return out;
+  }
+  /** Best effort: a cache that cannot be written only costs speed and history. */
+  store(group2, audit) {
+    const key = this.groupKey(group2);
+    const files = fileSignature(group2);
+    const prev = this.entries.get(key);
+    const checks = prev && JSON.stringify(prev.files) === JSON.stringify(files) ? { ...prev.audit.checks, ...audit.checks } : audit.checks;
+    const merged = { ...audit, checks };
+    this.entries.set(key, {
+      repo: this.repo,
+      group: key,
+      client: group2.client,
+      files,
+      audit: merged
+    });
+    if (!this.enabled) return;
+    const wire = {
+      v: 1,
+      engine: ENGINE,
+      repo: this.repo,
+      group: key,
+      client: group2.client,
+      files,
+      sessions: merged.sessions.map((s) => [s.id, s.client, s.start, s.end, s.turnsKnown ? 1 : 0]),
+      unread: merged.unread,
+      checks: Object.fromEntries(
+        Object.entries(merged.checks).map(([k, c]) => [
+          k,
+          { a: c.applicable, b: c.breaks.map(encodeBreak) }
+        ])
+      )
+    };
+    try {
+      mkdirSync(this.dir, { recursive: true, mode: 448 });
+      const file = join(this.dir, `${key.slice(0, 32)}.json`);
+      const tmp = `${file}.${process.pid}.tmp`;
+      writeFileSync(tmp, JSON.stringify(wire), { mode: 384 });
+      renameSync(tmp, file);
+    } catch {
+    }
+  }
+};
+
+// src/audit/enforce.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import YAML, { isMap, isScalar, isSeq } from "yaml";
+var origin = (rule) => ` R${rule.n} ${rule.file}:${rule.line}`;
+function seqAt(doc, path) {
+  let node = doc.getIn(path, true);
+  if (!isSeq(node)) {
+    doc.setIn(path, doc.createNode([]));
+    node = doc.getIn(path, true);
+  }
+  const seq = node;
+  seq.flow = false;
+  return seq;
+}
+var values = (seq) => seq.items.map((n) => isScalar(n) ? String(n.value) : "").map((v) => v.toLowerCase());
+function applyEnforcePlan(policyPath, plan, now = /* @__PURE__ */ new Date()) {
+  const created = !existsSync(policyPath);
+  const before = created ? "" : readFileSync2(policyPath, "utf8");
+  let text = created ? renderHooksStarterPolicy(now) : before;
+  if (!/^hooks\s*:/m.test(text)) text = `${text.replace(/\n*$/, "\n")}${HOOKS_POLICY_BLOCK}`;
+  const doc = YAML.parseDocument(text);
+  if (doc.errors.length > 0)
+    throw new Error(`${policyPath} is not valid YAML: ${doc.errors[0].message}`);
+  const added = [];
+  for (const item of plan.items) {
+    const seq = seqAt(doc, item.list.split("."));
+    if (values(seq).includes(item.pattern.toLowerCase())) continue;
+    const node = doc.createNode(item.pattern);
+    node.comment = origin(item.rule);
+    seq.items.push(node);
+    added.push(`${item.list}: ${item.pattern}  (R${item.rule.n}, ${item.check.label})`);
+  }
+  if (plan.builtins.length > 0) {
+    const path = ["hooks", "irreversible", "builtins"];
+    const node = doc.getIn(path, true);
+    const enabled = isScalar(node) ? node.value : void 0;
+    if (enabled === false || isSeq(node)) {
+      const seq = seqAt(doc, path);
+      for (const b of plan.builtins) {
+        if (values(seq).includes(b.name)) continue;
+        const scalar = doc.createNode(b.name);
+        scalar.comment = origin(b.rule);
+        seq.items.push(scalar);
+        added.push(`hooks.irreversible.builtins: ${b.name}  (R${b.rule.n}, ${b.check.label})`);
+      }
+    }
+  }
+  if (plan.irreversible.length > 0) {
+    const seq = seqAt(doc, ["hooks", "irreversible", "rules"]);
+    const names = new Set(
+      seq.items.map((n) => isMap(n) ? String(n.get("name") ?? "") : "").filter(Boolean)
+    );
+    for (const r of plan.irreversible) {
+      if (names.has(r.name)) continue;
+      const node = doc.createNode({ name: r.name, shell: r.shell, mentions: r.mentions });
+      if (isMap(node)) node.commentBefore = origin(r.rule);
+      seq.items.push(node);
+      added.push(
+        `hooks.irreversible.rules: ${r.name} (${r.shell.length} commands)  (R${r.rule.n}, ${r.check.label})`
+      );
+    }
+  }
+  const mode = doc.getIn(["hooks", "mode"]) === "enforce" ? "enforce" : "dry-run";
+  return { before, after: doc.toString({ lineWidth: 0 }), created, added, mode };
+}
+function lineDiff(a, b, context = 2) {
+  const x = a === "" ? [] : a.replace(/\n$/, "").split("\n");
+  const y = b.replace(/\n$/, "").split("\n");
+  const n = x.length;
+  const m = y.length;
+  const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+  for (let i2 = n - 1; i2 >= 0; i2 -= 1)
+    for (let j2 = m - 1; j2 >= 0; j2 -= 1)
+      lcs[i2][j2] = x[i2] === y[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && x[i] === y[j]) {
+      ops.push({ op: " ", line: x[i] });
+      i += 1;
+      j += 1;
+    } else if (j < m && (i >= n || lcs[i][j + 1] >= lcs[i + 1][j])) {
+      ops.push({ op: "+", line: y[j] });
+      j += 1;
+    } else {
+      ops.push({ op: "-", line: x[i] });
+      i += 1;
+    }
+  }
+  const keep = /* @__PURE__ */ new Set();
+  ops.forEach((o, k) => {
+    if (o.op === " ") return;
+    for (let d = -context; d <= context; d += 1) keep.add(k + d);
+  });
+  const out = [];
+  let last = -2;
+  ops.forEach((o, k) => {
+    if (!keep.has(k)) return;
+    if (k !== last + 1 && out.length > 0) out.push("  \u2026");
+    out.push(`${o.op} ${o.line}`);
+    last = k;
+  });
+  return out;
+}
+
+// src/audit/read.ts
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import {
+  ClaudeCodeAuditReader,
+  CodexAuditReader,
+  stableHash
+} from "@agentwares/agentguard-core";
+var CLAUDE_WANTED = (raw) => raw.includes('"type":"assistant"') || raw.includes('"type":"user"');
+var CODEX_WANTED = (raw) => raw.includes('"session_meta"') || raw.includes('"turn_context"') || raw.includes('"function_call"') || raw.includes('"local_shell_call"') || raw.includes('"custom_tool_call"');
+async function eachLine(path, wanted, onLine) {
+  const stream = createReadStream(path, { encoding: "utf8", highWaterMark: 1 << 20 });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  let n = 0;
+  try {
+    for await (const raw of lines) {
+      n += 1;
+      if (raw.length === 0 || !wanted(raw, n)) continue;
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (onLine(value, n) === false) break;
+    }
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+async function readGroup(group2, opts) {
+  if (group2.client === "codex") {
+    const reader2 = new CodexAuditReader(opts);
+    await eachLine(group2.files[0].path, CODEX_WANTED, (value, line) => {
+      reader2.add(value, line, 0);
+      return reader2.relevant;
+    });
+    return reader2.result();
+  }
+  const reader = new ClaudeCodeAuditReader(opts);
+  for (const [i, file] of group2.files.entries())
+    await eachLine(file.path, CLAUDE_WANTED, (value, line) => reader.add(value, line, i));
+  return reader.result();
+}
+async function fetchSteps(group2, wanted, opts) {
+  const out = /* @__PURE__ */ new Map();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const w of wanted) {
+    const set = byFile.get(w.file) ?? /* @__PURE__ */ new Set();
+    set.add(w.line);
+    byFile.set(w.file, set);
+  }
+  for (const [fileIndex, lines] of byFile) {
+    const file = group2.files[fileIndex];
+    if (!file) continue;
+    const last = Math.max(...lines);
+    const reader = group2.client === "codex" ? new CodexAuditReader(opts) : new ClaudeCodeAuditReader(opts);
+    await eachLine(
+      file.path,
+      (raw, n) => lines.has(n) || group2.client === "codex" && (raw.includes('"session_meta"') || raw.includes('"turn_context"')),
+      (value, n) => {
+        reader.add(value, n, fileIndex);
+        return n < last;
+      }
+    );
+    for (const step of reader.result().steps) out.set(stableHash(step.id), step);
+  }
+  return out;
+}
+
+// src/audit/repo.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { dirname, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "path";
+import YAML2 from "yaml";
+import {
+  AuditRulesSchema,
+  isWithin,
+  normalizePath
+} from "@agentwares/agentguard-core";
+
+// src/audit/sources.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, realpathSync, statSync } from "fs";
+import { basename, join as join2, resolve } from "path";
+function sourceDirs(env, home, overrides = {}) {
+  const claude = overrides.claudeDir ? [resolve(overrides.claudeDir)] : env.CLAUDE_CONFIG_DIR ? env.CLAUDE_CONFIG_DIR.split(",").map((d) => d.trim()).filter(Boolean).map((d) => join2(resolve(d), "projects")) : [join2(home, ".claude", "projects"), join2(home, ".config", "claude", "projects")];
+  const codexHome = env.CODEX_HOME ? resolve(env.CODEX_HOME) : join2(home, ".codex");
+  const codex = overrides.codexDir ? [resolve(overrides.codexDir)] : [join2(codexHome, "sessions"), join2(codexHome, "archived_sessions")];
+  return { "claude-code": claude, codex };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["tool-results", "memory", "node_modules", ".git"]);
+function stat(path) {
+  try {
+    const s = statSync(path);
+    return s.isFile() ? { path, size: s.size, mtimeMs: s.mtimeMs } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function jsonlUnder(dir, out, depth = 0) {
+  if (depth > 6) return;
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = join2(dir, e.name);
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) jsonlUnder(p, out, depth + 1);
+    } else if (e.isFile() && e.name.endsWith(".jsonl")) {
+      const f = stat(p);
+      if (f) out.push(f);
+    }
+  }
+}
+function claudeProjectName(dir) {
+  return dir.replace(/[^a-zA-Z0-9]/g, "-");
+}
+function pathForms(dir) {
+  const forms = /* @__PURE__ */ new Set([resolve(dir)]);
+  try {
+    forms.add(realpathSync(dir));
+  } catch {
+  }
+  return [...forms];
+}
+function claudeProjectDirs(roots, repoRoot) {
+  const names = pathForms(repoRoot).map(claudeProjectName);
+  const out = [];
+  for (const root of roots) {
+    let entries;
+    try {
+      entries = readdirSync2(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (names.some((n) => e.name === n || e.name.startsWith(`${n}-`)))
+        out.push(join2(root, e.name));
+    }
+  }
+  return out;
+}
+function claudeGroups(projectDirs) {
+  const groups = [];
+  for (const dir of projectDirs) {
+    let entries;
+    try {
+      entries = readdirSync2(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const mains = /* @__PURE__ */ new Map();
+    const subdirs = [];
+    for (const e of entries) {
+      const p = join2(dir, e.name);
+      if (e.isFile() && e.name.endsWith(".jsonl")) {
+        const f = stat(p);
+        if (f) mains.set(basename(e.name, ".jsonl"), f);
+      } else if (e.isDirectory() && !SKIP_DIRS.has(e.name)) subdirs.push(e.name);
+    }
+    for (const [id, main] of mains) {
+      const files = [main];
+      if (subdirs.includes(id)) jsonlUnder(join2(dir, id), files);
+      groups.push(group("claude-code", main.path, files));
+    }
+    for (const id of subdirs) {
+      if (mains.has(id)) continue;
+      const files = [];
+      jsonlUnder(join2(dir, id), files);
+      if (files.length > 0) groups.push(group("claude-code", join2(dir, id), files));
+    }
+  }
+  return groups;
+}
+function codexGroups(roots) {
+  const files = [];
+  for (const root of roots) if (existsSync2(root)) jsonlUnder(root, files);
+  return files.map((f) => group("codex", f.path, [f]));
+}
+function group(client, key, files) {
+  files.sort((a, b) => a.path === key ? -1 : b.path === key ? 1 : a.path.localeCompare(b.path));
+  return { client, key, files, lastWrite: Math.max(...files.map((f) => f.mtimeMs)) };
+}
+
+// src/audit/repo.ts
+function findRepo(cwd) {
+  let dir = resolve2(cwd);
+  for (let i = 0; i < 64; i += 1) {
+    const dotgit = join3(dir, ".git");
+    if (existsSync3(dotgit)) {
+      let root = dir;
+      try {
+        if (statSync2(dotgit).isFile()) {
+          const m = /^gitdir:\s*(.+)$/m.exec(readFileSync3(dotgit, "utf8"));
+          const gitdir = m ? resolve2(dir, m[1].trim()) : "";
+          const at = gitdir.lastIndexOf(`${sep}.git${sep}worktrees${sep}`);
+          if (at > 0) root = gitdir.slice(0, at);
+        }
+      } catch {
+      }
+      return { checkout: dir, root };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { checkout: resolve2(cwd), root: resolve2(cwd) };
+}
+function repoMatcher(root) {
+  const forms = pathForms(root).map(normalizePath);
+  return (cwd) => forms.some((f) => isWithin(normalizePath(cwd), f));
+}
+var RULE_FILES = [
+  "CLAUDE.md",
+  "CLAUDE.local.md",
+  ".claude/CLAUDE.md",
+  "AGENTS.md",
+  "GEMINI.md",
+  ".cursorrules",
+  ".github/copilot-instructions.md",
+  ".windsurfrules",
+  ".clinerules"
+];
+var MAX_CURSOR_RULES = 20;
+var MAX_BYTES = 512 * 1024;
+function cursorRules(dir, out, depth = 0) {
+  if (depth > 3 || out.length >= MAX_CURSOR_RULES) return;
+  let entries;
+  try {
+    entries = readdirSync3(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const p = join3(dir, e.name);
+    if (e.isDirectory()) cursorRules(p, out, depth + 1);
+    else if (e.isFile() && /\.(mdc|md)$/.test(e.name) && out.length < MAX_CURSOR_RULES) out.push(p);
+  }
+}
+function readRuleFiles(checkout, extra = []) {
+  const paths = RULE_FILES.map((f) => join3(checkout, f));
+  cursorRules(join3(checkout, ".cursor", "rules"), paths);
+  for (const e of extra) paths.push(isAbsolute(e) ? e : resolve2(checkout, e));
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    if (seen.has(p)) continue;
+    seen.add(p);
+    try {
+      if (!statSync2(p).isFile()) continue;
+      const text = readFileSync3(p, "utf8").slice(0, MAX_BYTES);
+      const rel = relative(checkout, p);
+      out.push({ path: rel.startsWith("..") ? p : rel.split(sep).join("/"), text });
+    } catch {
+    }
+  }
+  return out;
+}
+function readConfigRules(policyPath) {
+  if (!existsSync3(policyPath)) return { rules: [] };
+  let raw;
+  try {
+    raw = YAML2.parse(readFileSync3(policyPath, "utf8"));
+  } catch (err) {
+    return {
+      rules: [],
+      warning: `${policyPath} is not valid YAML (${err instanceof Error ? err.message : String(err)}); its audit.rules were skipped`
+    };
+  }
+  const audit = raw && typeof raw === "object" ? raw.audit : void 0;
+  const rules = audit && typeof audit === "object" ? audit.rules : void 0;
+  if (rules === void 0) return { rules: [] };
+  const parsed = AuditRulesSchema.safeParse(rules);
+  if (!parsed.success)
+    return {
+      rules: [],
+      warning: `audit.rules in ${policyPath} is invalid (${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}); skipped`
+    };
+  return { rules: parsed.data };
+}
+
+// src/commands/audit.ts
+var TEAM_HISTORY_URL = "https://agentwares-agentguard.vercel.app/team-history";
+var TEAM_HISTORY_LINE = `Team adherence history across repos and developers is coming \u2014 ${TEAM_HISTORY_URL}`;
+var CLIENT_LABEL = { "claude-code": "Claude Code", codex: "Codex" };
+function parseSince(value, now) {
+  const v = (value ?? "7d").trim().toLowerCase();
+  if (v === "all") return void 0;
+  const rel = /^(\d+)\s*([dhw])$/.exec(v);
+  if (rel) {
+    const n = Number(rel[1]);
+    const unit = rel[2] === "h" ? 36e5 : rel[2] === "w" ? 7 * 864e5 : 864e5;
+    return now.getTime() - n * unit;
+  }
+  const t = Date.parse(/^\d{4}-\d{2}-\d{2}$/.test(v) ? `${v}T00:00:00` : v);
+  if (!Number.isFinite(t))
+    throw new Error(`--since "${value}": use 7d, 30d, 24h, all or a date (YYYY-MM-DD)`);
+  return t;
+}
+function clientsFrom(args) {
+  const names = flagList(args, "client").map((n) => n.trim().toLowerCase());
+  if (names.length === 0 || names.includes("all")) return ["claude-code", "codex"];
+  return names.map((n) => {
+    if (n === "claude" || n === "claude-code") return "claude-code";
+    if (n === "codex") return "codex";
+    throw new Error(`unknown --client "${n}" (claude, codex or all)`);
+  });
+}
+var pad = (n) => String(n).padStart(2, "0");
+var localTime = (ms) => {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+};
+var localDay = (ms) => localTime(ms).slice(0, 10);
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+async function pool(items, size, work) {
+  let next = 0;
+  const run = async () => {
+    while (next < items.length) await work(items[next++]);
+  };
+  await Promise.all(Array.from({ length: Math.min(size, items.length) }, run));
+}
+function enforceTarget(check) {
+  switch (check.spec.kind) {
+    case "run-before":
+    case "no-commit-to":
+      return "audit-only";
+    case "no-edit":
+      return "hooks.paths.deny";
+    case "no-new-deps":
+      return check.spec.unlessAsked ? "hooks.shell.approval" : "hooks.shell.deny";
+    case "no-rm-outside":
+    case "no-publish":
+      return "hooks.irreversible.builtins";
+    case "no-deploy":
+      return "hooks.irreversible.rules";
+    default:
+      return "hooks.shell.deny";
+  }
+}
+async function auditCommand(args, io) {
+  const now = /* @__PURE__ */ new Date();
+  const json = flagBool(args, "json") === true;
+  const since = parseSince(flagString(args, "since"), now);
+  const clients = clientsFrom(args);
+  const home = homeFrom(io);
+  const repo = findRepo(resolve3(io.cwd, flagString(args, "repo") ?? "."));
+  const policyPath = resolve3(
+    repo.checkout,
+    flagString(args, "config") ?? io.env.AGENTGUARD_CONFIG ?? "agentguard.yaml"
+  );
+  const files = readRuleFiles(repo.checkout, flagList(args, "rules"));
+  const config = readConfigRules(policyPath);
+  const { rules, errors } = extractRules(files, config.rules, "agentguard.yaml");
+  const warnings = [
+    ...config.warning ? [config.warning] : [],
+    ...errors.map((e) => `${e.file}:${e.line}: ${e.message}`)
+  ];
+  const checks = rules.flatMap((r) => r.checks);
+  const keys = [...new Set(checks.map((c) => c.key))];
+  if (flagBool(args, "enforce")) return enforce(args, io, rules, policyPath, repo.checkout, json);
+  const dirs = sourceDirs(io.env, home, {
+    claudeDir: flagString(args, "claude-dir"),
+    codexDir: flagString(args, "codex-dir")
+  });
+  const groups = [
+    ...clients.includes("claude-code") ? claudeGroups(claudeProjectDirs(dirs["claude-code"], repo.root)) : [],
+    ...clients.includes("codex") ? codexGroups(dirs.codex) : []
+  ];
+  const cache = new AuditCache(
+    resolve3(io.cwd, flagString(args, "cache-dir") ?? join4(home, ".agentguard")),
+    sha(repo.root),
+    flagBool(args, "cache") !== false
+  );
+  const inRepo = repoMatcher(repo.root);
+  const ctx = {
+    repoRoot: repo.root,
+    home,
+    tmpDirs: [
+      tmpdir(),
+      io.env.TMPDIR ?? "",
+      "/tmp",
+      "/private/tmp",
+      "/var/folders",
+      "/private/var/folders"
+    ].filter(Boolean)
+  };
+  const counts = {
+    "claude-code": { transcripts: 0, read: 0, cached: 0, retained: 0, older: 0 },
+    codex: { transcripts: 0, read: 0, cached: 0, retained: 0, older: 0 }
+  };
+  const entries = [];
+  const evidence = !json && flagBool(args, "evidence") !== false;
+  await pool(groups, 6, async (group2) => {
+    const c = counts[group2.client];
+    c.transcripts += group2.files.length;
+    const hit = cache.lookup(group2, keys);
+    if (hit) {
+      c.cached += group2.files.length;
+      entries.push({ group: group2, audit: hit });
+      return;
+    }
+    if (since !== void 0 && group2.lastWrite < since) {
+      c.older += group2.files.length;
+      return;
+    }
+    let read;
+    try {
+      read = await readGroup(group2, { inRepo });
+    } catch {
+      return;
+    }
+    c.read += group2.files.length;
+    const audit = evaluateChecks(checks, read, ctx);
+    cache.store(group2, audit);
+    const hasBreaks = Object.values(audit.checks).some((o) => o.breaks.length > 0);
+    entries.push({
+      group: group2,
+      audit,
+      ...evidence && hasBreaks ? { steps: new Map(read.steps.map((s) => [stableHash2(s.id), s])) } : {}
+    });
+  });
+  const present = new Set(groups.map((g) => cache.groupKey(g)));
+  for (const client of clients)
+    for (const audit of cache.retained(present, client)) {
+      counts[client].retained += 1;
+      entries.push({ audit });
+    }
+  const summary = summarizeAudit(
+    rules,
+    entries.map((e) => e.audit),
+    { since }
+  );
+  const plan = planEnforcement(rules);
+  const enforceable = /* @__PURE__ */ new Set([
+    ...plan.items.map((i) => i.rule.id),
+    ...plan.builtins.map((b) => b.rule.id),
+    ...plan.irreversible.map((r) => r.rule.id)
+  ]);
+  if (json) {
+    io.out(
+      JSON.stringify(
+        {
+          tool: "agentguard audit",
+          version: version(),
+          repo: repo.root,
+          checkout: repo.checkout,
+          since: since === void 0 ? null : new Date(since).toISOString(),
+          until: now.toISOString(),
+          rule_files: files.map((f) => f.path),
+          sources: counts,
+          sessions: {
+            total: summary.sessions,
+            "claude-code": summary.sessionsByClient["claude-code"],
+            codex: summary.sessionsByClient.codex
+          },
+          unread_tool_calls: summary.unread,
+          rules: summary.rules.map((r) => ({
+            id: r.rule.id,
+            n: r.rule.n,
+            file: r.rule.file,
+            line: r.rule.line,
+            text: r.rule.text,
+            status: r.status,
+            checkable: r.rule.checks.length > 0,
+            ...r.rule.silenced ? { marked_not_checkable: true } : {},
+            sessions_broken: r.sessionsBroken,
+            last_broken: r.last.map((b) => new Date(b.at).toISOString()),
+            checks: r.checks.map((c, k) => ({
+              check: c.label,
+              kind: c.kind,
+              via: c.via,
+              enforce: enforceTarget(r.rule.checks[k]),
+              sessions_applicable: c.sessionsApplicable,
+              sessions_broken: c.sessionsBroken,
+              sessions_on_request: c.sessionsOnRequest,
+              sessions_undetermined: c.sessionsUndetermined,
+              breaks: c.breaks,
+              refused: c.refused
+            }))
+          })),
+          not_checkable: {
+            count: summary.rules.filter((r) => r.status === "not-checkable").length,
+            hint: NOT_CHECKABLE_HINT
+          },
+          warnings,
+          enforce: {
+            command: "agentguard audit --enforce",
+            rules: enforceable.size,
+            note: "writes hook-mode rules into agentguard.yaml in dry-run; nothing is blocked until hooks.mode is enforce"
+          },
+          team_history: { available: false, url: TEAM_HISTORY_URL },
+          privacy: "counts, rule ids and dates only: no command, path or prompt from a transcript is in this output, and nothing was sent anywhere"
+        },
+        null,
+        2
+      )
+    );
+    return 0;
+  }
+  const lines = /* @__PURE__ */ new Map();
+  if (evidence) {
+    const wanted = /* @__PURE__ */ new Map();
+    for (const r of summary.rules)
+      for (const b of r.last) {
+        const list = wanted.get(b.group) ?? [];
+        list.push(b);
+        wanted.set(b.group, list);
+      }
+    for (const [gi, breaks] of wanted) {
+      const entry = entries[gi];
+      if (!entry?.group) continue;
+      let steps = entry.steps;
+      if (!steps) {
+        try {
+          steps = await fetchSteps(entry.group, breaks, { inRepo });
+        } catch {
+          continue;
+        }
+      }
+      for (const b of breaks) {
+        const step = steps.get(b.step);
+        if (step) lines.set(`${gi}:${b.step}:${b.what}:${b.index}`, describeStep(step, b, ctx));
+      }
+    }
+  }
+  renderHuman(io, {
+    root: repo.root,
+    since,
+    files: files.map((f) => f.path),
+    counts,
+    clients,
+    summary,
+    evidence: evidence ? (b) => lines.get(`${b.group}:${b.step}:${b.what}:${b.index}`) ?? "(transcript no longer on disk)" : () => void 0,
+    enforceable: enforceable.size,
+    warnings
+  });
+  return 0;
+}
+function ruleHead(r) {
+  const id = `R${r.rule.n}`.padEnd(4);
+  return `  ${id} ${clip(r.rule.text, 78)}   (${r.rule.file}:${r.rule.line})`;
+}
+function renderHuman(io, v) {
+  const s = v.summary;
+  const window = v.since === void 0 ? "all history" : `since ${localDay(v.since)}`;
+  io.out(`agentguard audit \u2014 ${v.root} \xB7 ${window}`);
+  const read = v.clients.map((c) => {
+    const n = v.counts[c];
+    const parts = [`${n.read} read`, `${n.cached} from cache`];
+    if (n.retained) parts.push(`${n.retained} kept from deleted transcripts`);
+    if (n.older) parts.push(`${n.older} older than the window`);
+    return `${CLIENT_LABEL[c]}: ${plural(n.transcripts, "transcript")} (${parts.join(", ")})`;
+  });
+  io.out(read.join(" \xB7 "));
+  const byClient = v.clients.filter((c) => s.sessionsByClient[c] > 0).map((c) => `${CLIENT_LABEL[c]} ${s.sessionsByClient[c]}`);
+  io.out(
+    `${plural(s.sessions, "session")} in this repository${byClient.length ? ` (${byClient.join(", ")})` : ""}. Read on this machine; nothing was sent anywhere.`
+  );
+  if (s.unread > 0)
+    io.out(
+      `${plural(s.unread, "Codex tool call")} ran JavaScript (\`exec\`), not a command line, and ${s.unread === 1 ? "was" : "were"} not read.`
+    );
+  for (const w of v.warnings) io.out(`warning: ${w}`);
+  io.out("");
+  if (v.files.length === 0 && s.rules.length === 0) {
+    io.out(
+      "No rule files here (CLAUDE.md, AGENTS.md, GEMINI.md, .cursor/rules, \u2026) and no audit.rules in agentguard.yaml: nothing to audit."
+    );
+    io.out("");
+    io.out(TEAM_HISTORY_LINE);
+    return;
+  }
+  const checkable = s.rules.filter((r) => r.status !== "not-checkable");
+  const perFile = /* @__PURE__ */ new Map();
+  for (const r of s.rules) perFile.set(r.rule.file, (perFile.get(r.rule.file) ?? 0) + 1);
+  io.out(
+    `${plural(s.rules.length, "rule")} found (${[...perFile].map(([f, n]) => `${n} in ${f}`).join(", ")}); ${checkable.length} checkable.`
+  );
+  if (s.sessions === 0)
+    io.out(
+      `No Claude Code or Codex sessions in ${v.root} ${window}. Transcripts are read from ~/.claude/projects and ~/.codex/sessions (--claude-dir, --codex-dir); try --since 30d or --since all.`
+    );
+  const section = (title, list, body) => {
+    if (list.length === 0) return;
+    io.out("");
+    io.out(title);
+    for (const r of list) {
+      io.out(ruleHead(r));
+      body(r);
+    }
+  };
+  const checkLines = (r) => {
+    r.rule.checks.forEach((check, k) => {
+      const c = r.checks[k];
+      const noun = applicableNoun(c.kind, check.spec);
+      const scope = noun ? ` (${c.sessionsApplicable} ${noun})` : "";
+      let verdict;
+      if (c.sessionsBroken > 0) {
+        verdict = `broken in ${c.sessionsBroken} of ${s.sessions} sessions${scope}`;
+        const extra = [];
+        if (c.breaks > c.sessionsBroken) extra.push(`${c.breaks} times`);
+        if (c.sessionsOnRequest > 0)
+          extra.push(`${c.sessionsOnRequest} on a turn that asked for it`);
+        if (c.refused > 0) extra.push(`${c.refused} refused by the harness`);
+        if (extra.length) verdict += `; ${extra.join(", ")}`;
+      } else if (c.sessionsApplicable > 0 || !noun) {
+        const n = noun ? c.sessionsApplicable : s.sessions;
+        verdict = n === 1 ? `kept in the 1 session${noun ? ` that ${noun}` : ""}` : `kept in all ${n} sessions${noun ? ` that ${noun}` : ""}`;
+      } else verdict = `nothing in these sessions could break it`;
+      if (c.sessionsUndetermined > 0)
+        verdict += `; ${c.sessionsUndetermined} more in sessions that do not say who asked (Codex)`;
+      io.out(`       ${c.label} \u2014 ${verdict}`);
+    });
+    for (const b of r.last) {
+      const what = v.evidence(b);
+      io.out(
+        `         ${localTime(b.at)}${what ? `  ${what}` : ""}${b.refused ? "  [refused]" : ""}${b.asked ? "  [asked]" : ""}  \xB7 session ${b.session.slice(0, 8)}`
+      );
+    }
+  };
+  section(
+    "BROKEN",
+    s.rules.filter((r) => r.status === "broken").sort((a, b) => b.sessionsBroken - a.sessionsBroken),
+    checkLines
+  );
+  section(
+    "KEPT",
+    s.rules.filter((r) => r.status === "kept"),
+    checkLines
+  );
+  section(
+    "NOTHING IN THESE SESSIONS COULD BREAK IT",
+    s.rules.filter((r) => r.status === "not-applicable"),
+    checkLines
+  );
+  const notCheckable = s.rules.filter((r) => r.status === "not-checkable");
+  if (notCheckable.length > 0) {
+    io.out("");
+    io.out(
+      `NOT CHECKABLE MECHANICALLY (${notCheckable.length}) \u2014 ${NOT_CHECKABLE_HINT.replace(/^not checkable mechanically — /, "")}`
+    );
+    for (const r of notCheckable)
+      io.out(`${ruleHead(r)}${r.rule.silenced ? "  [marked none]" : ""}`);
+  }
+  io.out("");
+  if (v.enforceable > 0)
+    io.out(
+      `Enforce: agentguard audit --enforce   writes ${plural(v.enforceable, "rule")} into agentguard.yaml as hook rules, in dry-run (nothing is blocked until hooks.mode: enforce)`
+    );
+  io.out(TEAM_HISTORY_LINE);
+}
+async function enforce(args, io, rules, policyPath, checkout, json) {
+  const plan = planEnforcement(rules);
+  const preview = flagBool(args, "preview") === true;
+  const edit = applyEnforcePlan(policyPath, plan);
+  const diff = lineDiff(edit.before, edit.after);
+  const changed = edit.before !== edit.after;
+  const blocked = edit.mode === "enforce" && flagBool(args, "yes") !== true;
+  const write = changed && !preview && !blocked;
+  if (write) writeFileSync2(policyPath, edit.after);
+  const home = homeFrom(io);
+  const installed = ["project", "user"].some((scope) => {
+    try {
+      return installedHandlers(hookTarget("claude-code", scope, { cwd: checkout, home }, "")).length > 0;
+    } catch {
+      return true;
+    }
+  });
+  let hookInstalled = installed;
+  const hookOut = [];
+  if (!installed && !preview && !blocked) {
+    const sub = { ...io, cwd: checkout, out: (l) => hookOut.push(l) };
+    const passthrough = ["hooks", "install"];
+    const config = flagString(args, "config");
+    if (config) passthrough.push("--config", resolve3(io.cwd, config));
+    const command = flagString(args, "command");
+    if (command) passthrough.push("--command", command);
+    await hooksCommand(parseArgs(passthrough), sub);
+    hookInstalled = true;
+  }
+  if (json) {
+    io.out(
+      JSON.stringify(
+        {
+          policy: policyPath,
+          written: write,
+          preview,
+          hooks_mode: edit.mode,
+          added: edit.added,
+          audit_only: plan.auditOnly.map((a) => ({
+            rule: a.rule.id,
+            check: a.check.label,
+            why: a.why
+          })),
+          notes: plan.notes,
+          hook_installed: hookInstalled
+        },
+        null,
+        2
+      )
+    );
+    return blocked && changed ? 1 : 0;
+  }
+  if (!changed)
+    io.out(`agentguard.yaml already has a hook rule for every enforceable rule (${policyPath}).`);
+  else {
+    io.out(
+      `${write ? edit.created ? "wrote" : "updated" : "would update"} ${policyPath} \u2014 ${plural(edit.added.length, "hook rule")}:`
+    );
+    for (const line of diff) io.out(`  ${line}`);
+  }
+  if (plan.auditOnly.length > 0) {
+    io.out("");
+    io.out("Audit only (a pre-execution hook cannot check these):");
+    for (const a of plan.auditOnly) io.out(`  R${a.rule.n} ${a.check.label} \u2014 ${a.why}`);
+  }
+  if (plan.notes.length > 0) {
+    io.out("");
+    for (const n of plan.notes) io.out(`note: ${n}`);
+  }
+  io.out("");
+  if (blocked && changed) {
+    io.out(
+      "hooks.mode is enforce in this agentguard.yaml, so these rules would block at once. Nothing was written. Rerun with --enforce --yes to add them anyway, or set hooks.mode: dry-run first."
+    );
+    return 1;
+  }
+  if (preview) {
+    io.out("Preview only: nothing was written. Run agentguard audit --enforce to write it.");
+    return 0;
+  }
+  for (const l of hookOut) io.out(l);
+  if (installed) io.out("The agentguard hook is already installed (agentguard hooks status).");
+  io.out(
+    `hooks.mode is ${edit.mode}: ${edit.mode === "dry-run" ? "every decision is logged and nothing is blocked. Read agentguard report, then set hooks.mode: enforce yourself." : "the rules apply from the next session."}`
+  );
+  return 0;
+}
+
+export {
+  TEAM_HISTORY_URL,
+  TEAM_HISTORY_LINE,
+  parseSince,
+  auditCommand
+};
+//# sourceMappingURL=chunk-6S7LYVOC.js.map