pi-lens 4.2.1 → 4.4.0

package/dist/clients/sanitize.js

@@ -1,286 +0,0 @@
-/**
- * Tool Output Sanitization for pi-lens
- *
- * Cleans and normalizes tool output for display to users.
- * Removes ANSI codes, extracts key error messages, etc.
- */
-// --- Constants ---
-// ANSI escape codes for colors and formatting
-// oxlint-disable-next-line no-control-regex -- ESC (\x1b) is the literal ANSI escape-sequence lead byte this pattern strips, not accidental input.
-const ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
-// Full ECMA-48 CSI grammar (parameter bytes 0-9;? , intermediate bytes
-// space-/, final byte @-~) — matches every CSI sequence ANSI_ESCAPE does
-// plus non-SGR ones (cursor moves, private-mode `?` sequences like
-// `\x1b[?25l`, etc.), not just the `m`-terminated color codes.
-// oxlint-disable-next-line no-control-regex -- ESC (\x1b) is the literal ANSI escape-sequence lead byte this pattern strips, not accidental input.
-const ANSI_ESCAPE_EXTENDED = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
-// Common error patterns from different tools
-const ERROR_INDICATORS = [
-    /\berror\b/i,
-    /\bfailed\b/i,
-    /\bfatal\b/i,
-    /\binvalid\b/i,
-    /\bunexpected\b/i,
-    /\bexpected\b/i,
-    /\bsyntax\b/i,
-    /\bcannot find\b/i,
-    /\bnot found\b/i,
-    /\bno such\b/i,
-];
-// Patterns that indicate a line is a "detail" rather than an error
-const DETAIL_PATTERNS = [
-    /^help wanted/i,
-    /^note:/i,
-    /^hint:/i,
-    /^→/,
-    /^\s*at\s+/, // Stack traces
-    /^ {4}/, // Indented continuation
-];
-// --- Core Sanitization Functions ---
-/**
- * Remove ANSI escape sequences from a string.
- */
-export function stripAnsi(text) {
-    return text.replace(ANSI_ESCAPE, "").replace(ANSI_ESCAPE_EXTENDED, "");
-}
-/**
- * Check if a line contains error indicators.
- */
-function isErrorLine(line) {
-    const cleanLine = stripAnsi(line).trim();
-    return ERROR_INDICATORS.some((pattern) => pattern.test(cleanLine));
-}
-/**
- * Check if a line is a "detail" line (continuation, stack trace, etc.)
- * that shouldn't be shown as a standalone error.
- */
-function isDetailLine(line) {
-    const cleanLine = stripAnsi(line).trim();
-    return DETAIL_PATTERNS.some((pattern) => pattern.test(cleanLine));
-}
-/**
- * Sanitize a single line of tool output.
- * Removes ANSI codes and normalizes common patterns.
- */
-export function sanitizeLine(line) {
-    return stripAnsi(line)
-        .replace(/^\s*\[error\]\s*/i, "")
-        .replace(/^\s*error:\s*/i, "")
-        .replace(/^\s*[×✖✘✗]\s*/u, "")
-        .replace(/^\s*[✓✔]\s*/u, "")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-/**
- * Sanitize multi-line tool output.
- * Returns cleaned lines, filtered to relevant content.
- */
-export function sanitizeOutput(output) {
-    if (!output || typeof output !== "string") {
-        return "";
-    }
-    const lines = output.split(/\r?\n/);
-    const sanitized = lines
-        .map((line) => sanitizeLine(line))
-        .filter((line) => line.length > 0)
-        .filter((line) => !isDetailLine(line));
-    return sanitized.join("\n");
-}
-/**
- * Extract the most relevant error message from tool output.
- * Returns the first line that contains error indicators, or the first non-empty line.
- */
-export function extractErrorMessage(output) {
-    if (!output || typeof output !== "string") {
-        return undefined;
-    }
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => sanitizeLine(line))
-        .filter((line) => line.length > 0);
-    if (lines.length === 0) {
-        return undefined;
-    }
-    // Find first line with error indicators
-    const errorLine = lines.find((line) => isErrorLine(line));
-    if (errorLine) {
-        return errorLine;
-    }
-    // Fall back to first non-detail line
-    const firstMain = lines.find((line) => !isDetailLine(line));
-    return firstMain;
-}
-/**
- * Truncate a message to a maximum length, adding ellipsis if needed.
- */
-export function truncateMessage(message, maxLength = 140) {
-    if (message.length <= maxLength) {
-        return message;
-    }
-    return `${message.slice(0, maxLength - 1)}…`;
-}
-// --- Tool-Specific Sanitizers ---
-/**
- * Sanitize TypeScript/LSP diagnostic output.
- */
-export function sanitizeTsDiagnostic(output) {
-    if (!output)
-        return "";
-    // TypeScript errors often look like:
-    // error TS2322: Type 'string' is not assignable to type 'number'.
-    // or:
-    // src/file.ts(10,5): error TS2322: ...
-    const lines = output
-        .split(/\r?\n/)
-        .map((line) => stripAnsi(line))
-        .filter((line) => line.length > 0)
-        // Filter out non-error lines
-        .filter((line) => line.includes("error TS") || line.includes("warning TS"));
-    // If we have file:line:col format errors, extract those
-    const fileErrors = lines
-        .filter((line) => /^.+?\([\d,]+\):/.test(line))
-        .map((line) => {
-        // Extract file:line:col from the beginning
-        const match = line.match(/^(.+?\([\d,]+\):)\s*(.+)/);
-        if (match) {
-            return `${match[1]} ${match[2].trim()}`;
-        }
-        return line.trim();
-    });
-    if (fileErrors.length > 0) {
-        return fileErrors.slice(0, 10).join("\n");
-    }
-    // Otherwise just return error lines
-    return lines.slice(0, 5).join("\n");
-}
-// --- Helper Functions ---
-/**
- * Extract error/warning lines from tool output.
- * Filters and formats lines containing diagnostic information.
- */
-function extractDiagnosticLines(output, predicate, maxLines = 10) {
-    if (!output)
-        return "";
-    return output
-        .split(/\r?\n/)
-        .map((line) => stripAnsi(line))
-        .filter((line) => line.length > 0)
-        .filter(predicate)
-        .slice(0, maxLines)
-        .join("\n");
-}
-/**
- * Format JSON diagnostics array into readable output.
- */
-function formatJsonDiagnostics(diags, formatter) {
-    return diags.slice(0, 10).map(formatter).join("\n");
-}
-// --- Tool-Specific Sanitizers ---
-/**
- * Sanitize Rust cargo output.
- */
-export function sanitizeRustOutput(output) {
-    if (!output)
-        return "";
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return (isErrorLine(clean) || /^\s*-->\s+/.test(clean) // rustc source locations
-        );
-    });
-}
-/**
- * Sanitize Go vet output.
- */
-export function sanitizeGoOutput(output) {
-    if (!output)
-        return "";
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return /(?:^\.\/)|(?:\.go:)/.test(clean) || isErrorLine(clean);
-    });
-}
-/**
- * Sanitize Biome output.
- */
-export function sanitizeBiomeOutput(output) {
-    if (!output)
-        return "";
-    try {
-        const data = JSON.parse(output);
-        if (data.diagnostics && Array.isArray(data.diagnostics)) {
-            return formatJsonDiagnostics(data.diagnostics, (d) => {
-                const loc = d.location;
-                const file = loc?.path ? `${loc.path}` : "";
-                const line = loc?.span?.start?.line ?? 0;
-                const msg = d.message || "";
-                return file ? `${file}:${line + 1} ${msg}` : msg;
-            });
-        }
-    }
-    catch (err) {
-        void err;
-        // Not JSON, fall through to text processing
-    }
-    // Text output processing
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return isErrorLine(clean) || clean.includes("hint");
-    });
-}
-/**
- * Sanitize Ruff output.
- */
-export function sanitizeRuffOutput(output) {
-    if (!output)
-        return "";
-    try {
-        const data = JSON.parse(output);
-        if (Array.isArray(data)) {
-            return formatJsonDiagnostics(data, (d) => {
-                const row = d.location?.row ?? 0;
-                const col = d.location?.column ?? 0;
-                const code = d.code || "";
-                const msg = d.message || "";
-                return `${row}:${col} [${code}] ${msg}`;
-            });
-        }
-    }
-    catch (err) {
-        void err;
-        // Not JSON, fall through
-    }
-    // Text output
-    return extractDiagnosticLines(output, (line) => {
-        const clean = stripAnsi(line);
-        return isErrorLine(clean) || /\[(E|W)\d+\]/.test(clean);
-    });
-}
-/**
- * Sanitize tool output and return both a summary and full details.
- * Summary is the first error line, details is the full cleaned output.
- */
-export function sanitizeToolOutput(output, maxSummaryLength = 140) {
-    if (!output || typeof output !== "string") {
-        return { summary: undefined, details: undefined, truncated: false };
-    }
-    const sanitized = sanitizeOutput(output);
-    const lines = sanitized.split("\n").filter((l) => l.length > 0);
-    if (lines.length === 0) {
-        return { summary: undefined, details: undefined, truncated: false };
-    }
-    // Summary: first line with error indicators, or first line
-    const summary = extractErrorMessage(output);
-    const truncatedSummary = truncateMessage(summary ?? lines[0], maxSummaryLength);
-    // Details: all lines up to a reasonable limit
-    const MAX_DETAIL_LINES = 20;
-    const detailsLines = lines.slice(0, MAX_DETAIL_LINES);
-    const details = detailsLines.join("\n");
-    const truncated = lines.length > MAX_DETAIL_LINES;
-    return {
-        summary: truncatedSummary,
-        details: truncated
-            ? `${details}\n... and ${lines.length - MAX_DETAIL_LINES} more lines`
-            : details,
-        truncated,
-    };
-}

package/dist/clients/scan-utils.js

@@ -1,25 +0,0 @@
-import { collectSourceFiles, collectSourceFilesAsync, } from "./source-filter.js";
-/**
- * Recursively find source files in a directory, respecting common excludes.
- *
- * This function now delegates to `collectSourceFiles()` from the `source-filter`
- * module for unified artifact detection across all scanners.
- *
- * @param dir - Directory to scan
- * @param isTsProject - Deprecated parameter (kept for backward compatibility, not used)
- * @returns Array of absolute file paths that are source files (not build artifacts)
- */
-export function getSourceFiles(dir, _isTsProject) {
-    // Delegate to the unified source-filter module
-    // isTsProject parameter is no longer needed — artifact detection is automatic
-    return collectSourceFiles(dir);
-}
-/**
- * Async, event-loop-friendly twin of {@link getSourceFiles}. Returns the same
- * file list but yields to the loop while walking, so a large tree never holds
- * the loop in one synchronous burst. Background / deferred scanners (todo,
- * project-diagnostics, etc.) should prefer this over the sync version.
- */
-export function getSourceFilesAsync(dir, _isTsProject) {
-    return collectSourceFilesAsync(dir);
-}

package/dist/clients/scratch-tree-policy.js

@@ -1,165 +0,0 @@
-/**
- * Single source of truth for "scratch/cache tree" exclusion, shared by every
- * runner that hands a DIRECTORY to an external binary and lets that binary do
- * its own tree walk.
- *
- * pi-lens's own in-process walkers (`source-filter.ts`/`source-walker.ts`,
- * `getProjectIgnoreMatcher`) already route every entry through
- * `isExcludedDirName`/`EXCLUDED_DIRS` (`file-utils.ts`) — that's how knip,
- * jscpd, and the tree-sitter project scan skip `.pi/`, `node_modules/`, etc.
- * But a runner that shells out with `cwd`/`--source <dir>` and lets the
- * EXTERNAL tool walk (gitleaks `detect --source`, `trivy fs`, `opengrep scan
- * <dir>`) bypasses that walker entirely — the tool sees the raw tree,
- * including pi-ecosystem scratch/data directories that were never meant to be
- * scan targets (#1562: `.pi/greedysearch-sources/` — a gitignored web-research
- * cache — served a `YOUR_API_KEY` doc-example placeholder to the agent as a
- * "leaked secret").
- *
- * This module derives each such runner's native exclude syntax from the SAME
- * `EXCLUDED_DIRS` list `file-utils.ts` already uses for the in-process walk,
- * rather than hand-maintaining a parallel per-tool list (the single-source-of-
- * truth rule that #883 encodes — a hand-copied list is a defect in itself:
- * `dead-code-client.ts`'s `VULTURE_EXCLUDES` had drifted from `EXCLUDED_DIRS`
- * before this fix, e.g. missing `.pi`/`.claude`/`.next`).
- *
- * Deliberately NOT `.gitignore`-based: a secrets scanner (gitleaks, trivy's
- * `secret` scanner) must still see an untracked `.env` with a real credential
- * — `.env` is commonly gitignored, so blanket "respect .gitignore" would hide
- * exactly the file classes these scanners exist to catch (#1562 design note).
- * `EXCLUDED_DIRS` is a narrower, deliberate list of scratch/cache/vendor
- * directory NAMES (`.pi`, `.claude`, `node_modules`, `dist`, …), not a
- * gitignore pattern set.
- *
- * TWO exclusion tiers, not one (#1562 review-round F1) — `EXCLUDED_DIRS`
- * itself conflates two different questions:
- *   - "don't bother INDEXING/LINTING/DEDUPING this" (the walker-parity
- *     exports below, `getScratchTreeGlobPatterns`/`getScratchTreeDirNames`/
- *     `getScratchTreeFnmatchPatterns`) — correctly broad: build output
- *     (`dist`, `build`, `out`, `target`, `coverage`), vendored source
- *     (`vendor`, `third_party`, `vendors`), and editor config (`.vscode`)
- *     are all noise for knip/jscpd/vulture.
- *   - "don't bother looking for SECRETS here" — a much narrower question.
- *     The first cut of this fix reused the walker-parity list for gitleaks's
- *     secrets-lane exclusion too, and a review probe caught it silently
- *     dropping real AWS-shaped secrets seeded in `dist/`, `vendor/`,
- *     `.vscode/`, `build/`, `out/`, `target/`, `third_party/`,
- *     `third-party/`, `coverage/` (0/9 kept, unlogged) — a bundler can bake
- *     a real key into `dist/`, `.vscode/launch.json` commonly carries a
- *     committed debug token, and a vendored tree can carry an upstream
- *     leak. `SECRETS_LANE_SCRATCH_DIR_NAMES`/`getSecretsLaneAllowlistPaths`/
- *     `isUnderSecretsLaneScratchTree` are the narrow tier gitleaks (or any
- *     future gitleaks-shaped secret scanner) must use instead — pi-ecosystem/
- *     agent data dirs, `node_modules`, `.git`, and generic build/package-
- *     manager CACHES only; every real-leak-surface directory above stays
- *     fully in scope.
- */
-import { EXCLUDED_DIRS, getExcludedDirGlobs } from "./file-utils.js";
-import { escapeRegExp } from "./string-utils.js";
-/** Directory-name entries only — drops glob entries (e.g. `*.dSYM`) that a
- * bare directory-name/regex exclude can't express. */
-function literalExcludedDirNames() {
-    return EXCLUDED_DIRS.filter((name) => !name.includes("*") && !name.includes("?"));
-}
-/**
- * `**\/name/**` glob patterns for tools that take doublestar globs
- * (trivy `--skip-dirs`, opengrep/semgrep `--exclude`). Reuses
- * `file-utils.ts`'s own glob derivation so both walkers and shell-out runners
- * stay byte-for-byte in sync.
- */
-export function getScratchTreeGlobPatterns() {
-    return getExcludedDirGlobs();
-}
-/** Bare directory names, for tools (opengrep/semgrep `--exclude`) that treat a
- * slash-free pattern as "this directory name, anywhere in the tree". */
-export function getScratchTreeDirNames() {
-    return literalExcludedDirNames();
-}
-/**
- * Fnmatch-style glob patterns (`star/name/star`, not doublestar) for
- * vulture's `--exclude` — the format `dead-code-client.ts` needs.
- */
-export function getScratchTreeFnmatchPatterns() {
-    return literalExcludedDirNames().map((name) => `*/${name}/*`);
-}
-// --- Secrets-lane tier (#1562 review-round F1) ---
-//
-// Deliberately curated, NOT `EXCLUDED_DIRS`-derived: every name here must be
-// individually justified as "never intentionally holds a first-party
-// credential", not merely "not worth linting". See the module doc above for
-// the walker-parity-vs-secrets-lane distinction and the 9-path probe that
-// caught the original (too-broad) version of this fix.
-export const SECRETS_LANE_SCRATCH_DIR_NAMES = [
-    // pi-ecosystem / coding-agent data + cache directories.
-    ".pi",
-    // The same agent's rebranded config dir (#3112) — pi's config-dir name is
-    // `pkg.piConfig?.configDir || ".pi"`, so `.omp/agent/sessions` is the very
-    // history `.pi/agent/sessions` holds. Without it the secrets lane READS a
-    // project-local session history and can report a key a user pasted into a
-    // transcript as a blocking first-party leak.
-    ".omp",
-    ".pi-lens",
-    ".claude",
-    ".codex",
-    ".agents",
-    ".worktrees",
-    ".rescue",
-    ".gstack",
-    ".superpowers",
-    ".guardrails",
-    ".playwright-cli",
-    ".playwright-mcp",
-    // git's own internal object storage — binary/compressed, not readable
-    // source; a byte-regex scan of it produces garbage, not real findings.
-    ".git",
-    // Vendored/installed npm packages — third-party noise, not a first-party
-    // leak surface (unlike `vendor`/`third_party`, which are vendored SOURCE
-    // a project can carry an upstream leak in and stays in scope).
-    "node_modules",
-    // Generic build/package-manager CACHES — regenerated from source on every
-    // build/install, never a place a human commits a credential on purpose.
-    // Deliberately excludes build OUTPUT (`dist`/`build`/`out`/`target`/
-    // `coverage`) — a bundler/compiler CAN bake a real secret into output.
-    ".turbo",
-    ".cache",
-    ".parcel-cache",
-    ".svelte-kit",
-    ".nuxt",
-    ".yarn",
-    ".pnpm-store",
-    ".gradle",
-    ".next",
-    ".ruff_cache",
-    ".tox",
-    ".pytest_cache",
-    "venv",
-    ".venv",
-    "__pycache__",
-];
-/**
- * Regex patterns for gitleaks's `[allowlist] paths` config array, scoped to
- * the narrow secrets-lane tier above (NOT the walker-parity list — see the
- * module doc). Matched against the finding's relative path.
- *
- * #1562 review-round F4: gitleaks's `File` field preserves the OS-native
- * separator from Go's directory walk — on Windows that's `\`, not `/` — so
- * an anchor of only `(?:^|/)` never matches there. Both separators are
- * accepted in the anchor and in the "rest of path" tail.
- */
-export function getSecretsLaneAllowlistPaths() {
-    return SECRETS_LANE_SCRATCH_DIR_NAMES.map((name) => {
-        const escaped = escapeRegExp(name);
-        return `(?:^|[/\\\\])${escaped}(?:[/\\\\].*)?$`;
-    });
-}
-/**
- * True when any path segment of `relPath` (forward- or back-slash separated)
- * is a secrets-lane scratch dir name. Used for the TS-side post-filter that
- * backstops the generated gitleaks config — belt-and-suspenders because we
- * can't exercise gitleaks's own TOML-regex engine in unit tests, only assert
- * the config we hand it.
- */
-export function isUnderSecretsLaneScratchTree(relPath) {
-    const names = new Set(SECRETS_LANE_SCRATCH_DIR_NAMES.map((n) => n.toLowerCase()));
-    const segments = relPath.split(/[/\\]/).filter(Boolean);
-    return segments.some((segment) => names.has(segment.toLowerCase()));
-}

package/dist/clients/search-read-registration.js

@@ -1,94 +0,0 @@
-/**
- * Register the lines a *search* tool revealed to the agent as reads, so a
- * follow-up edit to those lines is not blocked by the read-guard (#169).
- *
- * Search → edit is a common flow: the agent finds where something must change
- * (ast_grep_search / lsp_navigation / grep), then edits exactly those lines.
- * Those lines were genuinely shown, so they count as read — but ONLY the lines
- * the search actually DELIVERED, never the whole file and never a blanket
- * margin, so editing an unseen region is still guarded (#1904).
- */
-import * as nodeFs from "node:fs";
-import * as path from "node:path";
-import { isPathIgnoredByProject } from "./file-utils.js";
-import { isExternalOrVendorFile } from "./path-utils.js";
-/** Clamp a delivered-context count to a usable non-negative integer. */
-function normalizeMargin(value) {
-    if (value === undefined || !Number.isFinite(value))
-        return undefined;
-    return Math.max(0, Math.floor(value));
-}
-/**
- * #1904 item 2: this was 2, which credited every search hit as a 5-line read
- * even though most searches print ONE line. The guard then let edits pass
- * against lines the model never saw. Credit only delivered lines; callers that
- * DID deliver context pass `contextBefore`/`contextAfter` per location.
- *
- * Note this is not the only slack in the system: `readCoversRange` in
- * read-guard.ts still widens every read record by `config.contextLines` when it
- * tests coverage, so a bare hit remains editable within that configured band.
- */
-const DEFAULT_CONTEXT_MARGIN = 0;
-/**
- * Record each shown location as a read (± context margin). Resolves project-
- * relative paths, skips external/vendor/ignored/non-existent files, and dedupes
- * identical spans. Returns how many reads were recorded.
- */
-export function registerSearchReads(readGuard, locations, opts) {
-    const margin = opts.contextMargin ?? DEFAULT_CONTEXT_MARGIN;
-    const seen = new Set();
-    let recorded = 0;
-    for (const loc of locations) {
-        if (!loc?.file || !Number.isFinite(loc.startLine))
-            continue;
-        const abs = path.isAbsolute(loc.file)
-            ? loc.file
-            : path.resolve(opts.projectRoot, loc.file);
-        if (isExternalOrVendorFile(abs, opts.projectRoot))
-            continue;
-        if (isPathIgnoredByProject(abs, opts.projectRoot, false))
-            continue;
-        try {
-            if (!nodeFs.statSync(abs).isFile())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        const marginBefore = normalizeMargin(loc.contextBefore) ?? margin;
-        const marginAfter = normalizeMargin(loc.contextAfter) ?? margin;
-        const creditReason = marginBefore === 0 && marginAfter === 0
-            ? "match-lines-only"
-            : loc.contextBefore !== undefined || loc.contextAfter !== undefined
-                ? "delivered-context-flags"
-                : "caller-margin";
-        const start = Math.max(1, Math.floor(loc.startLine) - marginBefore);
-        const endLine = Number.isFinite(loc.endLine)
-            ? loc.endLine
-            : loc.startLine;
-        const end = Math.max(start, Math.floor(endLine) + marginAfter);
-        const limit = end - start + 1;
-        const key = `${abs}:${start}:${limit}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        readGuard.recordRead({
-            filePath: abs,
-            requestedOffset: start,
-            requestedLimit: limit,
-            effectiveOffset: start,
-            effectiveLimit: limit,
-            expandedByLsp: false,
-            searchCredit: {
-                marginBefore,
-                marginAfter,
-                reason: creditReason,
-            },
-            turnIndex: opts.turnIndex,
-            writeIndex: opts.writeIndex,
-            timestamp: Date.now(),
-        });
-        recorded++;
-    }
-    return recorded;
-}

package/dist/clients/secret-findings.js

@@ -1,114 +0,0 @@
-/**
- * Cross-source secret-finding dedup (acceptance gate for #131 Mode 3).
- *
- * Hardcoded / committed secrets can be reported by up to three independent
- * pi-lens sources for the *same* line:
- *   - gitleaks       (session scan, #130) — rule id e.g. `aws-access-token`
- *   - trivy secret   (session scan, #131) — rule id e.g. `aws-access-key-id`
- *   - ast-grep rules (per-edit dispatch)  — rule id e.g. `*-hardcoded-secret-*`
- *
- * The existing diagnostic dedup keys on `filePath:line:rule`, so these three
- * have *different* rule ids and would NOT collapse — exactly the triple-report
- * noise that got the old regex secrets-scanner removed (b8f368d). This module
- * collapses by **location** (normalized file + line), keeping the rule/source
- * provenance, so a secret is surfaced once with "detected by gitleaks + trivy +
- * ast-grep" rather than three times.
- *
- * Pure + side-effect-free so the acceptance gate ("one surfaced finding, not
- * three") is a unit test, independent of the turn_end plumbing that consumes it.
- *
- * Refs: #131 (Mode 3), #130
- */
-import { normalizeFilePath } from "./path-utils.js";
-/**
- * Rule-id shape that marks a dispatch warning as a hardcoded-secret finding.
- * Deliberately conservative — the bundled ast-grep secret rules all carry one
- * of these tokens (`*-hardcoded-secret-*`, `*-hardcoded-password-*`,
- * `*-hardcoded-session-key-*`, `*-hardcoded-connection-password-*`, …) so we
- * don't sweep unrelated rules (e.g. a parser rule that merely mentions "token")
- * into the secrets channel.
- */
-const SECRET_RULE_PATTERN = /hardcoded|secret|password|credential/i;
-/** Does this dispatch warning look like a hardcoded-secret finding? */
-export function isSecretWarning(warning) {
-    const id = `${warning.rule ?? ""} ${warning.code ?? ""}`;
-    return SECRET_RULE_PATTERN.test(id);
-}
-/** Location key used to collapse the same secret across sources. */
-export function secretLocationKey(file, line) {
-    return `${normalizeFilePath(file)}:${line}`;
-}
-export function fromGitleaks(findings) {
-    return findings.map((f) => ({
-        file: f.file,
-        line: f.startLine,
-        sources: ["gitleaks"],
-        rule: f.ruleId,
-        description: f.description,
-    }));
-}
-export function fromTrivySecrets(findings) {
-    return findings.map((f) => ({
-        file: f.file,
-        line: f.line,
-        sources: ["trivy"],
-        rule: f.ruleId,
-        description: f.title,
-    }));
-}
-export function fromAstGrepWarnings(warnings) {
-    const out = [];
-    for (const w of warnings) {
-        if (!isSecretWarning(w) || typeof w.line !== "number")
-            continue;
-        out.push({
-            file: w.filePath,
-            line: w.line,
-            sources: ["ast-grep"],
-            rule: w.rule ?? w.code ?? "hardcoded-secret",
-            description: w.message,
-        });
-    }
-    return out;
-}
-// gitleaks > trivy > ast-grep: when the same location is flagged by several
-// scanners we keep the most-specific committed-secret rule id for display.
-const SOURCE_PRIORITY = {
-    gitleaks: 0,
-    trivy: 1,
-    "ast-grep": 2,
-};
-function sortSources(sources) {
-    return [...new Set(sources)].sort((a, b) => SOURCE_PRIORITY[a] - SOURCE_PRIORITY[b]);
-}
-/**
- * Collapse secret findings that share a location (normalized file + line) into
- * one, merging their `sources` and keeping the highest-priority source's rule.
- * Output preserves first-appearance order so surfacing is stable across turns.
- *
- * This is THE cross-source collapse the #131 Mode 3 acceptance gate verifies:
- * the same secret fed in from gitleaks + trivy + ast-grep yields a single
- * finding, not three.
- */
-export function dedupeSecretFindings(findings) {
-    const byKey = new Map();
-    for (const f of findings) {
-        const key = secretLocationKey(f.file, f.line);
-        const incoming = sortSources(f.sources);
-        const existed = byKey.get(key);
-        if (!existed) {
-            byKey.set(key, { ...f, sources: incoming });
-            continue;
-        }
-        // `existed.sources` is kept sorted, so [0] is its current rule's source.
-        const existingTop = SOURCE_PRIORITY[existed.sources[0]];
-        existed.sources = sortSources([...existed.sources, ...incoming]);
-        // Keep the rule from the highest-priority source now present.
-        if (SOURCE_PRIORITY[incoming[0]] < existingTop) {
-            existed.rule = f.rule;
-        }
-        // Fill a missing description from any source.
-        existed.description ??= f.description;
-    }
-    return [...byKey.values()];
-}