@hasna/hooks 0.2.20 → 0.3.1

package/hooks/hook-knowledge-context/src/hook.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildHookOutput,
+  buildKnowledgeArgs,
+  buildQuery,
+  extractContextText,
+  getConfig,
+  redactSecrets,
+  sanitizeQuery,
+  type KnowledgeContextConfig,
+  type KnowledgeExecutor,
+} from "./hook";
+
+const baseConfig: KnowledgeContextConfig = {
+  command: "knowledge",
+  timeoutMs: 1500,
+  maxItems: 6,
+  maxTokens: 1200,
+  maxQueryChars: 1200,
+  maxOutputChars: 8000,
+};
+
+describe("hook-knowledge-context", () => {
+  test("builds deterministic knowledge context pack args without semantic, web, or generation flags", () => {
+    const args = buildKnowledgeArgs("repo hook context", baseConfig);
+
+    expect(args).toEqual([
+      "context",
+      "pack",
+      "repo hook context",
+      "--from",
+      "search",
+      "--max-items",
+      "6",
+      "--max-tokens",
+      "1200",
+      "--json",
+    ]);
+    expect(args).not.toContain("--semantic");
+    expect(args).not.toContain("--generate");
+    expect(args).not.toContain("web");
+    expect(args).not.toContain("ask");
+    expect(args).not.toContain("build");
+  });
+
+  test("emits Codewith additionalContext for SessionStart", async () => {
+    const executor: KnowledgeExecutor = async () => ({
+      ok: true,
+      stdout: JSON.stringify({ context: "Use hooks.json for Codewith lifecycle hooks." }),
+    });
+
+    const output = await buildHookOutput(
+      {
+        hook_event_name: "SessionStart",
+        cwd: "/repo",
+        source: "startup",
+        model: "gpt-test",
+      },
+      executor
+    );
+
+    expect(output.continue).toBe(true);
+    expect(output.hookSpecificOutput?.hookEventName).toBe("SessionStart");
+    expect(output.hookSpecificOutput?.additionalContext).toContain("knowledge context pack --from search");
+    expect(output.hookSpecificOutput?.additionalContext).toContain("Use hooks.json");
+  });
+
+  test("emits event-matched additionalContext for UserPromptSubmit and redacts query secrets", async () => {
+    let capturedQuery = "";
+    const executor: KnowledgeExecutor = async (query) => {
+      capturedQuery = query;
+      return {
+        ok: true,
+        stdout: JSON.stringify({
+          items: [{ title: "Decision", text: "Prefer deterministic context packs. secret=demo" }],
+        }),
+      };
+    };
+
+    const output = await buildHookOutput(
+      {
+        hook_event_name: "UserPromptSubmit",
+        cwd: "/repo",
+        prompt: "implement this with token=demo",
+      },
+      executor
+    );
+
+    expect(output.hookSpecificOutput?.hookEventName).toBe("UserPromptSubmit");
+    expect(output.hookSpecificOutput?.additionalContext).toContain("Prefer deterministic context packs");
+    expect(output.hookSpecificOutput?.additionalContext).toContain("secret=<redacted>");
+    expect(output.hookSpecificOutput?.additionalContext).not.toContain("secret=demo");
+    expect(capturedQuery).toContain("token=<redacted>");
+    expect(capturedQuery).not.toContain("token=demo");
+  });
+
+  test("emits event-matched additionalContext for SubagentStart", async () => {
+    const executor: KnowledgeExecutor = async () => ({
+      ok: true,
+      stdout: JSON.stringify({ data: { markdown: "Subagents inherit parent scope and should stay bounded." } }),
+    });
+
+    const output = await buildHookOutput(
+      {
+        hook_event_name: "SubagentStart",
+        cwd: "/repo",
+        agent_type: "verifier",
+        turn_id: "turn-1",
+      },
+      executor
+    );
+
+    expect(output.hookSpecificOutput?.hookEventName).toBe("SubagentStart");
+    expect(output.hookSpecificOutput?.additionalContext).toContain("Subagents inherit parent scope");
+  });
+
+  test("fails open without context on executor error, timeout, or invalid JSON", async () => {
+    const failed = await buildHookOutput({ hook_event_name: "SessionStart", cwd: "/repo" }, async () => ({ ok: false }));
+    const timedOut = await buildHookOutput(
+      { hook_event_name: "SessionStart", cwd: "/repo" },
+      async () => ({ ok: false, timedOut: true })
+    );
+    const invalidJson = await buildHookOutput(
+      { hook_event_name: "SessionStart", cwd: "/repo" },
+      async () => ({ ok: true, stdout: "not json" })
+    );
+
+    expect(failed).toEqual({ continue: true });
+    expect(timedOut).toEqual({ continue: true });
+    expect(invalidJson).toEqual({ continue: true });
+  });
+
+  test("fails open for disabled or unsupported events", async () => {
+    const executor: KnowledgeExecutor = async () => {
+      throw new Error("executor should not run");
+    };
+
+    expect(
+      await buildHookOutput({ hook_event_name: "PostToolUse", cwd: "/repo" }, executor)
+    ).toEqual({ continue: true });
+    expect(
+      await buildHookOutput({ hook_event_name: "SessionStart", cwd: "/repo" }, executor, {
+        HOOKS_KNOWLEDGE_CONTEXT_DISABLE: "1",
+      })
+    ).toEqual({ continue: true });
+  });
+
+  test("sanitizes and bounds queries", () => {
+    expect(redactSecrets("password=hunter2 token=demo")).toBe(
+      "password=<redacted> token=<redacted>"
+    );
+    expect(sanitizeQuery("a\nb\tc", 100)).toBe("a b c");
+    expect(sanitizeQuery("word ".repeat(200), 20).length).toBeLessThanOrEqual(20);
+  });
+
+  test("builds event-specific queries and extracts common context pack shapes", () => {
+    const config = getConfig({});
+
+    expect(buildQuery({ hook_event_name: "SessionStart", cwd: "/repo", source: "resume" }, config)).toContain(
+      "session start"
+    );
+    expect(buildQuery({ hook_event_name: "SubagentStart", cwd: "/repo", agent_type: "reviewer" }, config)).toContain(
+      "subagent start"
+    );
+    expect(extractContextText({ pack: { context: "direct context" } })).toBe("direct context");
+    expect(extractContextText([{ title: "One", text: "Body", uri: "knowledge://item/one" }])).toContain("Body");
+  });
+});

package/hooks/hook-knowledge-context/src/hook.ts

@@ -0,0 +1,355 @@
+#!/usr/bin/env bun
+
+/**
+ * Codewith Hook: knowledge-context
+ *
+ * Deterministically injects bounded Knowledge context into Codewith lifecycle
+ * events. This hook never calls LLM providers, semantic search, web search, or
+ * raw stores directly; it delegates to `knowledge context pack --from search`.
+ */
+
+import { readFileSync } from "fs";
+import { spawn } from "child_process";
+
+export type KnowledgeContextEvent = "SessionStart" | "UserPromptSubmit" | "SubagentStart";
+
+interface HookInput {
+  session_id?: string;
+  cwd?: string;
+  hook_event_name?: string;
+  model?: string;
+  permission_mode?: string;
+  source?: string;
+  prompt?: string;
+  user_prompt?: string;
+  agent_id?: string;
+  agent_type?: string;
+  turn_id?: string;
+}
+
+interface HookOutput {
+  continue: boolean;
+  hookSpecificOutput?: {
+    hookEventName: KnowledgeContextEvent;
+    additionalContext: string;
+  };
+}
+
+export interface KnowledgeContextConfig {
+  command: string;
+  timeoutMs: number;
+  maxItems: number;
+  maxTokens: number;
+  maxQueryChars: number;
+  maxOutputChars: number;
+}
+
+export interface KnowledgeExecResult {
+  ok: boolean;
+  stdout?: string;
+  timedOut?: boolean;
+}
+
+export type KnowledgeExecutor = (
+  query: string,
+  config: KnowledgeContextConfig
+) => Promise<KnowledgeExecResult>;
+
+const DEFAULT_TIMEOUT_MS = 1500;
+const DEFAULT_MAX_ITEMS = 6;
+const DEFAULT_MAX_TOKENS = 1200;
+const DEFAULT_MAX_QUERY_CHARS = 1200;
+const DEFAULT_MAX_OUTPUT_CHARS = 8000;
+const SUPPORTED_EVENTS = new Set<KnowledgeContextEvent>([
+  "SessionStart",
+  "UserPromptSubmit",
+  "SubagentStart",
+]);
+
+function readStdinJson(): HookInput | null {
+  try {
+    const input = readFileSync(0, "utf-8").trim();
+    if (!input) return null;
+    return JSON.parse(input);
+  } catch {
+    return null;
+  }
+}
+
+function respond(output: HookOutput): void {
+  console.log(JSON.stringify(output));
+}
+
+function boundedNumber(raw: string | undefined, fallback: number, min: number, max: number): number {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) return fallback;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+
+function commandFromEnv(raw: string | undefined): string {
+  if (raw && /^[^\s\0]+$/.test(raw)) return raw;
+  return "knowledge";
+}
+
+export function getConfig(env: NodeJS.ProcessEnv = process.env): KnowledgeContextConfig {
+  return {
+    command: commandFromEnv(env.HOOKS_KNOWLEDGE_COMMAND),
+    timeoutMs: boundedNumber(env.HOOKS_KNOWLEDGE_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, 100, 10_000),
+    maxItems: boundedNumber(env.HOOKS_KNOWLEDGE_MAX_ITEMS, DEFAULT_MAX_ITEMS, 1, 20),
+    maxTokens: boundedNumber(env.HOOKS_KNOWLEDGE_MAX_TOKENS, DEFAULT_MAX_TOKENS, 100, 8_000),
+    maxQueryChars: boundedNumber(env.HOOKS_KNOWLEDGE_MAX_QUERY_CHARS, DEFAULT_MAX_QUERY_CHARS, 80, 4_000),
+    maxOutputChars: boundedNumber(env.HOOKS_KNOWLEDGE_MAX_OUTPUT_CHARS, DEFAULT_MAX_OUTPUT_CHARS, 500, 20_000),
+  };
+}
+
+export function isKnowledgeContextEvent(value: string | undefined): value is KnowledgeContextEvent {
+  return SUPPORTED_EVENTS.has(value as KnowledgeContextEvent);
+}
+
+function stringField(input: HookInput, key: keyof HookInput): string {
+  const value = input[key];
+  return typeof value === "string" ? value : "";
+}
+
+export function redactSecrets(text: string): string {
+  let redacted = text;
+  redacted = redacted.replace(
+    /\b(api[_-]?key|token|secret|password|passwd|pwd)\b\s*[:=]\s*[^,\s]+/gi,
+    (_match, key: string) => `${key}=<redacted>`
+  );
+  redacted = redacted.replace(/\bsk-[A-Za-z0-9_-]{16,}\b/g, "<redacted>");
+  redacted = redacted.replace(/\bgh[pousr]_[A-Za-z0-9_]{20,}\b/g, "<redacted>");
+  redacted = redacted.replace(/\bxox[baprs]-[A-Za-z0-9-]{20,}\b/g, "<redacted>");
+  redacted = redacted.replace(/\bAKIA[0-9A-Z]{16}\b/g, "<redacted>");
+  redacted = redacted.replace(/\bAIza[0-9A-Za-z_-]{20,}\b/g, "<redacted>");
+  redacted = redacted.replace(/\b[A-Za-z0-9+/]{48,}={0,2}\b/g, "<redacted>");
+  return redacted;
+}
+
+export function sanitizeQuery(text: string, maxChars: number): string {
+  const normalized = text
+    .replace(/[\u0000-\u001f\u007f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  const redacted = redactSecrets(normalized);
+  return redacted.length > maxChars ? redacted.slice(0, maxChars).trim() : redacted;
+}
+
+export function buildQuery(input: HookInput, config: KnowledgeContextConfig): string | null {
+  const cwd = stringField(input, "cwd");
+  const event = stringField(input, "hook_event_name");
+
+  if (event === "UserPromptSubmit") {
+    const prompt = stringField(input, "prompt") || stringField(input, "user_prompt");
+    return sanitizeQuery(`Codewith user prompt context. cwd: ${cwd}. prompt: ${prompt}`, config.maxQueryChars);
+  }
+
+  if (event === "SubagentStart") {
+    const agentType = stringField(input, "agent_type") || "subagent";
+    const turnId = stringField(input, "turn_id");
+    return sanitizeQuery(
+      `Codewith subagent start context. cwd: ${cwd}. agent type: ${agentType}. turn: ${turnId}`,
+      config.maxQueryChars
+    );
+  }
+
+  if (event === "SessionStart") {
+    const source = stringField(input, "source") || "startup";
+    const model = stringField(input, "model");
+    return sanitizeQuery(`Codewith session start context. cwd: ${cwd}. source: ${source}. model: ${model}`, config.maxQueryChars);
+  }
+
+  return null;
+}
+
+export function buildKnowledgeArgs(query: string, config: KnowledgeContextConfig): string[] {
+  return [
+    "context",
+    "pack",
+    query,
+    "--from",
+    "search",
+    "--max-items",
+    String(config.maxItems),
+    "--max-tokens",
+    String(config.maxTokens),
+    "--json",
+  ];
+}
+
+export function spawnKnowledgeContextPack(query: string, config: KnowledgeContextConfig): Promise<KnowledgeExecResult> {
+  const args = buildKnowledgeArgs(query, config);
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    let timedOut = false;
+    let timer: ReturnType<typeof setTimeout>;
+
+    const settle = (result: KnowledgeExecResult): void => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve(result);
+    };
+
+    const child = spawn(config.command, args, {
+      stdio: ["ignore", "pipe", "ignore"],
+      env: process.env,
+    });
+
+    timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        // ignore kill errors; close/error will settle
+      }
+    }, config.timeoutMs);
+
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+      if (stdout.length > config.maxOutputChars * 2) {
+        stdout = stdout.slice(0, config.maxOutputChars * 2);
+      }
+    });
+    child.on("error", () => settle({ ok: false, timedOut }));
+    child.on("close", (code) => settle({ ok: code === 0 && !timedOut, stdout, timedOut }));
+  });
+}
+
+function firstString(obj: Record<string, unknown>, keys: string[]): string | null {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+function firstArray(obj: Record<string, unknown>, keys: string[]): unknown[] | null {
+  for (const key of keys) {
+    const value = obj[key];
+    if (Array.isArray(value)) return value;
+  }
+  return null;
+}
+
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  if (max <= 3) return text.slice(0, max);
+  return `${text.slice(0, max - 3)}...`;
+}
+
+function formatPackItems(items: unknown[]): string | null {
+  const lines: string[] = [];
+
+  for (const [index, item] of items.entries()) {
+    if (typeof item === "string" && item.trim()) {
+      lines.push(`- ${truncate(item.trim(), 900)}`);
+      continue;
+    }
+    if (!item || typeof item !== "object") continue;
+
+    const obj = item as Record<string, unknown>;
+    const title = firstString(obj, ["title", "name", "id", "ref", "uri"]) || `item ${index + 1}`;
+    const body = firstString(obj, ["summary", "text", "content", "snippet", "preview", "body"]);
+    const source = firstString(obj, ["source", "uri", "ref", "url", "citation"]);
+    if (!body && !source) continue;
+    const suffix = source ? ` (source: ${truncate(source, 180)})` : "";
+    lines.push(`- ${truncate(title, 160)}${suffix}${body ? `: ${truncate(body, 900)}` : ""}`);
+  }
+
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+
+export function extractContextText(pack: unknown): string | null {
+  if (typeof pack === "string") {
+    return pack.trim() || null;
+  }
+  if (Array.isArray(pack)) {
+    return formatPackItems(pack);
+  }
+  if (!pack || typeof pack !== "object") {
+    return null;
+  }
+
+  const obj = pack as Record<string, unknown>;
+  const direct = firstString(obj, ["additionalContext", "context", "markdown", "content", "text", "summary"]);
+  if (direct) return direct;
+
+  for (const key of ["pack", "contextPack", "context_pack", "data", "result"]) {
+    const nested = obj[key];
+    const text = extractContextText(nested);
+    if (text) return text;
+  }
+
+  const items = firstArray(obj, ["items", "results", "sources", "citations"]);
+  return items ? formatPackItems(items) : null;
+}
+
+export function formatAdditionalContext(
+  event: KnowledgeContextEvent,
+  context: string,
+  config: KnowledgeContextConfig
+): string {
+  const header = `[hook-knowledge-context] Deterministic Knowledge context (${event}; knowledge context pack --from search):`;
+  const safeContext = redactSecrets(context.trim());
+  return `${header}\n\n${truncate(safeContext, Math.max(0, config.maxOutputChars - header.length - 2))}`;
+}
+
+export async function buildHookOutput(
+  input: HookInput | null,
+  executor: KnowledgeExecutor = spawnKnowledgeContextPack,
+  env: NodeJS.ProcessEnv = process.env
+): Promise<HookOutput> {
+  if (env.HOOKS_KNOWLEDGE_CONTEXT_DISABLE === "1") {
+    return { continue: true };
+  }
+
+  if (!input) {
+    return { continue: true };
+  }
+
+  const event = input.hook_event_name;
+  if (!isKnowledgeContextEvent(event)) {
+    return { continue: true };
+  }
+
+  const config = getConfig(env);
+  const query = buildQuery(input, config);
+  if (!query) {
+    return { continue: true };
+  }
+
+  try {
+    const result = await executor(query, config);
+    if (!result.ok || !result.stdout) {
+      return { continue: true };
+    }
+
+    const parsed = JSON.parse(result.stdout);
+    const context = extractContextText(parsed);
+    if (!context) {
+      return { continue: true };
+    }
+
+    return {
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: event,
+        additionalContext: formatAdditionalContext(event, context, config),
+      },
+    };
+  } catch {
+    return { continue: true };
+  }
+}
+
+export async function run(): Promise<void> {
+  respond(await buildHookOutput(readStdinJson()));
+}
+
+if (import.meta.main) {
+  void run();
+}

package/hooks/hook-knowledge-context/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "lib": ["ESNext"],
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types", "node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/hooks/pre-bash/README.md

@@ -0,0 +1,17 @@
+# pre-bash
+
+Codewith-native hook installed as `hooks run pre-bash`.
+
+This hook is OSS-safe: optional Hasna CLIs are best-effort and missing CLIs fail open with concise warnings. Security gates only fail closed when a guarded commit/push scan runs successfully and finds possible secrets.
+
+## Install for Codewith
+
+Prefer renderer-managed configuration through open-configs. @hasna/hooks can emit the TOML fragment:
+
+```bash
+hooks install pre-bash --target codewith
+```
+
+## License
+
+Apache-2.0

package/hooks/pre-bash/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "pre-bash",
+  "version": "0.1.0",
+  "description": "Codewith-native Pre Bash hook for @hasna/hooks",
+  "type": "module",
+  "main": "./src/hook.ts",
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "author": "Hasna",
+  "license": "Apache-2.0"
+}

package/hooks/pre-bash/src/hook.ts

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+
+import {
+  commandExists,
+  gitCommandInfo,
+  getCommand,
+  isBashPreToolUse,
+  isRiskyOperation,
+  readCache,
+  readInput,
+  redactGitleaksOutput,
+  respond,
+  runCommand,
+  warn,
+  type CodewithHookInput,
+} from "../../codewith-native-common";
+
+interface SessionDigest {
+  context: string;
+  warnings: string[];
+}
+
+async function runStagedSecretsScan(cwd: string): Promise<{ block: boolean; reason?: string; warning?: string }> {
+  if (!commandExists("gitleaks")) {
+    return { block: false, warning: "gitleaks unavailable; staged secrets scan skipped fail-open." };
+  }
+
+  const result = await runCommand([
+    "gitleaks", "git", "--staged", "--no-banner", "--redact", "--report-format", "json", "--report-path", "-", ".",
+  ], { cwd, timeoutMs: 15_000 });
+
+  if (result.exitCode === 0) return { block: false };
+  if (result.exitCode === 1) {
+    return { block: true, reason: redactGitleaksOutput(result.stdout, result.stderr) };
+  }
+  return { block: false, warning: `gitleaks scan did not complete cleanly (exit ${result.exitCode ?? "unknown"}${result.timedOut ? ", timed out" : ""}); fail-open.` };
+}
+
+function riskyCommsBlock(): string | null {
+  const cached = readCache<SessionDigest>("session-start-digest", 5 * 60_000);
+  if (!cached) return null;
+  const context = cached.context || "";
+  if (/\[FREEZE\]/i.test(context)) return "Cached announcements contain a [FREEZE]. Re-check conversations before running risky operations.";
+  if (/Unread blockers JSON:\n\s*\[(?!\s*\])/i.test(context)) return "Cached conversations blockers are non-empty. Resolve or verify blockers before risky operations.";
+  if (/"message_ids"\s*:\s*\[(?!\s*\])/i.test(context) && /blockers/i.test(context)) return "Cached blocker digest appears non-empty. Re-check conversations before risky operations.";
+  return null;
+}
+
+export async function evaluate(input: CodewithHookInput): Promise<{ output: Record<string, unknown>; warnings: string[] }> {
+  const warnings: string[] = [];
+  if (!isBashPreToolUse(input)) return { output: { continue: true }, warnings };
+  const command = getCommand(input);
+  if (!command) return { output: { continue: true }, warnings };
+  const cwd = input.cwd || process.cwd();
+  const gitInfo = gitCommandInfo(command, cwd);
+
+  if (gitInfo) {
+    const scan = await runStagedSecretsScan(gitInfo.targetCwd);
+    if (scan.warning) warnings.push(scan.warning);
+    if (scan.block) {
+      return { output: { decision: "block", reason: scan.reason }, warnings };
+    }
+  }
+
+  if (isRiskyOperation(command)) {
+    const reason = riskyCommsBlock();
+    if (reason) return { output: { decision: "block", reason }, warnings };
+    if (!readCache<SessionDigest>("session-start-digest", 5 * 60_000)) {
+      warnings.push("No fresh session-start comms cache; risky operation allowed fail-open, but manually re-check blockers/announcements first.");
+    }
+  }
+
+  if (warnings.length > 0) {
+    return {
+      output: {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: warnings.map((w) => `[pre-bash] ${w}`).join("\n"),
+        },
+      },
+      warnings,
+    };
+  }
+
+  return { output: { continue: true }, warnings };
+}
+
+export async function run(): Promise<void> {
+  const input = readInput();
+  try {
+    const { output, warnings } = await evaluate(input);
+    for (const message of warnings) warn(message);
+    respond(output);
+  } catch (error) {
+    warn(`pre-bash failed open: ${error instanceof Error ? error.message : String(error)}`);
+    respond({ continue: true });
+  }
+}
+
+if (import.meta.main) {
+  await run();
+}

package/hooks/prompt-guard/README.md

@@ -0,0 +1,17 @@
+# prompt-guard
+
+Codewith-native hook installed as `hooks run prompt-guard`.
+
+This hook is OSS-safe: optional Hasna CLIs are best-effort and missing CLIs fail open with concise warnings. Security gates only fail closed when a guarded commit/push scan runs successfully and finds possible secrets.
+
+## Install for Codewith
+
+Prefer renderer-managed configuration through open-configs. @hasna/hooks can emit the TOML fragment:
+
+```bash
+hooks install prompt-guard --target codewith
+```
+
+## License
+
+Apache-2.0