kritya 0.8.2-beta

package/dist/tools/lsp.js

@@ -0,0 +1,239 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { lspManager } from "../lsp/manager.js";
+import { writeFileAtomic } from "../atomicWrite.js";
+import { resolveSafe, truncateResult } from "./common.js";
+const MAX_LOCATIONS = 100;
+const positionParams = {
+    type: "object",
+    properties: {
+        path: { type: "string", description: "File path relative to the workspace root" },
+        line: { type: "number", description: "1-based line number of the symbol" },
+        column: {
+            type: "number",
+            description: "1-based column of a character inside the symbol name",
+        },
+    },
+    required: ["path", "line", "column"],
+};
+function parsePosition(args) {
+    const line = Number(args.line);
+    const column = Number(args.column);
+    if (!Number.isInteger(line) || line < 1 || !Number.isInteger(column) || column < 1) {
+        throw new Error("line and column must be 1-based positive integers");
+    }
+    return { line: line - 1, character: column - 1 };
+}
+/**
+ * Render locations as "path:line:col  <source line>". The snippet is read
+ * from disk per unique file; files outside the workspace (stdlib,
+ * node_modules typings) are still reported by path, just without a snippet
+ * guarantee — definitions legitimately live there.
+ */
+async function formatLocations(workspace, locations) {
+    if (locations.length === 0)
+        return "(no results)";
+    const shown = locations.slice(0, MAX_LOCATIONS);
+    const fileCache = new Map();
+    const lines = [];
+    for (const loc of shown) {
+        let abs;
+        try {
+            abs = fileURLToPath(loc.uri);
+        }
+        catch {
+            lines.push(loc.uri);
+            continue;
+        }
+        const rel = path.relative(workspace, abs);
+        const display = rel.startsWith("..") ? abs : rel;
+        const line = loc.range.start.line + 1;
+        const col = loc.range.start.character + 1;
+        if (!fileCache.has(abs)) {
+            try {
+                fileCache.set(abs, (await fs.readFile(abs, "utf8")).split("\n"));
+            }
+            catch {
+                fileCache.set(abs, null);
+            }
+        }
+        const snippet = fileCache.get(abs)?.[loc.range.start.line]?.trim().slice(0, 200);
+        lines.push(`${display}:${line}:${col}${snippet ? `  ${snippet}` : ""}`);
+    }
+    if (locations.length > shown.length) {
+        lines.push(`... [${locations.length - shown.length} more]`);
+    }
+    return truncateResult(lines.join("\n"));
+}
+const SEVERITY = ["error", "warning", "info", "hint"];
+function formatDiagnostics(relPath, diags) {
+    if (diags.length === 0)
+        return `No diagnostics for ${relPath} — the file is clean.`;
+    const lines = diags.map((d) => {
+        const sev = SEVERITY[(d.severity ?? 1) - 1] ?? "error";
+        const line = d.range.start.line + 1;
+        const col = d.range.start.character + 1;
+        const code = d.code !== undefined ? ` [${d.source ?? ""}${d.source ? ":" : ""}${d.code}]` : "";
+        return `${relPath}:${line}:${col} ${sev}: ${d.message.replace(/\s*\n\s*/g, " ")}${code}`;
+    });
+    return truncateResult(lines.join("\n"));
+}
+export const lspDefinitionTool = {
+    name: "lsp_definition",
+    description: "Go to the definition of the symbol at a position, resolved semantically by a real " +
+        "language server (TypeScript/JavaScript, Python, Go, Rust, C/C++) — unlike grep, this " +
+        "follows imports, scopes, and re-exports. Returns 'path:line:col  <code>' locations. " +
+        "The first call for a language may take a few seconds while the server indexes the project.",
+    parameters: positionParams,
+    requiresPermission: false,
+    summarize: (args) => `Definition of ${args.path}:${args.line}:${args.column}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const client = await lspManager.clientFor(ctx.workspace, abs);
+        return formatLocations(ctx.workspace, await client.definition(abs, parsePosition(args)));
+    },
+};
+export const lspReferencesTool = {
+    name: "lsp_references",
+    description: "Find all references to the symbol at a position, resolved semantically by a real " +
+        "language server — every actual usage site across the project, without the false " +
+        "positives of a text search. Returns 'path:line:col  <code>' locations, including the " +
+        "declaration.",
+    parameters: positionParams,
+    requiresPermission: false,
+    summarize: (args) => `References to ${args.path}:${args.line}:${args.column}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const client = await lspManager.clientFor(ctx.workspace, abs);
+        return formatLocations(ctx.workspace, await client.references(abs, parsePosition(args)));
+    },
+};
+export const lspDiagnosticsTool = {
+    name: "lsp_diagnostics",
+    description: "Get language-server diagnostics (type errors, unresolved imports, warnings) for a file " +
+        "without running a build. Use after editing to verify a change didn't break anything. " +
+        "Reads the file from disk, so unsaved concerns don't apply.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace root" },
+        },
+        required: ["path"],
+    },
+    requiresPermission: false,
+    summarize: (args) => `Diagnostics for ${args.path}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const client = await lspManager.clientFor(ctx.workspace, abs);
+        const rel = path.relative(ctx.workspace, abs);
+        return formatDiagnostics(rel, await client.diagnosticsFor(abs));
+    },
+};
+export const lspHoverTool = {
+    name: "lsp_hover",
+    description: "Show what a symbol resolves to — its type, signature, and doc comment — as computed by a " +
+        "real language server, without opening the file it's defined in. Answers 'what is this?' at " +
+        "a position: the inferred type of a variable, a function's full signature, an imported " +
+        "symbol's origin. Returns the server's markdown/plaintext, or a note if there's nothing there.",
+    parameters: positionParams,
+    requiresPermission: false,
+    summarize: (args) => `Hover ${args.path}:${args.line}:${args.column}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const client = await lspManager.clientFor(ctx.workspace, abs);
+        const text = await client.hover(abs, parsePosition(args));
+        return text ? truncateResult(text) : "(no hover information at this position)";
+    },
+};
+/**
+ * Apply a set of LSP TextEdits to a document's text. LSP positions are UTF-16
+ * code-unit offsets, which is exactly how JS indexes strings, so line/character
+ * map onto slice offsets directly. Edits are applied end-first so that earlier
+ * edits don't shift the offsets of later ones.
+ */
+function applyTextEdits(text, edits) {
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n")
+            lineStarts.push(i + 1);
+    }
+    const toOffset = (pos) => {
+        const lineStart = lineStarts[pos.line] ?? text.length;
+        return Math.min(lineStart + pos.character, text.length);
+    };
+    const sorted = [...edits].sort((a, b) => toOffset(b.range.start) - toOffset(a.range.start));
+    let result = text;
+    for (const edit of sorted) {
+        const start = toOffset(edit.range.start);
+        const end = toOffset(edit.range.end);
+        result = result.slice(0, start) + edit.newText + result.slice(end);
+    }
+    return result;
+}
+const renameParams = {
+    type: "object",
+    properties: {
+        path: { type: "string", description: "File path relative to the workspace root" },
+        line: { type: "number", description: "1-based line number of the symbol" },
+        column: {
+            type: "number",
+            description: "1-based column of a character inside the symbol name",
+        },
+        new_name: { type: "string", description: "The new name for the symbol" },
+    },
+    required: ["path", "line", "column", "new_name"],
+};
+export const lspRenameTool = {
+    name: "lsp_rename",
+    description: "Rename a symbol everywhere it is used, across the whole project, using a real language " +
+        "server. Unlike find-and-replace this is semantic: it renames only the actual occurrences " +
+        "of THIS symbol — never a same-named but unrelated variable, and never text in comments or " +
+        "strings — and updates every file that references it. Point it at any one occurrence " +
+        "(definition or use). Writes the edited files to disk and reports what changed.",
+    parameters: renameParams,
+    requiresPermission: true,
+    summarize: (args) => `Rename ${args.path}:${args.line}:${args.column} → ${args.new_name}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const newName = String(args.new_name);
+        if (newName.trim().length === 0)
+            throw new Error("new_name must not be empty");
+        const client = await lspManager.clientFor(ctx.workspace, abs);
+        const fileEdits = await client.rename(abs, parsePosition(args), newName);
+        if (fileEdits.length === 0) {
+            return "No rename performed — the symbol at that position can't be renamed (it may be a keyword, literal, or outside a project the server has loaded).";
+        }
+        // Validate every target up front so a rename is all-or-nothing: resolveSafe
+        // rejects anything outside the workspace or matching a secret pattern.
+        const targets = [];
+        for (const fe of fileEdits) {
+            let target;
+            try {
+                target = fileURLToPath(fe.uri);
+            }
+            catch {
+                throw new Error(`Rename produced an edit for a non-file URI (${fe.uri}); aborted.`);
+            }
+            const rel = path.relative(ctx.workspace, target);
+            // resolveSafe throws for out-of-workspace / sensitive paths — abort the whole rename.
+            const safeAbs = resolveSafe(ctx.workspace, rel);
+            targets.push({ abs: safeAbs, rel, edits: fe.edits });
+        }
+        let totalEdits = 0;
+        for (const t of targets) {
+            const content = await fs.readFile(t.abs, "utf8");
+            const updated = applyTextEdits(content, t.edits);
+            if (updated === content)
+                continue;
+            ctx.undo?.snapshot(t.abs, t.rel);
+            await writeFileAtomic(t.abs, updated);
+            totalEdits += t.edits.length;
+        }
+        const fileList = targets
+            .map((t) => `  ${t.rel} (${t.edits.length} edit${t.edits.length === 1 ? "" : "s"})`)
+            .join("\n");
+        return truncateResult(`Renamed to "${newName}" — ${totalEdits} edit${totalEdits === 1 ? "" : "s"} across ` +
+            `${targets.length} file${targets.length === 1 ? "" : "s"}:\n${fileList}`);
+    },
+};

package/dist/tools/notebook.js

@@ -0,0 +1,215 @@
+import fs from "node:fs/promises";
+import { writeFileAtomic } from "../atomicWrite.js";
+import { resolveSafe, truncateResult } from "./common.js";
+/** nbformat stores text as either a single string or an array of lines. */
+function joinSource(source) {
+    if (Array.isArray(source))
+        return source.join("");
+    return source ?? "";
+}
+/** Store text the way Jupyter does: one array entry per line, newline kept on all but the last. */
+function splitSource(text) {
+    if (text === "")
+        return [];
+    const lines = text.split("\n");
+    return lines.map((line, i) => (i < lines.length - 1 ? line + "\n" : line));
+}
+const MAX_OUTPUT_CHARS = 2000;
+/** Collapse one cell's outputs into a short, token-cheap text summary. */
+function summarizeOutputs(outputs) {
+    const parts = [];
+    for (const raw of outputs) {
+        const out = raw;
+        switch (out.output_type) {
+            case "stream":
+                parts.push(joinSource(out.text));
+                break;
+            case "execute_result":
+            case "display_data": {
+                const data = (out.data ?? {});
+                if (data["text/plain"]) {
+                    parts.push(joinSource(data["text/plain"]));
+                }
+                // Rich outputs (images, HTML) are large and unreadable as text: name them, drop the bytes.
+                for (const mime of Object.keys(data)) {
+                    if (mime !== "text/plain")
+                        parts.push(`[${mime} output]`);
+                }
+                break;
+            }
+            case "error": {
+                const ename = String(out.ename ?? "Error");
+                const evalue = String(out.evalue ?? "");
+                parts.push(`${ename}: ${evalue}`);
+                if (Array.isArray(out.traceback)) {
+                    parts.push(out.traceback.join("\n"));
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const text = parts.join("\n").trimEnd();
+    if (text.length <= MAX_OUTPUT_CHARS)
+        return text;
+    return (text.slice(0, MAX_OUTPUT_CHARS) +
+        `\n... [output truncated, ${text.length - MAX_OUTPUT_CHARS} more characters]`);
+}
+async function loadNotebook(abs) {
+    const text = await fs.readFile(abs, "utf8");
+    let nb;
+    try {
+        nb = JSON.parse(text);
+    }
+    catch {
+        throw new Error("File is not valid JSON — a .ipynb notebook must be a JSON document");
+    }
+    if (!Array.isArray(nb.cells)) {
+        throw new Error("Not a valid notebook: missing a top-level `cells` array");
+    }
+    return nb;
+}
+async function saveNotebook(abs, nb) {
+    // Jupyter writes notebooks with 1-space indent and a trailing newline; match it to keep diffs small.
+    await writeFileAtomic(abs, JSON.stringify(nb, null, 1) + "\n");
+}
+export const readNotebookTool = {
+    name: "read_notebook",
+    description: "Read a Jupyter notebook (.ipynb) and return a clean, per-cell view: each cell's index, " +
+        "type (code/markdown/raw), source, and a compacted summary of its outputs. Large binary " +
+        "outputs like images are shown as placeholders rather than raw data. Use the cell index " +
+        "shown here with edit_notebook.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace root" },
+        },
+        required: ["path"],
+    },
+    requiresPermission: false,
+    summarize: (args) => `Read ${args.path}`,
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const nb = await loadNotebook(abs);
+        const parts = [];
+        nb.cells.forEach((cell, i) => {
+            const type = cell.cell_type ?? "code";
+            const exec = type === "code" && cell.execution_count != null ? ` (exec ${cell.execution_count})` : "";
+            parts.push(`[${i}] ${type}${exec}`);
+            parts.push(joinSource(cell.source));
+            if (type === "code" && Array.isArray(cell.outputs) && cell.outputs.length > 0) {
+                const summary = summarizeOutputs(cell.outputs);
+                if (summary) {
+                    parts.push("--- output ---");
+                    parts.push(summary);
+                }
+            }
+            parts.push("");
+        });
+        return truncateResult(parts.join("\n").trimEnd());
+    },
+};
+export const editNotebookTool = {
+    name: "edit_notebook",
+    description: "Edit a single cell of a Jupyter notebook (.ipynb) in place, leaving all other cells and " +
+        "their saved outputs untouched. op=replace changes a cell's source (and clears that cell's " +
+        "stale outputs); op=insert adds a new cell at the given index; op=delete removes the cell at " +
+        "the given index. Cell indexes match what read_notebook prints. This does not run any code.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace root" },
+            op: { type: "string", enum: ["replace", "insert", "delete"] },
+            index: {
+                type: "number",
+                description: "Target cell index. For insert, the new cell is placed at this index (use the cell count to append at the end).",
+            },
+            source: {
+                type: "string",
+                description: "New cell text. Required for replace and insert; ignored for delete.",
+            },
+            cell_type: {
+                type: "string",
+                enum: ["code", "markdown", "raw"],
+                description: "Cell type for insert (default code), or to change a cell's type on replace.",
+            },
+        },
+        required: ["path", "op", "index"],
+    },
+    requiresPermission: true,
+    summarize: (args) => `Edit ${args.path} (${args.op} cell ${args.index})`,
+    async preview(args) {
+        const op = String(args.op);
+        if (op === "delete")
+            return `Delete cell ${args.index}`;
+        const src = String(args.source ?? "");
+        const preview = src.length > 200 ? src.slice(0, 200) + "…" : src;
+        return `${op} cell ${args.index}:\n${preview}`;
+    },
+    async execute(args, ctx) {
+        const relPath = String(args.path);
+        const abs = resolveSafe(ctx.workspace, relPath);
+        const op = String(args.op);
+        const index = Number(args.index);
+        if (!Number.isInteger(index) || index < 0) {
+            throw new Error(`index must be a non-negative integer, got ${args.index}`);
+        }
+        const nb = await loadNotebook(abs);
+        const cells = nb.cells;
+        switch (op) {
+            case "replace": {
+                if (index >= cells.length) {
+                    throw new Error(`Cannot replace cell ${index}: notebook has ${cells.length} cell(s)`);
+                }
+                if (args.source === undefined)
+                    throw new Error("replace requires `source`");
+                const cell = cells[index];
+                cell.source = splitSource(String(args.source));
+                if (args.cell_type !== undefined)
+                    cell.cell_type = String(args.cell_type);
+                // The stored source no longer matches these outputs, so clear them.
+                if (cell.cell_type === "code") {
+                    cell.outputs = [];
+                    cell.execution_count = null;
+                }
+                else {
+                    delete cell.outputs;
+                    delete cell.execution_count;
+                }
+                break;
+            }
+            case "insert": {
+                if (index > cells.length) {
+                    throw new Error(`Cannot insert at ${index}: notebook has ${cells.length} cell(s) (max index ${cells.length})`);
+                }
+                if (args.source === undefined)
+                    throw new Error("insert requires `source`");
+                const cellType = args.cell_type !== undefined ? String(args.cell_type) : "code";
+                const cell = {
+                    cell_type: cellType,
+                    source: splitSource(String(args.source)),
+                    metadata: {},
+                };
+                if (cellType === "code") {
+                    cell.outputs = [];
+                    cell.execution_count = null;
+                }
+                cells.splice(index, 0, cell);
+                break;
+            }
+            case "delete": {
+                if (index >= cells.length) {
+                    throw new Error(`Cannot delete cell ${index}: notebook has ${cells.length} cell(s)`);
+                }
+                cells.splice(index, 1);
+                break;
+            }
+            default:
+                throw new Error(`Unknown op "${op}". Use replace, insert, or delete.`);
+        }
+        ctx.undo?.snapshot(abs, relPath);
+        await saveNotebook(abs, nb);
+        return `${op === "delete" ? "Deleted" : op === "insert" ? "Inserted" : "Replaced"} cell ${index} in ${relPath}`;
+    },
+};

package/dist/tools/read.js

@@ -0,0 +1,32 @@
+import fs from "node:fs/promises";
+import { resolveSafe, truncateResult, countLines } from "./common.js";
+export const readFileTool = {
+    name: "read_file",
+    description: "Read a text file from the workspace. Returns the content with line numbers. " +
+        "Use offset/limit for large files.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path relative to the workspace root" },
+            offset: { type: "number", description: "1-based line number to start from (optional)" },
+            limit: { type: "number", description: "Maximum number of lines to return (optional)" },
+        },
+        required: ["path"],
+    },
+    requiresPermission: false,
+    summarize: (args) => `Read ${args.path}`,
+    resultSummary: (output) => countLines(output, "line", "lines"),
+    async execute(args, ctx) {
+        const abs = resolveSafe(ctx.workspace, String(args.path));
+        const content = await fs.readFile(abs, "utf8");
+        const lines = content.split("\n");
+        const offset = Math.max(1, Number(args.offset) || 1);
+        const limit = Number(args.limit) || 2000;
+        const slice = lines.slice(offset - 1, offset - 1 + limit);
+        const numbered = slice.map((l, i) => `${String(offset + i).padStart(5)}\t${l}`).join("\n");
+        const header = lines.length > slice.length
+            ? `[showing lines ${offset}-${offset + slice.length - 1} of ${lines.length}]\n`
+            : "";
+        return truncateResult(header + numbered);
+    },
+};

package/dist/tools/repoMap.js

@@ -0,0 +1,26 @@
+import { countLines } from "./common.js";
+import { buildRepoMap } from "../repomap/repoMap.js";
+export const repoMapTool = {
+    name: "repo_map",
+    description: "Get a structural overview of the codebase: a ranked skeleton of source files with their " +
+        "class/function/type signatures (no bodies). Use this FIRST to orient yourself in an " +
+        "unfamiliar or large repository before grepping or reading files — it shows where things " +
+        "live at a fraction of the token cost of reading files. Pass a `path` to focus on one " +
+        "subdirectory. Covers mainstream languages (TS/JS, Python, Go, Rust, Java, Kotlin, C#, " +
+        "C/C++, Ruby, PHP, Swift, Scala); files in other languages are omitted.",
+    parameters: {
+        type: "object",
+        properties: {
+            path: {
+                type: "string",
+                description: "Optional subdirectory to map, relative to the workspace root (default: whole workspace)",
+            },
+        },
+    },
+    requiresPermission: false,
+    summarize: (args) => (args.path ? `Repo map: ${args.path}` : "Repo map (whole workspace)"),
+    resultSummary: (output) => countLines(output, "line", "lines"),
+    async execute(args, ctx) {
+        return buildRepoMap(ctx.workspace, String(args.path ?? "."));
+    },
+};

package/dist/tools/secretScan.js

@@ -0,0 +1,143 @@
+/**
+ * Content-based secret scanning, independent of the filename checks in
+ * common.ts (isSensitivePath). Filenames only catch secrets kept in files
+ * that *look* sensitive (.env, *secret*, etc.) — they do nothing to stop the
+ * model from writing a real API key it saw in some tool output (a log, an
+ * error message, a fetched page) into an ordinary file like README.md or
+ * config.ts. This scans content being written/edited for known secret
+ * formats and high-entropy assignments, and blocks the write.
+ *
+ * This is a heuristic defense-in-depth measure, not a guarantee: it can miss
+ * novel key formats and can false-positive on random-looking test fixtures.
+ * Callers should surface the specific match kind so a false positive is easy
+ * to diagnose and override deliberately (e.g. by restructuring the string).
+ */
+// Well-known key/token formats with distinctive prefixes or structure —
+// these have a very low false-positive rate.
+const NAMED_PATTERNS = [
+    { kind: "AWS Access Key ID", re: /\bAKIA[0-9A-Z]{16}\b/g },
+    { kind: "AWS Secret Access Key", re: /\baws(.{0,20})?['"]\s*[:=]\s*['"][0-9a-zA-Z/+]{40}['"]/gi },
+    { kind: "GitHub token", re: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g },
+    { kind: "GitLab token", re: /\bglpat-[A-Za-z0-9\-_]{20,}\b/g },
+    { kind: "Slack token", re: /\bxox[baprs]-[0-9A-Za-z-]{10,}\b/g },
+    { kind: "Slack webhook URL", re: /\bhooks\.slack\.com\/services\/[A-Za-z0-9/]{20,}\b/g },
+    { kind: "Google API key", re: /\bAIza[0-9A-Za-z\-_]{35}\b/g },
+    { kind: "Stripe key", re: /\b(sk|rk)_(live|test)_[0-9a-zA-Z]{20,}\b/g },
+    { kind: "Anthropic API key", re: /\bsk-ant-[A-Za-z0-9\-_]{20,}\b/g },
+    {
+        kind: "OpenAI API key",
+        re: /\bsk-[A-Za-z0-9]{20,}T3BlbkFJ[A-Za-z0-9]{20,}\b|\bsk-proj-[A-Za-z0-9\-_]{20,}\b/g,
+    },
+    {
+        kind: "JSON Web Token",
+        re: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    },
+    {
+        kind: "Private key block",
+        re: /-----BEGIN (RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g,
+    },
+];
+// Generic "KEY = <opaque token>" assignments, gated by an entropy check so
+// ordinary identifiers/URLs/sentences don't trip it.
+// No leading `\b`: env vars are routinely prefixed (OPENAI_API_KEY,
+// STRIPE_SECRET_KEY, DB_PASSWORD) and `_` is a word character, so a boundary
+// requirement before the key phrase would silently skip almost every real
+// `.env` entry. A trailing `\b` still stops the phrase mid-identifier.
+const ASSIGNMENT_RE = /(api[_-]?key|apikey|secret|token|access[_-]?key|private[_-]?key|passwd|password|pwd|auth)\w*\s*[:=]\s*["'`]?([A-Za-z0-9/+_.-]{16,})["'`]?/gi;
+function shannonEntropy(s) {
+    const counts = new Map();
+    for (const ch of s)
+        counts.set(ch, (counts.get(ch) ?? 0) + 1);
+    let entropy = 0;
+    for (const count of counts.values()) {
+        const p = count / s.length;
+        entropy -= p * Math.log2(p);
+    }
+    return entropy;
+}
+/** Placeholder-looking values (env var refs, obvious examples) that shouldn't be flagged. */
+function looksLikePlaceholder(value) {
+    if (/^(x+|\*+|0+|1+|<[^>]+>|\{\{.*\}\}|\$\{?[A-Z0-9_]+\}?|your[_-]|example|changeme|placeholder|dummy|fake|test)/i.test(value)) {
+        return true;
+    }
+    // Low variety of distinct characters (e.g. "aaaaaaaaaaaaaaaaaaaa") is not a real secret.
+    return new Set(value).size < 6;
+}
+const MIN_ENTROPY = 3.5;
+const MAX_SNIPPET = 12;
+function redact(value) {
+    if (value.length <= MAX_SNIPPET)
+        return value.slice(0, 4) + "…";
+    return value.slice(0, 4) + "…" + value.slice(-4);
+}
+/**
+ * Scan `content` for strings that look like real secrets. Returns an empty
+ * array if none are found.
+ */
+export function scanForSecrets(content) {
+    const matches = [];
+    const seen = new Set();
+    for (const { kind, re } of NAMED_PATTERNS) {
+        re.lastIndex = 0;
+        let m;
+        while ((m = re.exec(content))) {
+            const value = m[0];
+            const key = `${kind}:${value}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                matches.push({ kind, snippet: redact(value) });
+            }
+            if (!re.global)
+                break;
+        }
+    }
+    ASSIGNMENT_RE.lastIndex = 0;
+    let am;
+    while ((am = ASSIGNMENT_RE.exec(content))) {
+        const value = am[2];
+        if (looksLikePlaceholder(value))
+            continue;
+        if (shannonEntropy(value) < MIN_ENTROPY)
+            continue;
+        const key = `assignment:${value}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            matches.push({ kind: `high-entropy ${am[1].toLowerCase()} value`, snippet: redact(value) });
+        }
+    }
+    return matches;
+}
+/**
+ * Scans `content` the same way `scanForSecrets` does, but instead of
+ * blocking, replaces each matched secret with a `[REDACTED: <kind>]`
+ * placeholder. Used for shell output, which — unlike a file write — has
+ * already happened by the time we see it; redacting the display is the
+ * only lever left, so masking rather than throwing is the right shape here.
+ */
+export function redactSecrets(content) {
+    const matches = scanForSecrets(content);
+    if (matches.length === 0)
+        return { redacted: content, matches };
+    let redacted = content;
+    for (const { kind, re } of NAMED_PATTERNS) {
+        redacted = redacted.replace(re, () => `[REDACTED: ${kind}]`);
+    }
+    redacted = redacted.replace(ASSIGNMENT_RE, (full, _label, value) => {
+        if (looksLikePlaceholder(value) || shannonEntropy(value) < MIN_ENTROPY)
+            return full;
+        // `full` is `key<sep><quote?>value<quote?>` — replace just the value
+        // substring so the key (useful context) stays visible. `value` is at
+        // least 16 chars, so a spurious earlier occurrence inside the key/label
+        // portion of `full` is not a realistic concern.
+        return full.replace(value, "[REDACTED]");
+    });
+    return { redacted, matches };
+}
+export function formatSecretWarning(matches, path) {
+    const lines = matches.map((m) => `  - ${m.kind}: ${m.snippet}`);
+    return (`Blocked write to ${path}: content looks like it contains real secret(s):\n` +
+        lines.join("\n") +
+        `\n\nIf this is genuinely not a secret (e.g. a test fixture), rewrite it so it doesn't ` +
+        `match common key formats or lower its entropy — for example, using an obvious placeholder ` +
+        `like "sk-ant-EXAMPLE...".`);
+}