@orquentra/codebuddy 0.0.0-stage → 2.4.0

package/dist/chunk-DSN5CEHO.js

@@ -0,0 +1,175 @@
+import {
+  failSoft,
+  readHookInput,
+  writeStdout
+} from "./chunk-PYLH4MH5.js";
+import {
+  SessionCapsuleLedger,
+  detectTestCommand,
+  estimateTokens,
+  findCoveringTest
+} from "./chunk-5OWZVZSO.js";
+import {
+  NON_SOURCE_PATH,
+  discoverTaskPaths,
+  loadFreshIndex,
+  loadProjectArchitectureMap,
+  readBoundedSource,
+  taskTerms
+} from "./chunk-IBMJYIEP.js";
+
+// src/hooks/lean.ts
+import { createHash } from "crypto";
+import { appendFile, mkdir } from "fs/promises";
+import { extname, join, resolve } from "path";
+var LEAN_POINTER_PREFIX = "CodeBuddy likely files: ";
+var LEAN_LIMITS = {
+  paths: 6,
+  symbolsPerFile: 3,
+  wholeFileLines: 80,
+  spanTokens: 1200
+};
+var LEAN_HOOK_BUDGET_MS = 1500;
+var RENDER_RESERVE_MS = 300;
+async function runLeanHook(input, emit, budgetMs = LEAN_HOOK_BUDGET_MS) {
+  const started = Date.now();
+  const repositoryRoot = resolve(input.cwd ?? process.cwd());
+  const prompt = input.prompt?.trim() ?? "";
+  if (prompt === "" || prompt.startsWith("/")) return "";
+  const sessionId = input.session_id ?? "default";
+  try {
+    const { manifest } = await loadFreshIndex(repositoryRoot);
+    const discovery = await discoverTaskPaths(
+      repositoryRoot,
+      prompt,
+      manifest,
+      loadProjectArchitectureMap(repositoryRoot, manifest),
+      // The rerank must answer while rendering still fits in the hook budget.
+      { semantic: false, llmDeadlineAt: started + budgetMs - RENDER_RESERVE_MS }
+    );
+    const terms = taskTerms(prompt);
+    const indexed = new Set(Object.keys(manifest.entries));
+    const pointers = discovery.paths.filter((path) => !NON_SOURCE_PATH.test(path)).map((path) => {
+      const test = findCoveringTest(path, indexed);
+      const table = manifest.entries[path]?.symbolTable ?? [];
+      const picked = discovery.symbols?.[path] ?? [];
+      const ordered = [
+        ...picked.flatMap((name) => table.filter((symbol) => symbol.name === name)),
+        ...table.filter(
+          (symbol) => !picked.includes(symbol.name) && terms.some((term) => symbol.name.toLowerCase().includes(term))
+        )
+      ];
+      return {
+        path,
+        symbols: ordered.map(({ name, startLine, endLine }) => ({ name, startLine, endLine })),
+        ...test ? { test } : {}
+      };
+    });
+    const ledger = new SessionCapsuleLedger(repositoryRoot);
+    if (input.ephemeral_context) await ledger.reset(sessionId);
+    const { text, emitted } = await renderLeanBlock({
+      repositoryRoot,
+      prompt,
+      pointers,
+      ledger,
+      sessionId,
+      testCommand: pointers.length > 0 ? await detectTestCommand(repositoryRoot) : null
+    });
+    if (Date.now() - started >= budgetMs) return "";
+    if (text) await emit?.(text);
+    await ledger.markSent(sessionId, emitted);
+    return text;
+  } catch (error) {
+    await logHookError(repositoryRoot, sessionId, error).catch(() => {
+    });
+    return "";
+  }
+}
+async function logHookError(root, sessionId, error) {
+  const directory = join(root, ".codebuddy", "cache", "hooks");
+  await mkdir(directory, { recursive: true });
+  const message = error?.message ?? String(error);
+  await appendFile(
+    join(directory, "errors.log"),
+    `${(/* @__PURE__ */ new Date()).toISOString()} ${message.replace(/\s+/g, " ")} session=${sessionId}
+`
+  );
+}
+async function renderLeanBlock(input) {
+  const loaded = [];
+  for (const pointer of input.pointers) {
+    if (loaded.length === LEAN_LIMITS.paths) break;
+    const source = await readBoundedSource(input.repositoryRoot, pointer.path);
+    if (source === null) continue;
+    loaded.push({
+      path: pointer.path,
+      symbols: pointer.symbols.slice(0, LEAN_LIMITS.symbolsPerFile),
+      ...pointer.test ? { test: pointer.test } : {},
+      lines: source.split(/\r?\n/)
+    });
+  }
+  if (loaded.length === 0) return { text: "", emitted: [] };
+  const capsules = [
+    {
+      key: "lean:pointers",
+      text: LEAN_POINTER_PREFIX + loaded.map(describePointer).join(", ")
+    },
+    ...input.testCommand ? [{ key: "lean:test-command", text: `CodeBuddy test command: ${input.testCommand}` }] : []
+  ];
+  if (isReadOnlyPrompt(input.prompt)) {
+    let tokens = 0;
+    for (const span of loaded.flatMap(spansOf)) {
+      const cost = estimateTokens(span.text);
+      if (tokens + cost > LEAN_LIMITS.spanTokens) break;
+      tokens += cost;
+      capsules.push(span);
+    }
+  }
+  const seen = await input.ledger.seen(input.sessionId, capsules);
+  const emitted = capsules.filter((capsule) => !seen.has(capsule.key));
+  return { text: emitted.map((capsule) => capsule.text).join("\n"), emitted };
+}
+function describePointer(pointer) {
+  const ranges = pointer.symbols.map((s) => `${s.name} L${s.startLine}-${s.endLine}`).join(", ");
+  const test = pointer.test ? `test: ${pointer.test}` : "";
+  const detail = [ranges, test].filter(Boolean).join("; ");
+  return detail ? `${pointer.path} (${detail})` : pointer.path;
+}
+function spansOf(pointer) {
+  const ranges = pointer.lines.length <= LEAN_LIMITS.wholeFileLines ? [{ start: 1, end: pointer.lines.length }] : pointer.symbols.map((s) => ({ start: s.startLine, end: s.endLine }));
+  const language = extname(pointer.path).slice(1);
+  return ranges.map(({ start, end }) => {
+    const body = pointer.lines.slice(start - 1, end).join("\n");
+    const hash = createHash("sha1").update(body).digest("hex").slice(0, 12);
+    return {
+      key: `lean:span:${pointer.path}:${start}-${end}:${hash}`,
+      text: `${pointer.path}:L${start}-${end}
+\`\`\`${language}
+${body}
+\`\`\``
+    };
+  });
+}
+var FORCED_READ_ONLY = /\b(without editing|without changing|don't change|do not change|don't edit|do not edit)\b/i;
+var QUESTION_START = /^(how|what|why|where|which|who|explain|describe|summarize)\b/i;
+var EDIT_VERB = /\b(add|change|fix|implement|update|remove|delete|rename|refactor|write|create|make|edit|replace|move|migrate|support|build)\b/i;
+function isReadOnlyPrompt(prompt) {
+  const text = prompt.trim();
+  if (text === "" || text.startsWith("/")) return false;
+  if (FORCED_READ_ONLY.test(text)) return true;
+  const asks = QUESTION_START.test(text) || text.endsWith("?");
+  return asks && !EDIT_VERB.test(text);
+}
+
+// src/hooks/lean-command.ts
+async function runLeanHookCommand() {
+  await failSoft(async () => {
+    await runLeanHook(await readHookInput(), writeStdout);
+  });
+}
+
+export {
+  renderLeanBlock,
+  runLeanHookCommand
+};
+//# sourceMappingURL=chunk-DSN5CEHO.js.map

package/dist/chunk-DSN5CEHO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/lean.ts","../src/hooks/lean-command.ts"],"sourcesContent":["/**\n * Lean mode: the prompt hook's only job is to cut the agent's token spend. It\n * injects ranked file pointers (and code spans for read-only questions) and\n * nothing else — no MCP tools, rules block, or memory capture.\n */\nimport { createHash } from \"node:crypto\";\nimport { appendFile, mkdir } from \"node:fs/promises\";\nimport { extname, join, resolve } from \"node:path\";\nimport {\n  discoverTaskPaths,\n  loadProjectArchitectureMap,\n  NON_SOURCE_PATH,\n  readBoundedSource,\n  taskTerms,\n} from \"../context/discovery.js\";\nimport { type ContextCapsule, SessionCapsuleLedger } from \"../context/session-ledger.js\";\nimport { detectTestCommand, findCoveringTest } from \"../context/tests.js\";\nimport { loadFreshIndex } from \"../indexer/engine.js\";\nimport { estimateTokens } from \"../savings/tokens.js\";\nimport type { HookInput } from \"./runtime.js\";\n\nexport const LEAN_POINTER_PREFIX = \"CodeBuddy likely files: \";\nexport const LEAN_LIMITS = {\n  paths: 6,\n  symbolsPerFile: 3,\n  wholeFileLines: 80,\n  spanTokens: 1200,\n} as const;\n\nexport type LeanPointer = {\n  path: string;\n  symbols: Array<{ name: string; startLine: number; endLine: number }>;\n  /** The test file that covers this path, when one follows a known convention. */\n  test?: string;\n};\n\ntype LoadedPointer = LeanPointer & { lines: string[] };\n\n/** A lean block finished later than this is dropped: the host may already have moved on. */\nexport const LEAN_HOOK_BUDGET_MS = 1500;\n/** Rendering after the BYOK rerank needs this much of the budget. */\nconst RENDER_RESERVE_MS = 300;\n\n/**\n * UserPromptSubmit in lean mode → ranked file pointers, or nothing. Never\n * throws: an error is appended to `.codebuddy/cache/hooks/errors.log` and the\n * turn proceeds as if CodeBuddy were not installed.\n */\nexport async function runLeanHook(\n  input: HookInput,\n  emit?: (block: string) => Promise<void>,\n  budgetMs = LEAN_HOOK_BUDGET_MS,\n): Promise<string> {\n  const started = Date.now();\n  const repositoryRoot = resolve(input.cwd ?? process.cwd());\n  const prompt = input.prompt?.trim() ?? \"\";\n  if (prompt === \"\" || prompt.startsWith(\"/\")) return \"\";\n  const sessionId = input.session_id ?? \"default\";\n  try {\n    const { manifest } = await loadFreshIndex(repositoryRoot);\n    const discovery = await discoverTaskPaths(\n      repositoryRoot,\n      prompt,\n      manifest,\n      loadProjectArchitectureMap(repositoryRoot, manifest),\n      // The rerank must answer while rendering still fits in the hook budget.\n      { semantic: false, llmDeadlineAt: started + budgetMs - RENDER_RESERVE_MS },\n    );\n    const terms = taskTerms(prompt);\n    const indexed = new Set(Object.keys(manifest.entries));\n    const pointers: LeanPointer[] = discovery.paths\n      .filter((path) => !NON_SOURCE_PATH.test(path))\n      .map((path) => {\n        const test = findCoveringTest(path, indexed);\n        const table = manifest.entries[path]?.symbolTable ?? [];\n        // Symbols the BYOK rerank named come first, then term matches.\n        const picked = discovery.symbols?.[path] ?? [];\n        const ordered = [\n          ...picked.flatMap((name) => table.filter((symbol) => symbol.name === name)),\n          ...table.filter(\n            (symbol) =>\n              !picked.includes(symbol.name) &&\n              terms.some((term) => symbol.name.toLowerCase().includes(term)),\n          ),\n        ];\n        return {\n          path,\n          symbols: ordered.map(({ name, startLine, endLine }) => ({ name, startLine, endLine })),\n          ...(test ? { test } : {}),\n        };\n      });\n    const ledger = new SessionCapsuleLedger(repositoryRoot);\n    // The host keeps the block for this turn only, so nothing counts as already sent.\n    if (input.ephemeral_context) await ledger.reset(sessionId);\n    const { text, emitted } = await renderLeanBlock({\n      repositoryRoot,\n      prompt,\n      pointers,\n      ledger,\n      sessionId,\n      testCommand: pointers.length > 0 ? await detectTestCommand(repositoryRoot) : null,\n    });\n    if (Date.now() - started >= budgetMs) return \"\";\n    if (text) await emit?.(text);\n    await ledger.markSent(sessionId, emitted);\n    return text;\n  } catch (error) {\n    await logHookError(repositoryRoot, sessionId, error).catch(() => {});\n    return \"\";\n  }\n}\n\nasync function logHookError(root: string, sessionId: string, error: unknown): Promise<void> {\n  const directory = join(root, \".codebuddy\", \"cache\", \"hooks\");\n  await mkdir(directory, { recursive: true });\n  const message = (error as Error)?.message ?? String(error);\n  await appendFile(\n    join(directory, \"errors.log\"),\n    `${new Date().toISOString()} ${message.replace(/\\s+/g, \" \")} session=${sessionId}\\n`,\n  );\n}\n\n/**\n * The lean block for one prompt: a single pointer line, plus current-source\n * spans when the prompt is read-only. Capsules already delivered this session\n * are left out; the caller marks `emitted` as sent once the block is written.\n */\nexport async function renderLeanBlock(input: {\n  repositoryRoot: string;\n  prompt: string;\n  pointers: LeanPointer[];\n  ledger: SessionCapsuleLedger;\n  sessionId: string;\n  /** Sent once per session, after the pointers. */\n  testCommand?: string | null;\n}): Promise<{ text: string; emitted: ContextCapsule[] }> {\n  const loaded: LoadedPointer[] = [];\n  for (const pointer of input.pointers) {\n    if (loaded.length === LEAN_LIMITS.paths) break;\n    const source = await readBoundedSource(input.repositoryRoot, pointer.path);\n    if (source === null) continue; // deleted, oversized or binary since indexing\n    loaded.push({\n      path: pointer.path,\n      symbols: pointer.symbols.slice(0, LEAN_LIMITS.symbolsPerFile),\n      ...(pointer.test ? { test: pointer.test } : {}),\n      lines: source.split(/\\r?\\n/),\n    });\n  }\n  if (loaded.length === 0) return { text: \"\", emitted: [] };\n\n  const capsules: ContextCapsule[] = [\n    {\n      key: \"lean:pointers\",\n      text: LEAN_POINTER_PREFIX + loaded.map(describePointer).join(\", \"),\n    },\n    ...(input.testCommand\n      ? [{ key: \"lean:test-command\", text: `CodeBuddy test command: ${input.testCommand}` }]\n      : []),\n  ];\n  if (isReadOnlyPrompt(input.prompt)) {\n    let tokens = 0;\n    for (const span of loaded.flatMap(spansOf)) {\n      const cost = estimateTokens(span.text);\n      if (tokens + cost > LEAN_LIMITS.spanTokens) break;\n      tokens += cost;\n      capsules.push(span);\n    }\n  }\n  const seen = await input.ledger.seen(input.sessionId, capsules);\n  const emitted = capsules.filter((capsule) => !seen.has(capsule.key));\n  return { text: emitted.map((capsule) => capsule.text).join(\"\\n\"), emitted };\n}\n\nfunction describePointer(pointer: LoadedPointer): string {\n  const ranges = pointer.symbols.map((s) => `${s.name} L${s.startLine}-${s.endLine}`).join(\", \");\n  const test = pointer.test ? `test: ${pointer.test}` : \"\";\n  const detail = [ranges, test].filter(Boolean).join(\"; \");\n  return detail ? `${pointer.path} (${detail})` : pointer.path;\n}\n\n/** Whole small files; otherwise the matched symbol spans. */\nfunction spansOf(pointer: LoadedPointer): ContextCapsule[] {\n  const ranges =\n    pointer.lines.length <= LEAN_LIMITS.wholeFileLines\n      ? [{ start: 1, end: pointer.lines.length }]\n      : pointer.symbols.map((s) => ({ start: s.startLine, end: s.endLine }));\n  const language = extname(pointer.path).slice(1);\n  return ranges.map(({ start, end }) => {\n    const body = pointer.lines.slice(start - 1, end).join(\"\\n\");\n    const hash = createHash(\"sha1\").update(body).digest(\"hex\").slice(0, 12);\n    return {\n      key: `lean:span:${pointer.path}:${start}-${end}:${hash}`,\n      text: `${pointer.path}:L${start}-${end}\\n\\`\\`\\`${language}\\n${body}\\n\\`\\`\\``,\n    };\n  });\n}\n\nconst FORCED_READ_ONLY =\n  /\\b(without editing|without changing|don't change|do not change|don't edit|do not edit)\\b/i;\nconst QUESTION_START = /^(how|what|why|where|which|who|explain|describe|summarize)\\b/i;\nconst EDIT_VERB =\n  /\\b(add|change|fix|implement|update|remove|delete|rename|refactor|write|create|make|edit|replace|move|migrate|support|build)\\b/i;\n\n/**\n * Whether a prompt asks a question without asking for edits. Conservative: a\n * false positive costs up to the span budget, a false negative costs nothing.\n */\nexport function isReadOnlyPrompt(prompt: string): boolean {\n  const text = prompt.trim();\n  if (text === \"\" || text.startsWith(\"/\")) return false;\n  if (FORCED_READ_ONLY.test(text)) return true;\n  const asks = QUESTION_START.test(text) || text.endsWith(\"?\");\n  return asks && !EDIT_VERB.test(text);\n}\n","import { runLeanHook } from \"./lean.js\";\nimport { failSoft, readHookInput, writeStdout } from \"./stdio.js\";\n\n/** `codebuddy hooks lean`: read the hook payload, print the lean block, never fail. */\nexport async function runLeanHookCommand(): Promise<void> {\n  await failSoft(async () => {\n    await runLeanHook(await readHookInput(), writeStdout);\n  });\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-GDJH7XJC.js

@@ -0,0 +1,119 @@
+// src/memory-extract/sensitive.ts
+var PATTERNS = [
+  { label: "private-key", regex: /-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----/ },
+  { label: "aws-access-key", regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/ },
+  { label: "hf-token", regex: /\bhf_[A-Za-z0-9]{16,}\b/ },
+  { label: "github-token", regex: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/ },
+  // GitHub fine-grained personal access tokens.
+  {
+    label: "github-fine-grained-pat",
+    regex: /\bgithub_pat_[A-Za-z0-9_]{22,255}_[A-Za-z0-9]{22,255}\b/
+  },
+  { label: "npm-token", regex: /\bnpm_[A-Za-z0-9]{36}\b/ },
+  { label: "gitlab-token", regex: /\bglpat-[A-Za-z0-9_-]{20,}\b/ },
+  { label: "slack-token", regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
+  { label: "bearer-token", regex: /\bBearer\s+[A-Za-z0-9._-]{12,}\b/ },
+  // Vendor API keys with distinctive, low-false-positive prefixes.
+  { label: "anthropic-key", regex: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/ },
+  { label: "openai-key", regex: /\bsk-(?!ant-)[A-Za-z0-9_-]{20,}\b/ },
+  { label: "google-api-key", regex: /\bAIza[0-9A-Za-z_-]{35}\b/ },
+  { label: "stripe-key", regex: /\b(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
+  // A JWT: three base64url segments. Common in auth-related pastes.
+  { label: "jwt", regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/ },
+  // Credentials embedded in a connection URL: scheme://user:password@host.
+  {
+    label: "connection-string-credentials",
+    regex: /\b[a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:[^\s:/@]+@/i
+  },
+  {
+    // Catches `password: x`, `api_key = x`, and the prose form `password is x`.
+    // Deliberately eager — an over-flagged review item is cheaper than a leak.
+    label: "credential-assignment",
+    regex: /\b(?:api[_-]?key|secret|token|password|passwd|pwd|access[_-]?key|authorization|auth[_-]?token|credential[s]?)\b\s*(?:[:=]|\bis\b|\bwas\b|\bequals\b)\s*\S{6,}/i
+  },
+  // HTTP Basic-auth style inline credentials outside a URL scheme
+  // (`Authorization: Basic dXNlcjpwYXNz`).
+  {
+    label: "basic-auth-header",
+    regex: /\bAuthorization\s*[:=]\s*Basic\s+[A-Za-z0-9+/=]{8,}/i
+  },
+  { label: "email", regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/ }
+];
+var OPENCODE_ID = /^(?:ses|msg|prt)_[0-9a-f]{12}[0-9A-Za-z]{14}$/;
+function hasHighEntropyToken(text) {
+  for (const token of text.split(/[^A-Za-z0-9+/_=-]+/)) {
+    if (token.length < 24 || token.length > 200 || OPENCODE_ID.test(token)) continue;
+    if (!/[a-z]/.test(token) || !/[A-Z]/.test(token) || !/[0-9]/.test(token)) continue;
+    if (shannonEntropy(token) >= 3.5) return true;
+  }
+  return false;
+}
+function shannonEntropy(value) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const p = count / value.length;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+function scanSensitive(text) {
+  const reasons = [];
+  for (const { label, regex } of PATTERNS) {
+    if (regex.test(text) && !reasons.includes(label)) reasons.push(label);
+  }
+  if (hasHighEntropyToken(text)) reasons.push("high-entropy-string");
+  return { sensitive: reasons.length > 0, reasons };
+}
+var REDACTED = "[REDACTED SENSITIVE CONTENT]";
+function redactSensitive(text) {
+  return scanSensitive(text).sensitive ? REDACTED : text;
+}
+var CLAIM_KEYS = ["subject", "predicate", "object", "content"];
+var PROVENANCE_TEXT_KEYS = [
+  "paths",
+  "verification",
+  "reason",
+  "createdByAgent",
+  "sourcePlanId",
+  "sourceSessionId",
+  "introducedBy"
+];
+function claimText(record) {
+  return CLAIM_KEYS.map((key) => record[key]).filter((value) => typeof value === "string").join(" ");
+}
+function redactPersisted(record) {
+  const out = { ...record };
+  const present = CLAIM_KEYS.filter((key) => typeof out[key] === "string");
+  const claimSensitive = present.length > 0 && (scanSensitive(claimText(out)).sensitive || present.some((key) => scanSensitive(out[key]).sensitive));
+  if (claimSensitive) for (const key of present) out[key] = REDACTED;
+  for (const key of PROVENANCE_TEXT_KEYS) {
+    const value = out[key];
+    if (typeof value === "string") out[key] = redactSensitive(value);
+    else if (Array.isArray(value)) {
+      out[key] = value.map((item) => typeof item === "string" ? redactSensitive(item) : item);
+    }
+  }
+  return out;
+}
+function scanFields(fields) {
+  const reasons = [];
+  for (const field of fields) {
+    if (!field) continue;
+    for (const reason of scanSensitive(field).reasons) {
+      if (!reasons.includes(reason)) reasons.push(reason);
+    }
+  }
+  return { sensitive: reasons.length > 0, reasons };
+}
+
+export {
+  scanSensitive,
+  REDACTED,
+  redactSensitive,
+  claimText,
+  redactPersisted,
+  scanFields
+};
+//# sourceMappingURL=chunk-GDJH7XJC.js.map

package/dist/chunk-GDJH7XJC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-extract/sensitive.ts"],"sourcesContent":["/**\n * Sensitive-content scan. Secrets and personal data must never be auto-saved\n * as durable memory — a matched candidate is forced into the review queue,\n * flagged, so a human decides. This is a conservative detector: false positives\n * (an extra review item) are acceptable; false negatives (a leaked key in\n * committed Markdown) are not.\n *\n * The scan only ever *routes to review* — it never blocks a turn, deletes\n * content, or rejects on its own. Adding a reason at most moves a candidate from\n * \"auto-save\" to \"human decides\".\n */\n\nexport type SensitivityResult = {\n  sensitive: boolean;\n  reasons: string[];\n};\n\nconst PATTERNS: Array<{ label: string; regex: RegExp }> = [\n  { label: \"private-key\", regex: /-----BEGIN(?: [A-Z0-9]+)* PRIVATE KEY-----/ },\n  { label: \"aws-access-key\", regex: /\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b/ },\n  { label: \"hf-token\", regex: /\\bhf_[A-Za-z0-9]{16,}\\b/ },\n  { label: \"github-token\", regex: /\\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\\b/ },\n  // GitHub fine-grained personal access tokens.\n  {\n    label: \"github-fine-grained-pat\",\n    regex: /\\bgithub_pat_[A-Za-z0-9_]{22,255}_[A-Za-z0-9]{22,255}\\b/,\n  },\n  { label: \"npm-token\", regex: /\\bnpm_[A-Za-z0-9]{36}\\b/ },\n  { label: \"gitlab-token\", regex: /\\bglpat-[A-Za-z0-9_-]{20,}\\b/ },\n  { label: \"slack-token\", regex: /\\bxox[baprs]-[A-Za-z0-9-]{10,}\\b/ },\n  { label: \"bearer-token\", regex: /\\bBearer\\s+[A-Za-z0-9._-]{12,}\\b/ },\n  // Vendor API keys with distinctive, low-false-positive prefixes.\n  { label: \"anthropic-key\", regex: /\\bsk-ant-[A-Za-z0-9_-]{20,}\\b/ },\n  { label: \"openai-key\", regex: /\\bsk-(?!ant-)[A-Za-z0-9_-]{20,}\\b/ },\n  { label: \"google-api-key\", regex: /\\bAIza[0-9A-Za-z_-]{35}\\b/ },\n  { label: \"stripe-key\", regex: /\\b(?:sk|rk|pk)_(?:live|test)_[A-Za-z0-9]{16,}\\b/ },\n  // A JWT: three base64url segments. Common in auth-related pastes.\n  { label: \"jwt\", regex: /\\beyJ[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}\\.[A-Za-z0-9_-]{10,}\\b/ },\n  // Credentials embedded in a connection URL: scheme://user:password@host.\n  {\n    label: \"connection-string-credentials\",\n    regex: /\\b[a-z][a-z0-9+.-]*:\\/\\/[^\\s:/@]+:[^\\s:/@]+@/i,\n  },\n  {\n    // Catches `password: x`, `api_key = x`, and the prose form `password is x`.\n    // Deliberately eager — an over-flagged review item is cheaper than a leak.\n    label: \"credential-assignment\",\n    regex:\n      /\\b(?:api[_-]?key|secret|token|password|passwd|pwd|access[_-]?key|authorization|auth[_-]?token|credential[s]?)\\b\\s*(?:[:=]|\\bis\\b|\\bwas\\b|\\bequals\\b)\\s*\\S{6,}/i,\n  },\n  // HTTP Basic-auth style inline credentials outside a URL scheme\n  // (`Authorization: Basic dXNlcjpwYXNz`).\n  {\n    label: \"basic-auth-header\",\n    regex: /\\bAuthorization\\s*[:=]\\s*Basic\\s+[A-Za-z0-9+/=]{8,}/i,\n  },\n  { label: \"email\", regex: /\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b/ },\n];\n\n/**\n * Deterministic, review-oriented high-entropy heuristic. Flags a token that\n * looks like a random secret — long, mixed character classes, high Shannon\n * entropy — that the prefix-based patterns above wouldn't catch. Tuned to stay\n * quiet on ordinary code and prose: identifiers are usually low-entropy words\n * (`camelCase`, `snake_case`), and hex hashes / SHAs lack the required mix of\n * upper, lower, and digit. Never a hard block; at most one extra review item.\n * OpenCode session/message/part ids (`ses_` + 12 hex + 14 random base62) are\n * host identifiers recorded as provenance, not secrets, so they are skipped;\n * otherwise every OpenCode capture would be queued for review.\n */\nconst OPENCODE_ID = /^(?:ses|msg|prt)_[0-9a-f]{12}[0-9A-Za-z]{14}$/;\n\nexport function hasHighEntropyToken(text: string): boolean {\n  for (const token of text.split(/[^A-Za-z0-9+/_=-]+/)) {\n    if (token.length < 24 || token.length > 200 || OPENCODE_ID.test(token)) continue;\n    if (!/[a-z]/.test(token) || !/[A-Z]/.test(token) || !/[0-9]/.test(token)) continue;\n    if (shannonEntropy(token) >= 3.5) return true;\n  }\n  return false;\n}\n\nfunction shannonEntropy(value: string): number {\n  const counts = new Map<string, number>();\n  for (const char of value) counts.set(char, (counts.get(char) ?? 0) + 1);\n  let entropy = 0;\n  for (const count of counts.values()) {\n    const p = count / value.length;\n    entropy -= p * Math.log2(p);\n  }\n  return entropy;\n}\n\nexport function scanSensitive(text: string): SensitivityResult {\n  const reasons: string[] = [];\n  for (const { label, regex } of PATTERNS) {\n    if (regex.test(text) && !reasons.includes(label)) reasons.push(label);\n  }\n  if (hasHighEntropyToken(text)) reasons.push(\"high-entropy-string\");\n  return { sensitive: reasons.length > 0, reasons };\n}\n\nexport const REDACTED = \"[REDACTED SENSITIVE CONTENT]\";\n\n/** Whole-field redaction: a field that scans sensitive is replaced, never partially kept. */\nexport function redactSensitive(text: string): string {\n  return scanSensitive(text).sensitive ? REDACTED : text;\n}\n\n/**\n * The claim: fields that together state one memory. A credential can be split\n * across them (\"password\" / \"is\" / \"hunter2secret\"), so they are scanned\n * jointly and redacted as a unit.\n */\nexport const CLAIM_KEYS = [\"subject\", \"predicate\", \"object\", \"content\"] as const;\n\n/** Independent free-text provenance fields (string or string[]), redacted one by one. */\nexport const PROVENANCE_TEXT_KEYS = [\n  \"paths\",\n  \"verification\",\n  \"reason\",\n  \"createdByAgent\",\n  \"sourcePlanId\",\n  \"sourceSessionId\",\n  \"introducedBy\",\n] as const;\n\n/** The claim fields joined in reading order, for a joint scan. */\nexport function claimText(record: Partial<Record<(typeof CLAIM_KEYS)[number], unknown>>): string {\n  return CLAIM_KEYS.map((key) => record[key])\n    .filter((value): value is string => typeof value === \"string\")\n    .join(\" \");\n}\n\n/**\n * Persistence-boundary redaction: returns a copy of `record` with every\n * free-text field redacted. If any claim field, or the joined claim, scans\n * sensitive, ALL claim fields are replaced (a sibling may hold the value half\n * of the credential). Provenance fields are redacted individually. Idempotent,\n * so re-persisting (e.g. approving a queued item) never re-introduces a raw\n * value. Structural fields (ids, fingerprint, namespace, timestamps, enums)\n * are left alone.\n */\nexport function redactPersisted<T extends object>(record: T): T {\n  const out = { ...record } as Record<string, unknown>;\n  const present = CLAIM_KEYS.filter((key) => typeof out[key] === \"string\");\n  const claimSensitive =\n    present.length > 0 &&\n    (scanSensitive(claimText(out)).sensitive ||\n      present.some((key) => scanSensitive(out[key] as string).sensitive));\n  if (claimSensitive) for (const key of present) out[key] = REDACTED;\n  for (const key of PROVENANCE_TEXT_KEYS) {\n    const value = out[key];\n    if (typeof value === \"string\") out[key] = redactSensitive(value);\n    else if (Array.isArray(value)) {\n      out[key] = value.map((item) => (typeof item === \"string\" ? redactSensitive(item) : item));\n    }\n  }\n  return out as T;\n}\n\n/** Scan several surfaces separately and merge the reason labels (never the matched text). */\nexport function scanFields(fields: Array<string | null | undefined>): SensitivityResult {\n  const reasons: string[] = [];\n  for (const field of fields) {\n    if (!field) continue;\n    for (const reason of scanSensitive(field).reasons) {\n      if (!reasons.includes(reason)) reasons.push(reason);\n    }\n  }\n  return { sensitive: reasons.length > 0, reasons };\n}\n"],"mappings":"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","names":[]}