@aaac/runtime 0.2.5 → 0.2.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (42) hide show
  1. package/dist/adapters/adk-sdk.d.ts +1 -1
  2. package/dist/adapters/adk-sdk.js +1 -1
  3. package/dist/adapters/claude-agent-sdk.d.ts +1 -1
  4. package/dist/adapters/claude-agent-sdk.js +4 -1
  5. package/dist/adapters/claude-agent-sdk.js.map +1 -1
  6. package/dist/adapters/openai-agents-sdk.d.ts +1 -1
  7. package/dist/adapters/openai-agents-sdk.js +1 -1
  8. package/dist/{chunk-3DDB34BU.js → chunk-D2UXESPT.js} +2 -2
  9. package/dist/chunk-D2UXESPT.js.map +1 -0
  10. package/dist/{chunk-MG2ULUX6.js → chunk-DEBCJKRX.js} +2 -2
  11. package/dist/{chunk-2INQL5TG.js → chunk-GWNXNSGL.js} +6 -5
  12. package/dist/chunk-GWNXNSGL.js.map +1 -0
  13. package/dist/{chunk-MSVIEEGR.js → chunk-HR2Q64AO.js} +29 -5
  14. package/dist/chunk-HR2Q64AO.js.map +1 -0
  15. package/dist/{chunk-FKAI54OM.js → chunk-QVMLALPF.js} +2 -2
  16. package/dist/{chunk-F5R46S7I.js → chunk-Y7NORFFM.js} +2 -2
  17. package/dist/claude-bundles/full.js +134 -133
  18. package/dist/claude-bundles/lean.js +5 -4
  19. package/dist/generator/index.d.ts +2 -2
  20. package/dist/generator/index.js +2 -2
  21. package/dist/{guardrail-hooks-CB23nhZV.d.ts → guardrail-hooks-B-qe4ebW.d.ts} +16 -3
  22. package/dist/{hook-protocol-CFnNudiV.d.ts → hook-protocol-BH86kCQB.d.ts} +2 -0
  23. package/dist/{hooks-lite-CoWWnCRH.d.ts → hooks-lite-DvZu9Jhx.d.ts} +2 -2
  24. package/dist/{index-BlSepCSZ.d.ts → index-C2DHitGz.d.ts} +9 -1
  25. package/dist/index.d.ts +5 -5
  26. package/dist/index.js +27 -8
  27. package/dist/index.js.map +1 -1
  28. package/dist/lib/claude-native/hooks-lite.d.ts +3 -3
  29. package/dist/lib/claude-native/hooks-lite.js +3 -3
  30. package/dist/lib/claude-native/hooks-prompt.d.ts +4 -4
  31. package/dist/lib/claude-native/hooks-prompt.js +3 -3
  32. package/dist/lib/claude-native/index.d.ts +7 -7
  33. package/dist/lib/claude-native/index.js +6 -6
  34. package/dist/{navigation-context-B-RpUg3_.d.ts → navigation-context-D1NbiipT.d.ts} +1 -1
  35. package/dist/{workspace-user-prompt-submit-D11Iu0zO.d.ts → workspace-user-prompt-submit-aErGPoX4.d.ts} +2 -2
  36. package/package.json +4 -4
  37. package/dist/chunk-2INQL5TG.js.map +0 -1
  38. package/dist/chunk-3DDB34BU.js.map +0 -1
  39. package/dist/chunk-MSVIEEGR.js.map +0 -1
  40. /package/dist/{chunk-MG2ULUX6.js.map → chunk-DEBCJKRX.js.map} +0 -0
  41. /package/dist/{chunk-FKAI54OM.js.map → chunk-QVMLALPF.js.map} +0 -0
  42. /package/dist/{chunk-F5R46S7I.js.map → chunk-Y7NORFFM.js.map} +0 -0
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["../src/lib/command-body-files.ts","../src/lib/guardrail-hooks.ts"],"sourcesContent":["/**\n * The text a command guardrail scans for a shell command: the command itself,\n * plus the contents of any message body it passes by file.\n *\n * `gh pr create --body-file body.md`, `gh issue comment -F body.md`,\n * `gh release create --notes-file notes.md` and `git commit -F msg.txt` carry\n * the same text a heredoc would put on the command line. Scanning only the\n * command string let a rule that stops the heredoc form pass the file form.\n *\n * Only a plain path is resolved — bare, or wrapped whole in one pair of quotes.\n * `-` (stdin), a path built from a variable, and anything that is not a regular\n * file (a FIFO would block the hook) are left out, and the command string alone\n * is what gets scanned for them, as before. The file text is joined on a new\n * line, so a pattern's `.` never spans the command and the body, and a pattern\n * anchored at `^` still means the start of the command.\n */\nimport { readFileSync, statSync } from \"node:fs\";\nimport { resolve } from \"node:path\";\n\nconst BODY_FILE_FLAG =\n /(?:^|\\s)(?:--body-file|--notes-file|--file|-F)(?:=|\\s+)(?:'([^']*)'|\"([^\"]*)\"|([^\\s;|&]+))/g;\n\nexport function commandScanText(command: string, cwd?: string): string {\n const bodies: string[] = [];\n for (const match of command.matchAll(BODY_FILE_FLAG)) {\n const path = match[1] ?? match[2] ?? match[3];\n if (!path || path === \"-\") continue;\n const absPath = resolve(cwd ?? process.cwd(), path);\n try {\n if (!statSync(absPath).isFile()) continue;\n bodies.push(readFileSync(absPath, \"utf8\"));\n } catch {\n continue;\n }\n }\n return bodies.length === 0 ? command : [command, ...bodies].join(\"\\n\");\n}\n","/**\n * SDK Guardrail Hook Bridge — generic adapter from guardrail check functions to\n * SDK-compatible hook responses.\n *\n * Embedded guardrail rules are converted via createGuardrailHooksFromRules(),\n * which delegates to createGuardrailHooks(). All hook logic lives here.\n *\n * Every check this module runs arrives as an ARGUMENT. It has no ambient\n * source: it does not know what a plugin is, and it reaches for no registry, so\n * what a route enforces is decided by that route and is readable at its call\n * site. This is also what keeps the module light enough to sit on the lean\n * hot-path graph — see `PluginRegistry.guardrailChecks` for the measurement and\n * for which layer supplies the plugin source.\n */\n\nimport { commandScanText } from \"./command-body-files.js\";\n\n/**\n * Enforcement action of a guardrail.\n *\n * `block` / `warn` / `shadow` / `info` are DECLARED by the active guardrail\n * policy. `unresolved` is not an enforcement level a policy can declare: it is\n * the state of a guardrail that has a binding implementation while the active\n * policy declares no action for it (no `active_guardrail_policy` in the project\n * manifest, an unknown policy name, or a policy with no rule for the guardrail).\n *\n * An unresolved guardrail DENIES — see `getBlockingViolations`. Substituting a\n * permissive default here is what turned every `action: block` guardrail in a\n * policy-less project into a no-op while the guardrail cache still listed it\n * (#293); the action is not knowable, so the operation the guardrail covers is\n * refused and the message says how to fix the manifest.\n *\n * ONE declaration for the set, so the type and the check `isGuardrailRuleData`\n * performs cannot name different ones — a bare union has nothing a predicate\n * can read, and the rules cross a process boundary as JSON.\n */\nexport const GUARDRAIL_ACTIONS = [\n \"block\",\n \"warn\",\n \"shadow\",\n \"info\",\n \"unresolved\",\n] as const;\n\nexport type GuardrailAction = (typeof GUARDRAIL_ACTIONS)[number];\n\n/** The action of a guardrail whose active policy declares none (see GuardrailAction). */\nexport const UNRESOLVED_GUARDRAIL_ACTION = \"unresolved\" as const;\n\nexport interface GuardrailCheckResult {\n guardrail_id: string;\n passed: boolean;\n action: GuardrailAction;\n message: string;\n}\n\n/**\n * What a guardrail hook answers.\n *\n * A refusal CARRIES ITS MESSAGE — one fact, not two independently optional\n * ones. Declared as separate optionals, every consumer had to supply a value\n * for a case no producer can reach (`beforeShellExecution`, `preToolUse` and\n * `afterFileEdit` all refuse through `denyResponse`, which always writes one),\n * and they supplied three different ones: two hand-written copies of \"Command\n * blocked by guardrail\" in the PreToolUse routes and a fall-back to\n * `agent_message` in the SDK adapter (#311). Nothing rejected a fourth, and\n * nothing noticed when one of them drifted, because a string literal that\n * disagrees with another string literal is not a type error.\n *\n * So the union states what the producer already guarantees, and the question\n * disappears instead of being answered in more places.\n */\nexport type HookResponse =\n | {\n permission: \"deny\";\n /** Every blocking violation, rendered. Never empty — a refusal has a cause. */\n user_message: string;\n agent_message: string;\n additionalContext?: undefined;\n }\n | {\n permission?: undefined;\n user_message?: undefined;\n agent_message?: undefined;\n /** Violations to surface to the agent without refusing. */\n additionalContext?: string;\n };\n\nexport interface GuardrailRule {\n guardrail_id: string;\n pattern: string;\n action: GuardrailAction;\n message: string;\n file_glob?: string;\n exclude_glob?: string;\n}\n\nexport interface GuardrailRuleData {\n commandRules: GuardrailRule[];\n fileRules: GuardrailRule[];\n contentRules: GuardrailRule[];\n}\n\nfunction isGuardrailRule(value: unknown): value is GuardrailRule {\n if (typeof value !== \"object\" || value === null) return false;\n const rule = value as Record<string, unknown>;\n return (\n typeof rule.guardrail_id === \"string\" &&\n typeof rule.pattern === \"string\" &&\n GUARDRAIL_ACTIONS.includes(rule.action as GuardrailAction) &&\n typeof rule.message === \"string\" &&\n (rule.file_glob === undefined || typeof rule.file_glob === \"string\") &&\n (rule.exclude_glob === undefined || typeof rule.exclude_glob === \"string\")\n );\n}\n\n/**\n * The single gate in front of {@link GuardrailRuleData}, next to the type it\n * grants — the rules are written to a cache file by one process and read back by\n * another, so the reader has only bytes and this predicate is what turns them\n * into rules the PreToolUse guard may run.\n *\n * Every declared field is checked, `action` against {@link GUARDRAIL_ACTIONS} —\n * the rules decide whether an operation is refused, so a rule carrying an action\n * the evaluator does not implement is not one this guard may run.\n */\nexport function isGuardrailRuleData(value: unknown): value is GuardrailRuleData {\n if (typeof value !== \"object\" || value === null) return false;\n const data = value as Record<string, unknown>;\n return (\n Array.isArray(data.commandRules) &&\n data.commandRules.every(isGuardrailRule) &&\n Array.isArray(data.fileRules) &&\n data.fileRules.every(isGuardrailRule) &&\n Array.isArray(data.contentRules) &&\n data.contentRules.every(isGuardrailRule)\n );\n}\n\nexport interface GuardrailCheckFunctions {\n checkCommand: (command: string) => GuardrailCheckResult[];\n checkFilePath: (filePath: string) => GuardrailCheckResult[];\n checkContent: (filePath: string, content: string) => GuardrailCheckResult[];\n}\n\nfunction globFragmentToRegex(fragment: string): string {\n let out = \"\";\n for (const ch of fragment) {\n if (ch === \"*\") out += \"[^/]*\";\n else if (ch === \"?\") out += \"[^/]\";\n else if (\".+^$|()[]\\\\\".includes(ch)) out += \"\\\\\" + ch;\n else out += ch;\n }\n return out;\n}\n\n/**\n * A pattern ending in `/` denotes a DIRECTORY and matches everything under it\n * (#262). This is the dominant style in artifact `path_patterns` — the embedded\n * dev-team DSL (`src/`, `lib/`, `tests/`, `.cursor/rules/`) and every\n * artifact-contracts registry rely on it. Without this, such a pattern compiles\n * to `^src/$`, which no file path can ever equal, so path → artifact reverse\n * lookup silently matched nothing and the artifact edit guard never fired.\n *\n * The rewrite is monotonic: file paths never end in `/`, so a pattern that\n * matched something before still matches exactly the same paths.\n */\nfunction expandDirectoryPattern(pattern: string): string {\n return pattern.endsWith(\"/\") ? `${pattern}**` : pattern;\n}\n\nexport function matchGlob(rawPattern: string, path: string): boolean {\n const pattern = expandDirectoryPattern(rawPattern);\n let regex = \"\";\n let i = 0;\n while (i < pattern.length) {\n if (pattern[i] === \"*\" && pattern[i + 1] === \"*\" && pattern[i + 2] === \"/\") {\n regex += \"(?:.+/)?\";\n i += 3;\n } else if (pattern[i] === \"*\" && pattern[i + 1] === \"*\") {\n regex += \".*\";\n i += 2;\n } else if (pattern[i] === \"*\") {\n regex += \"[^/]*\";\n i += 1;\n } else if (pattern[i] === \"?\") {\n regex += \"[^/]\";\n i += 1;\n } else if (pattern[i] === \"{\") {\n const end = pattern.indexOf(\"}\", i);\n if (end !== -1) {\n const alts = pattern.slice(i + 1, end).split(\",\").map(globFragmentToRegex);\n regex += \"(?:\" + alts.join(\"|\") + \")\";\n i = end + 1;\n } else {\n regex += \"\\\\{\";\n i += 1;\n }\n } else if (\".+^$|()[]\\\\\".includes(pattern[i])) {\n regex += \"\\\\\" + pattern[i];\n i += 1;\n } else {\n regex += pattern[i];\n i += 1;\n }\n }\n return new RegExp(\"^\" + regex + \"$\").test(path);\n}\n\n/**\n * Does this tool-input key name a file the call acts on?\n *\n * Derived from the naming convention rather than from a census of today's\n * tools. `NotebookEdit` calls its target `notebook_path`, so a reader that knew\n * only `file_path`/`path` classified that call correctly and then judged\n * nothing — the artifact guard was reached and found no path to protect (#309).\n * Every such key so far ends in `path`, so the rule follows the suffix and the\n * next tool to name an `output_path` is already covered.\n *\n * `file` / `filename` carry no suffix; they are the SDK progress-event\n * spellings the task runner reads, and are named for that reason.\n */\nfunction namesTargetFile(key: string): boolean {\n return (\n key === \"path\" || key === \"file\" || key === \"filename\" || key.endsWith(\"_path\")\n );\n}\n\n/**\n * Does this tool-input key carry text the call is about to WRITE?\n *\n * The same convention rule as `namesTargetFile`, over the other half of a file\n * edit. `Write` calls it `content`; `Edit` and `NotebookEdit` prefix the value\n * they are installing with `new_` (`new_string`, `new_source`), so the rule\n * follows the prefix and a tool that arrives naming a `new_text` is covered.\n *\n * The exclusions are the point. `old_string` is the text being REMOVED, and\n * scanning it would refuse the very edit that takes a forbidden string OUT of a\n * file — a content guardrail that fights its own repair. `file_path` and the\n * `cell_id` / `edit_mode` sort of parameter are neither. So \"everything the\n * payload happens to hold\" is not an available answer; the key has to say it is\n * the incoming value.\n */\nfunction namesPendingContent(key: string): boolean {\n return key === \"content\" || key.startsWith(\"new_\");\n}\n\n/**\n * The first non-empty string value under a key `names` accepts, or `\"\"`.\n *\n * Keys are scanned in sorted order, so the answer cannot depend on the order a\n * payload happened to serialize its properties in.\n *\n * Reads TOP-LEVEL string values only, and returns the first match: a payload\n * carrying its files in an array (`file_paths`) or nested (`edits[].new_string`)\n * is not covered, and no built-in has that shape today (#309).\n */\nfunction firstStringValue(\n toolInput: Record<string, unknown> | undefined | null,\n names: (key: string) => boolean,\n): string {\n if (!toolInput) return \"\";\n for (const key of Object.keys(toolInput).sort()) {\n if (!names(key)) continue;\n const value = toolInput[key];\n if (typeof value === \"string\" && value) return value;\n }\n return \"\";\n}\n\n/**\n * The file a tool call names as its target, or `\"\"` when it names none.\n *\n * ONE reader for every consumer that asks \"which file is this call about\": the\n * `preToolUse` file guardrails below, both Claude Code PreToolUse routes, the\n * `guard evaluate` CLI, the Claude SDK adapter and the task runner's\n * `process.edit` events. They had four spellings of it between them, agreeing\n * on `file_path` and diverging after — and a reader that knows fewer keys than\n * the tool writes turns a guard that runs into a guard that decides nothing.\n *\n * Scope is a TOOL INPUT. The after-file-edit payloads (`afterFileEdit` here,\n * the Cursor hook input in `guard-commands`) are not tool inputs: their\n * `file_path` is a top-level protocol field and is the whole interface.\n */\nexport function toolTargetPath(\n toolInput: Record<string, unknown> | undefined | null,\n): string {\n return firstStringValue(toolInput, namesTargetFile);\n}\n\n/**\n * Claude Code tools that cannot modify a file in the working tree — the ONLY\n * calls a `file_glob` / `content_regex` guardrail lets past unexamined.\n *\n * This list is inverted on purpose. Naming the tools to guard (`Edit`, `Write`,\n * `MultiEdit`) meant the guard covered exactly the tools that existed when it\n * was written, and `NotebookEdit` — a first-party file editor — walked through\n * a `manual_edit: forbidden` artifact for as long as it has existed (#309).\n * Every future tool would have arrived the same way, silently, because a name\n * that is missing from an allowlist looks identical to a name that is absent\n * for a reason.\n *\n * Naming the tools NOT to guard puts the staleness on the harmless side. An\n * unrecognised tool is judged instead of waved through, and being judged costs\n * it nothing unless it names a covered file: `toolTargetPath` reads the file out\n * of the call, so a tool that targets no file resolves to nothing and is\n * allowed. \"Deny by default\" here therefore means \"examined by default\", not\n * \"refused by default\" — a new Claude Code release does not lock the session\n * down.\n *\n * Every name is a Claude Code built-in, pinned against an independent\n * transcription of the tool reference in `__tests__/fixtures/`.\n */\nexport const NON_MUTATING_TOOLS: ReadonlySet<string> = new Set([\n // Name a path in their input and only ever read it.\n \"Read\",\n \"Glob\",\n \"Grep\",\n \"LSP\",\n // Load or delegate: whatever they set in motion arrives at the same guard as\n // its own tool call, and is guarded there.\n \"Task\",\n \"Agent\",\n \"Skill\",\n // Reach outside the working tree entirely.\n \"WebFetch\",\n \"WebSearch\",\n // Session-local state rather than files.\n \"TodoWrite\",\n \"AskUserQuestion\",\n \"ToolSearch\",\n \"EnterPlanMode\",\n \"ExitPlanMode\",\n]);\n\n/**\n * The file this call may WRITE, or `\"\"` when there is none.\n *\n * ONE answer to \"which operations do the file guards cover\", for every route:\n * the `preToolUse` gate below, both Claude Code PreToolUse routes (through\n * `artifactGuardTarget`), the `guard evaluate` CLI and the Claude SDK adapter.\n *\n * `file_glob` and `content_regex` guard WRITES. That is not a reading of what\n * the matcher could mean — it is what every rule declared against it says:\n * across `agents/bindings/runtime.yaml`, `examples/governance/bindings/runtime.yaml`\n * and the bindings `aaac init` bootstraps a new project with, all 19 messages\n * are \"Writing to … is blocked\", \"Generated files must not be hand-edited\" or\n * \"Do not write … at repo root\". None is about reading one. So a guard that\n * refused `Read` would refuse an operation no rule in this repo asks it to, and\n * `protect-generated-files` — `action: block` under the default policy — would\n * stop an agent reading the generated code it has to read to work.\n *\n * Answering it HERE rather than in the hook is what keeps the routes on one\n * verdict. Answered per-consumer, it went two ways immediately: the workspace\n * PreToolUse route filtered by this set and the single-component one did not, so\n * the same `Read secrets/prod.env` was allowed by one and refused by the other\n * (#316).\n */\nexport function toolWriteTarget(\n toolName: string | undefined,\n toolInput: Record<string, unknown> | undefined | null,\n): string {\n if (NON_MUTATING_TOOLS.has(toolName ?? \"\")) return \"\";\n return toolTargetPath(toolInput);\n}\n\n/**\n * The text a tool call is about to write into `toolTargetPath`, or `\"\"`.\n *\n * The companion reader, and the reason `content_regex` guardrails are decided\n * BEFORE the write rather than reported after it. Claude Code hands PreToolUse\n * the tool's parameters in full, so the pending content is already in the\n * payload; the only event that could carry it afterwards is PostToolUse, whose\n * `block` cannot un-write the file and would answer the same declared\n * `action: block` differently from every other route (#316).\n */\nexport function toolPendingContent(\n toolInput: Record<string, unknown> | undefined | null,\n): string {\n return firstStringValue(toolInput, namesPendingContent);\n}\n\n/**\n * What one check is asked about: a command, a path, or a path and the content\n * about to go into it. Nothing here names an AGENT.\n *\n * Which rules an agent is checked against is settled before an evaluator\n * exists, by the layer that knows where rules come from — see\n * `createAgentGuardrailHooks` in `execute.ts`, the one constructor of per-agent\n * hooks. An agent id travelling inside the context would mean that same\n * question could also be answered later, from in here, and it did: a second\n * per-agent constructor exported beside that one wrote `agentId` on every\n * context it forwarded, no gate read it, and the two disagreed on memoisation\n * and on what an agent with no rules gets (#333).\n *\n * So the field is gone, and an OBJECT LITERAL naming an agent is now TS2353 —\n * which is what makes that constructor un-pasteable verbatim.\n * `adapter-guardrail-hooks.test.ts` pins the absence with a `@ts-expect-error`\n * that turns into TS2578 if the field returns.\n *\n * That is the whole of what the type says, and it is less than it sounds.\n * Excess-property checking reaches object literals only: an `as HookContext`\n * cast, an interface that extends this one, a literal bound to a variable\n * first, and a plain `Record<string, unknown>` all compile — measured, not\n * assumed. And a second per-agent constructor that simply never writes an agent\n * id needs none of them and compiles as it is. What is removed here is the\n * AFFORDANCE the duplicate happened to use, not the possibility of another one.\n * The invariant — ONE constructor of per-agent hooks — is held by the\n * declaration on `createAgentGuardrailHooks` and by reading it, and nothing\n * mechanical will fail if it is broken.\n */\nexport interface HookContext {\n command?: string;\n filePath?: string;\n content?: string;\n}\n\n/**\n * The guardrail gates, one per payload SHAPE — not one per rule kind.\n *\n * Which gate a caller picks is decided by what it holds, never by which rules\n * it wants consulted: every gate runs every rule the context can answer. An\n * object with four methods hid the opposite for as long as this existed — the\n * Claude Code PreToolUse route called `beforeShellExecution` and nothing else,\n * so a project's `file_glob` and `content_regex` guardrails were enforced by\n * `guard evaluate` and by the SDK adapter while the session a person actually\n * works in never consulted them, and no type or single-route test could say so\n * (#316).\n */\n/**\n * A shell command about to run, and the directory it runs in — which resolves a\n * message body the command passes by file (`commandScanText`). Without `cwd`\n * the hook process's own directory is used.\n */\nexport interface ShellCommandInput {\n command?: string;\n cwd?: string;\n}\n\nexport interface GuardrailHooks {\n /** A command about to run. Claude Code PreToolUse (both routes), `guard evaluate`. */\n beforeShellExecution: (input: ShellCommandInput) => HookResponse;\n /**\n * The checks {@link GuardrailHooks.beforeShellExecution} decides on — the\n * command plus any body it passes by file. `guard evaluate` reports these, so\n * the list it prints is the one its verdict came from.\n */\n checkShellCommand: (input: ShellCommandInput) => GuardrailCheckResult[];\n /**\n * A TOOL INPUT, verbatim: `toolTargetPath` reads the file out of it and\n * `toolPendingContent` the text about to go in. The single-component Claude\n * Code PreToolUse route, `guard evaluate` and the Claude SDK adapter.\n */\n preToolUse: (input: {\n tool_name?: string;\n tool_input?: Record<string, unknown>;\n }) => HookResponse;\n /**\n * A file write whose path and content the caller has ALREADY extracted —\n * Cursor's after-file-edit event, where both are top-level protocol fields,\n * and the workspace Claude Code PreToolUse route, which must ask about the\n * member-repo-relative path (`stripMemberPrefix`) rather than the one the\n * tool named, because member guardrail patterns are written in that space.\n */\n afterFileEdit: (input: { file_path?: string; content?: string }) => HookResponse;\n /** The shared check runner. Not a gate: `getBlockingViolations` is what refuses. */\n runChecks: (ctx: HookContext) => GuardrailCheckResult[];\n}\n\n/**\n * Does this action refuse the operation? `block` because the policy says so,\n * `unresolved` because the policy says nothing and a guardrail whose action is\n * unknown must not be permissive (#293). Single definition — every deny gate\n * (shell / pre-tool-use / after-file-edit hooks, `guard evaluate`'s exit code,\n * the OpenAI Agents SDK tripwire) reads it through `getBlockingViolations`.\n */\nfunction isDenyAction(action: GuardrailAction): boolean {\n return action === \"block\" || action === UNRESOLVED_GUARDRAIL_ACTION;\n}\n\nexport function getBlockingViolations(results: GuardrailCheckResult[]): GuardrailCheckResult[] {\n return results.filter((r) => !r.passed && isDenyAction(r.action));\n}\n\nexport function getWarnings(results: GuardrailCheckResult[]): GuardrailCheckResult[] {\n return results.filter((r) => !r.passed && r.action === \"warn\");\n}\n\nexport function hasBlockingViolation(results: GuardrailCheckResult[]): boolean {\n return getBlockingViolations(results).length > 0;\n}\n\n/**\n * How a guardrail violation reads: `[guardrail-id] message`, one per line.\n *\n * Single definition — the shell, pre-tool-use and after-file-edit hooks all\n * refuse in the same words, a warning reads the same as the refusal it would\n * have been under a stricter policy, and the ADK adapter throws the same text\n * where it has no hook response to return. Exported for that last one only:\n * not re-exported from the package barrel, because no consumer outside this\n * runtime renders a violation.\n */\nexport function renderViolations(results: GuardrailCheckResult[]): string {\n return results.map((r) => `[${r.guardrail_id}] ${r.message}`).join(\"\\n\");\n}\n\n/**\n * The refusal every guardrail hook returns.\n *\n * The message is written HERE, once, rather than at each of the three hooks —\n * that is what makes `HookResponse`'s \"a denial carries its message\" a fact\n * about the code and not a convention. `user_message` and `agent_message` are\n * the same text on purpose: the agent is told exactly what the user is told.\n */\nfunction denyResponse(blocks: GuardrailCheckResult[]): HookResponse {\n const message = renderViolations(blocks);\n return { permission: \"deny\", user_message: message, agent_message: message };\n}\n\n/**\n * Create SDK hook functions from guardrail check functions.\n *\n * Returns hook functions in the format expected by the Claude SDK, plus a\n * generic runChecks() for programmatic use.\n *\n * Takes any number of check SOURCES and asks every one of them every question\n * the context can answer — which is the same rule `GuardrailHooks` states about\n * its gates, one level down. A source is not a rule kind and not a route: it is\n * one supplier of checks, and the hooks it produces cannot tell which supplier a\n * verdict came from. That is what lets a second supplier be added (the execution\n * layer adds the process's plugin guardrails, see\n * `PluginRegistry.guardrailChecks`) without there being a second EVALUATOR —\n * the property #304 and #316 exist to hold.\n *\n * Ordering is by question, then by source, so the sources a caller lists are\n * consulted in the order it listed them and a refusal reads the same way every\n * time (`renderViolations` joins in result order).\n *\n * Zero sources is a legitimate answer, not a degenerate one: it is what an agent\n * with no resolved rules and no plugins has, and the hooks it gets deny nothing.\n */\nexport function createGuardrailHooks(...sources: GuardrailCheckFunctions[]): GuardrailHooks {\n function runChecks(ctx: HookContext): GuardrailCheckResult[] {\n const results: GuardrailCheckResult[] = [];\n\n if (ctx.command) {\n for (const source of sources) results.push(...source.checkCommand(ctx.command));\n }\n\n if (ctx.filePath) {\n for (const source of sources) results.push(...source.checkFilePath(ctx.filePath));\n }\n\n if (ctx.filePath && ctx.content) {\n for (const source of sources) {\n results.push(...source.checkContent(ctx.filePath, ctx.content));\n }\n }\n\n return results;\n }\n\n function checkShellCommand(input: ShellCommandInput): GuardrailCheckResult[] {\n const command = input.command ?? \"\";\n if (!command) return [];\n return runChecks({ command: commandScanText(command, input.cwd) });\n }\n\n function beforeShellExecution(input: ShellCommandInput): HookResponse {\n const results = checkShellCommand(input);\n if (results.length === 0) return {};\n const blocks = getBlockingViolations(results);\n const warns = getWarnings(results);\n\n if (blocks.length > 0) {\n return denyResponse(blocks);\n }\n\n if (warns.length > 0) {\n return { additionalContext: renderViolations(warns) };\n }\n\n return {};\n }\n\n /**\n * The verdict on one file write — the ONE gate behind both file-shaped hooks\n * below, so `file_glob` and `content_regex` are decided together and cannot\n * be decided differently depending on which payload shape arrived.\n *\n * They diverged before: `preToolUse` asked `runChecks({ filePath })` and so\n * consulted `checkFilePath` alone, while `afterFileEdit` asked with the\n * content and got both. The rules a project declares are the same rules\n * either way (#316).\n */\n function fileWriteVerdict(filePath: string, content: string): HookResponse {\n if (!filePath) return {};\n\n const blocks = getBlockingViolations(runChecks({ filePath, content }));\n return blocks.length > 0 ? denyResponse(blocks) : {};\n }\n\n function preToolUse(input: {\n tool_name?: string;\n tool_input?: Record<string, unknown>;\n }): HookResponse {\n return fileWriteVerdict(\n toolWriteTarget(input.tool_name, input.tool_input),\n toolPendingContent(input.tool_input),\n );\n }\n\n function afterFileEdit(input: { file_path?: string; content?: string }): HookResponse {\n return fileWriteVerdict(input.file_path ?? \"\", input.content ?? \"\");\n }\n\n return { beforeShellExecution, checkShellCommand, preToolUse, afterFileEdit, runChecks };\n}\n\n/** Compile a guardrail regex pattern, supporting inline `(?i)` case-insensitivity prefix. */\nexport function compileGuardrailPattern(pattern: string): RegExp {\n if (pattern.startsWith(\"(?i)\")) {\n return new RegExp(pattern.slice(4), \"i\");\n }\n return new RegExp(pattern);\n}\n\n/**\n * Create SDK hook functions from embedded guardrail rule data.\n *\n * The rules are the first check source; `extraSources` are consulted after\n * them, on every question. This is the funnel every route reaches the evaluator\n * through — both Claude Code PreToolUse routes, `guard evaluate` and the\n * execution layer — so what distinguishes those routes is visible here as an\n * argument list and nowhere else.\n */\nexport function createGuardrailHooksFromRules(\n rules: GuardrailRuleData,\n ...extraSources: GuardrailCheckFunctions[]\n): GuardrailHooks {\n const commandChecks = rules.commandRules.map((rule) => ({\n guardrail_id: rule.guardrail_id,\n pattern: compileGuardrailPattern(rule.pattern),\n action: rule.action,\n message: rule.message,\n }));\n\n const fileChecks = rules.fileRules;\n\n const contentChecks = rules.contentRules.map((rule) => ({\n guardrail_id: rule.guardrail_id,\n pattern: compileGuardrailPattern(rule.pattern),\n action: rule.action,\n message: rule.message,\n file_glob: rule.file_glob,\n exclude_glob: rule.exclude_glob,\n }));\n\n return createGuardrailHooks({\n checkCommand(command: string): GuardrailCheckResult[] {\n const results: GuardrailCheckResult[] = [];\n for (const check of commandChecks) {\n const passed = !check.pattern.test(command);\n results.push({\n guardrail_id: check.guardrail_id,\n passed,\n action: check.action,\n message: passed ? \"\" : check.message,\n });\n }\n return results;\n },\n\n checkFilePath(filePath: string): GuardrailCheckResult[] {\n const results: GuardrailCheckResult[] = [];\n for (const check of fileChecks) {\n if (check.exclude_glob && matchGlob(check.exclude_glob, filePath)) {\n continue;\n }\n const matched = matchGlob(check.pattern, filePath);\n results.push({\n guardrail_id: check.guardrail_id,\n passed: !matched,\n action: check.action,\n message: matched ? check.message : \"\",\n });\n }\n return results;\n },\n\n checkContent(filePath: string, content: string): GuardrailCheckResult[] {\n const results: GuardrailCheckResult[] = [];\n for (const check of contentChecks) {\n if (check.file_glob && !matchGlob(check.file_glob, filePath)) {\n continue;\n }\n if (check.exclude_glob && matchGlob(check.exclude_glob, filePath)) {\n continue;\n }\n const matched = check.pattern.test(content);\n results.push({\n guardrail_id: check.guardrail_id,\n passed: !matched,\n action: check.action,\n message: matched ? check.message : \"\",\n });\n }\n return results;\n },\n }, ...extraSources);\n}\n"],"mappings":"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","names":[]}
@@ -6,7 +6,7 @@ import {
6
6
  buildContextResponse,
7
7
  listArtifacts,
8
8
  readFreshNavigationBuild
9
- } from "./chunk-3DDB34BU.js";
9
+ } from "./chunk-D2UXESPT.js";
10
10
 
11
11
  // src/lib/claude-native/navigation-cache.ts
12
12
  import { spawn } from "child_process";
@@ -231,4 +231,4 @@ export {
231
231
  readFreshMemberIndices,
232
232
  createWorkspaceUserPromptSubmitHandler
233
233
  };
234
- //# sourceMappingURL=chunk-FKAI54OM.js.map
234
+ //# sourceMappingURL=chunk-QVMLALPF.js.map
@@ -1,6 +1,6 @@
1
1
  import {
2
2
  UNRESOLVED_GUARDRAIL_ACTION
3
- } from "./chunk-MSVIEEGR.js";
3
+ } from "./chunk-HR2Q64AO.js";
4
4
 
5
5
  // src/generator/context.ts
6
6
  var UNRESOLVED_GUARDRAIL_SEVERITY = "critical";
@@ -480,4 +480,4 @@ export {
480
480
  loadProjectConfig,
481
481
  loadWorkspaceMembers
482
482
  };
483
- //# sourceMappingURL=chunk-F5R46S7I.js.map
483
+ //# sourceMappingURL=chunk-Y7NORFFM.js.map