pi-lens 4.3.0 → 4.4.0

package/dist/clients/indent-retarget.js

@@ -1,154 +0,0 @@
-import { blockCommentInteriorMask, templateLiteralInteriorMask, } from "./dispatch/indent-detect.js";
-/**
- * Computes both interior masks for `oldLines`, anchored to the real file
- * when `fileContext` resolves cleanly, falling back to the fragment alone
- * otherwise. `blockCommentInteriorMask` has no fragment-ambiguity to correct
- * (a lone `*\/` cannot be mistaken for an opener the way a lone backtick
- * can), so it always runs file-anchored when a file is available — this is
- * about `templateLiteralInteriorMask` specifically, but both take the same
- * path for one lexing pass over consistent line numbers.
- */
-function computeInteriorMasks(oldLines, fileContext) {
-    if (fileContext) {
-        const fileLines = fileContext.content.replace(/\r\n/g, "\n").split("\n");
-        const start = fileContext.startLine - 1;
-        const end = start + oldLines.length;
-        if (start >= 0 && end <= fileLines.length) {
-            return {
-                commentInterior: blockCommentInteriorMask(fileLines).slice(start, end),
-                templateInterior: templateLiteralInteriorMask(fileLines).slice(start, end),
-            };
-        }
-        // startLine/length don't fit inside content — the caller resolved a
-        // stale or mismatched range; fall through to the fragment-only path
-        // rather than slicing out of bounds.
-    }
-    return {
-        commentInterior: blockCommentInteriorMask(oldLines),
-        templateInterior: templateLiteralInteriorMask(oldLines),
-    };
-}
-/**
- * Retargets the leading-whitespace style of newText to match the indentation
- * correction that was applied to oldText.
- *
- * Builds a mapping from oldText indentation strings to their corrected forms,
- * then extends it to cover deeper nesting levels (n × baseUnit → n × correctedUnit).
- * Returns undefined — leaving newText unchanged — when any non-blank line in
- * newText has indentation that cannot be resolved, to avoid producing
- * mixed-indentation output.
- *
- * A line inside a terminated `/* … *\/` block comment, or inside a
- * multi-line template literal, still gets an exact entry in the map — a
- * replacement that reintroduces that SAME indent (adding another JSDoc
- * continuation, or another template line, say) still resolves by direct
- * lookup — but that indent is never eligible to be picked as the shortest
- * ("base") unit and extrapolated to a deeper level `newText` adds that
- * oldText never showed: its leading space is alignment (on the comment
- * opener's `*` column, or on the template string's own content), not a
- * nesting unit, and that alignment's ratio can differ from the code's own
- * indentation ratio, silently mis-scaling every such deeper line (#3052,
- * #3116). Uses the same lexer as `clients/dispatch/indent-detect.ts`'s
- * `detectIndentation` (#3039, #3059) rather than a second one.
- *
- * `fileContext`, when the caller has it, anchors that lexer to the real file
- * (see {@link IndentRetargetFileContext}) so a template boundary the
- * oldText fragment crosses is read correctly instead of ambiguously. Without
- * it (match position unknown — the caller never found a unique file span,
- * or is calling with a synthetic fragment that has no backing file), the
- * masks fall back to running over the fragment alone, which is exact for a
- * block comment (`*\/` cannot be mistaken for an opener) but can misread a
- * template literal whose opener or closer lies outside the fragment.
- */
-export function retargetReplacementIndentation(newText, oldText, correctedOldText, fileContext) {
-    const newline = newText.includes("\r\n") ? "\r\n" : "\n";
-    const oldLines = oldText.replace(/\r\n/g, "\n").split("\n");
-    const correctedLines = correctedOldText.replace(/\r\n/g, "\n").split("\n");
-    if (oldLines.length !== correctedLines.length)
-        return undefined;
-    const { commentInterior, templateInterior } = computeInteriorMasks(oldLines, fileContext);
-    const indentMap = new Map();
-    // oldIndent keys backed by at least one line OUTSIDE a comment or
-    // template-literal interior — the only keys eligible to be picked as the
-    // base unit below. An interior line still lands in indentMap (exact-width
-    // lookups must still resolve, #3052 F1), it just cannot anchor the
-    // extrapolation.
-    const structuralIndents = new Set();
-    const ambiguousIndents = new Set();
-    for (const [i, oldLine] of oldLines.entries()) {
-        // oldLines.length === correctedLines.length is checked above; the "" is
-        // unreachable, only satisfying noUncheckedIndexedAccess.
-        const correctedLine = correctedLines[i] ?? "";
-        const oldIndent = oldLine.match(/^[\t ]*/)?.[0] ?? "";
-        const correctedIndent = correctedLine.match(/^[\t ]*/)?.[0] ?? "";
-        if (oldIndent === correctedIndent)
-            continue;
-        const previous = indentMap.get(oldIndent);
-        if (previous !== undefined && previous !== correctedIndent) {
-            indentMap.delete(oldIndent);
-            structuralIndents.delete(oldIndent);
-            ambiguousIndents.add(oldIndent);
-            continue;
-        }
-        if (!ambiguousIndents.has(oldIndent)) {
-            indentMap.set(oldIndent, correctedIndent);
-            if (!commentInterior[i] && !templateInterior[i]) {
-                structuralIndents.add(oldIndent);
-            }
-        }
-    }
-    if (indentMap.size === 0)
-        return undefined;
-    // Find the shortest structurally-backed mapped key as the base unit so
-    // that nesting levels in newText that are deeper than anything in
-    // oldText can be remapped as n × baseFrom → n × baseTo. A key backed
-    // only by comment- or template-interior lines is skipped here (but stays
-    // in indentMap for direct lookups above).
-    let baseFrom = "";
-    let baseTo = "";
-    for (const [from, to] of indentMap) {
-        if (from.length > 0 &&
-            structuralIndents.has(from) &&
-            (baseFrom === "" || from.length < baseFrom.length)) {
-            baseFrom = from;
-            baseTo = to;
-        }
-    }
-    function resolveIndent(indent) {
-        if (indent === "")
-            return "";
-        const direct = indentMap.get(indent);
-        if (direct !== undefined)
-            return direct;
-        if (baseFrom.length > 0 &&
-            indent.length % baseFrom.length === 0 &&
-            baseFrom.repeat(indent.length / baseFrom.length) === indent) {
-            return baseTo.repeat(indent.length / baseFrom.length);
-        }
-        return undefined;
-    }
-    let changed = false;
-    const newLines = newText.replace(/\r\n/g, "\n").split("\n");
-    const retargetedLines = [];
-    for (const line of newLines) {
-        const indent = line.match(/^[\t ]*/)?.[0] ?? "";
-        if (indent === line) {
-            // Blank / whitespace-only line — preserve as-is.
-            retargetedLines.push(line);
-            continue;
-        }
-        const resolved = resolveIndent(indent);
-        if (resolved === undefined) {
-            // Indentation can't be resolved — abort to avoid mixed-indentation output.
-            return undefined;
-        }
-        if (resolved !== indent) {
-            changed = true;
-            retargetedLines.push(resolved + line.slice(indent.length));
-        }
-        else {
-            retargetedLines.push(line);
-        }
-    }
-    return changed ? retargetedLines.join(newline) : undefined;
-}

package/dist/clients/inline-blocker-dispositions.js

@@ -1,186 +0,0 @@
-/**
- * Disposition/rule/inline-suppression policy for the turn-end
- * "Unresolved from this turn" blocker replay (#3246).
- *
- * `runtime-turn.ts` re-serves every live `InlineBlockerRecord` the turn's
- * dispatches left behind. Until this module, it pushed the record's
- * ALREADY-RENDERED `summary` string verbatim, so a `lens_diagnostic_mark`
- * made after the record was written had nothing to act on: the durable
- * disposition store was honored by `lens_diagnostics`, the widget, the cached
- * scanner lanes, late auxiliary and cascade, while this one surface replayed
- * the pre-mark text on every later turn — including turns that edited only an
- * unrelated file. That is #3246's report.
- *
- * The fix is the same shape `blocker-past-eof.ts` already argued for the
- * `lines` field: carry the STRUCTURED diagnostics the summary was rendered
- * from (`dispatchResult.blockers`, via `PipelineResult.inlineBlockerDiagnostics`
- * and `InlineBlockerRecord.diagnostics`) and re-derive at read time, rather
- * than regex-parsing a string built for human display. With the diagnostics in
- * hand this module runs the ONE filter stack every other findings surface runs
- * — `clients/dispatch/finding-policy.ts`'s inline `pi-lens-ignore` → stored
- * dispositions → `.pi-lens.json` rule policy — against the file's CURRENT
- * bytes, and re-renders the survivors with `formatDiagnostics(..., "blocking")`,
- * the SAME renderer `dispatcher.ts` used to build the stored summary. No second
- * anchor implementation and no second renderer: an unmarked record therefore
- * re-renders byte-identically to what dispatch produced.
- *
- * Ordering (#3246 mutation (c)): the policy runs over the WHOLE candidate set
- * and `formatDiagnostics` applies its 10-row display cap to the survivors.
- * Filtering after the cap would leave a marked finding occupying a display slot
- * and hide an unmarked one behind "... and N more" — the cap-before-policy
- * shape `cascade-format.ts` already avoids.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { hasAnyDispositionMarks } from "./diagnostic-dispositions.js";
-import { applyFindingPolicy, inlineBlockerIdentities, loadProjectRulePolicyMap, } from "./dispatch/finding-policy.js";
-import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
-import { formatDiagnostics } from "./dispatch/utils/format-utils.js";
-/**
- * The file's CURRENT bytes, or `""` when they cannot be read.
- *
- * `""` is `FindingPolicyOptions.content`'s documented fail-open input: inline
- * suppression becomes a no-op and the STRICT anchor hashes an empty line, so it
- * cannot match a mark made against real content and the finding stays VISIBLE.
- * Never hide a blocking finding over an I/O error (AGENTS.md shape 48).
- */
-function readCurrentContent(filePath) {
-    try {
-        return fs.readFileSync(filePath, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-/**
- * Apply the shared finding policy to one live inline-blocker record.
- *
- * Diagnostics are grouped by the file they were raised AGAINST, not by the
- * record's own path: `dispatchResult.blockers` is pooled across every runner
- * dispatched for the edited file, and a chart-wide runner (helm-lint,
- * helm-render) reports blocking diagnostics against sibling files — the same
- * cross-file population `pipeline.ts` filters out of `inlineBlockerLines`.
- * Anchoring those against the record's path would derive the wrong strict
- * anchor and read the wrong file's `pi-lens-ignore` comments.
- */
-export function applyInlineBlockerPolicy(record, cwd) {
-    const diagnostics = record.diagnostics;
-    if (!diagnostics || diagnostics.length === 0) {
-        // Bounded per (kind, subject) by the ledger itself — this condition
-        // recurs every turn end for the same record, so a counted row would
-        // grow without adding information (AGENTS.md shapes 13/17). Recorded
-        // ONLY when the project actually holds marks: with an empty store there
-        // is nothing this record failed to honor, and a row every session for
-        // every unstructured record would be noise, not a degradation.
-        if (hasAnyDispositionMarks(cwd)) {
-            recordDegradationOnce({
-                kind: "inline-blocker-unstructured",
-                subject: `inline-blocker:${toRunnerDisplayPath(cwd, record.filePath)}`,
-                reason: "record carries no structured diagnostics; disposition marks cannot be applied to its rendered summary",
-            });
-        }
-        return {
-            body: record.summary,
-            candidates: 0,
-            kept: 0,
-            suppressed: 0,
-            unstructured: true,
-        };
-    }
-    const byFile = new Map();
-    for (const diagnostic of diagnostics) {
-        // Resolved against the PROJECT root, never `process.cwd()`: a runner that
-        // reports a project-relative path would otherwise be grouped under the
-        // agent host's working directory and read the wrong file's bytes. No
-        // case/separator fold on the key (catalog shape 1): two spellings of one
-        // file would only cost a duplicate read here — `anchorsForDiagnostic`
-        // canonicalizes both the cwd and the file path itself, so the anchors,
-        // and therefore the verdict, are identical either way.
-        const owner = path.resolve(cwd, diagnostic.filePath);
-        const group = byFile.get(owner);
-        if (group)
-            group.push(diagnostic);
-        else
-            byFile.set(owner, [diagnostic]);
-    }
-    // `loadPiLensProjectConfig` is mtime-cached, so several groups cost one stat.
-    const policyMap = loadProjectRulePolicyMap(cwd);
-    const dropped = new Set();
-    for (const [filePath, group] of byFile) {
-        const { kept } = applyFindingPolicy(group, {
-            cwd,
-            filePath,
-            content: readCurrentContent(filePath),
-            policyMap,
-            identities: inlineBlockerIdentities,
-        });
-        const survivors = new Set(kept);
-        for (const diagnostic of group) {
-            if (!survivors.has(diagnostic))
-                dropped.add(diagnostic);
-        }
-    }
-    const kept = dropped.size === 0
-        ? [...diagnostics]
-        : diagnostics.filter((diagnostic) => !dropped.has(diagnostic));
-    return {
-        body: kept.length === 0
-            ? undefined
-            : formatDiagnostics(kept, "blocking").trim(),
-        candidates: diagnostics.length,
-        kept: kept.length,
-        suppressed: dropped.size,
-        unstructured: false,
-    };
-}
-/**
- * How many file/tool identities {@link summarizeInlineBlockerPolicy}'s one
- * per-turn record names. The COUNTS are always exact; only the identity lists
- * are capped, so a turn that touched a hundred files writes a bounded row
- * rather than a file listing (AGENTS.md shape 17).
- */
-const IDENTITY_CAP = 10;
-/**
- * The ONE bounded record the turn writes for this pass — never one per
- * finding. Derived here rather than accumulated at the call site so the shape
- * and its bound live with the policy they describe.
- */
-export function summarizeInlineBlockerPolicy(entries) {
-    const files = [];
-    const tools = new Set();
-    let stale = 0;
-    let candidates = 0;
-    let kept = 0;
-    let suppressed = 0;
-    let unstructured = 0;
-    for (const entry of entries) {
-        for (const tool of entry.sources ?? [])
-            tools.add(tool);
-        if (entry.stale)
-            stale += 1;
-        const outcome = entry.outcome;
-        if (outcome === undefined)
-            continue;
-        candidates += outcome.candidates;
-        kept += outcome.kept;
-        suppressed += outcome.suppressed;
-        if (outcome.unstructured)
-            unstructured += 1;
-        // The files a mark actually acted on — the identity a reader needs to
-        // reconstruct a replay report.
-        if (outcome.suppressed > 0 && files.length < IDENTITY_CAP) {
-            files.push(entry.displayPath);
-        }
-    }
-    return {
-        records: entries.length,
-        stale,
-        candidates,
-        kept,
-        dispositionSuppressed: suppressed,
-        unstructured,
-        files,
-        tools: [...tools].slice(0, IDENTITY_CAP),
-    };
-}

package/dist/clients/install-diagnostics.js

@@ -1,156 +0,0 @@
-/**
- * Install/runtime diagnostics — a paste-able environment fingerprint for bug
- * reports about extension load failures (#285/#335: `ResolveMessage: Cannot
- * find package …`).
- *
- * This module is deliberately self-contained and dependency-free: it only
- * RESOLVES specifiers (never imports them), reads package.json, and stats files.
- * So it loads and reports correctly even when the very deps that failed (e.g.
- * `typescript`) are unreachable — which is exactly when we need it. Every probe
- * is best-effort and never throws.
- */
-import { createRequire } from "node:module";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-// The shared web-tree-sitter ladder imports nothing but node:fs/node:path, so
-// importing it keeps this module's "loads even when the deps that failed are
-// unreachable" property intact.
-import { resolveWebTreeSitterPackageDir } from "../scripts/lib/web-tree-sitter-dir.mjs";
-const require = createRequire(import.meta.url);
-const ISSUES_URL = "https://github.com/apmantza/pi-lens/issues";
-/** Runtime third-party deps whose resolution is the documented failure surface. */
-const CRITICAL_DEPS = [
-    "typescript",
-    "minimatch",
-    "typebox",
-    "js-yaml",
-    "vscode-jsonrpc",
-    "web-tree-sitter",
-    "@ast-grep/napi",
-];
-function safe(fn, fallback) {
-    try {
-        return fn();
-    }
-    catch {
-        return fallback;
-    }
-}
-/** Gather the environment fingerprint. Never throws. */
-export function collectInstallDiagnostics() {
-    const notes = [];
-    const here = safe(() => path.dirname(fileURLToPath(import.meta.url)), "");
-    const pkgDir = safe(() => path.resolve(here, ".."), here); // dist/clients -> dist; good enough as anchor
-    // Walk up to the real package root (dir holding our package.json).
-    let root = pkgDir;
-    for (let i = 0; i < 6; i++) {
-        if (safe(() => fs.existsSync(path.join(root, "package.json")), false))
-            break;
-        const up = path.dirname(root);
-        if (up === root)
-            break;
-        root = up;
-    }
-    const piLensVersion = safe(() => {
-        const pj = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-        return String(pj.version ?? "unknown");
-    }, "unknown");
-    const bunVersion = globalThis.Bun
-        ?.version;
-    const runtime = bunVersion
-        ? `bun ${bunVersion}`
-        : `node ${process.versions.node}`;
-    const platform = `${process.platform}-${process.arch}`;
-    const pkgRealDir = safe(() => fs.realpathSync(root), root);
-    const behindSymlink = pkgRealDir !== root;
-    let packageManager = "unknown";
-    if (pkgRealDir.includes(`${path.sep}.pnpm${path.sep}`) || behindSymlink) {
-        packageManager = "pnpm-symlinked";
-    }
-    else if (safe(() => fs.existsSync(path.join(root, "node_modules", "typescript")), false)) {
-        packageManager = "nested";
-    }
-    else {
-        packageManager = "npm-hoisted";
-    }
-    const deps = CRITICAL_DEPS.map((name) => {
-        try {
-            return { name, resolved: true, resolvedPath: require.resolve(name) };
-        }
-        catch (err) {
-            return {
-                name,
-                resolved: false,
-                error: `${err?.code ?? ""} ${err?.message ?? String(err)}`.trim(),
-            };
-        }
-    });
-    const astGrepCli = safe(() => {
-        const cliPkg = require.resolve("@ast-grep/cli/package.json");
-        const dir = path.dirname(cliPkg);
-        return ["ast-grep", "ast-grep.exe", "sg", "sg.exe"].some((b) => fs.existsSync(path.join(dir, b)));
-    }, false);
-    const grammars = safe(() => {
-        // #3409 (sweep sibling of the same shape): this probe used to walk up from
-        // the BARE `web-tree-sitter` specifier, so on the host pi ships — a `bun
-        // build --compile` binary, where a bare specifier throws MODULE_NOT_FOUND
-        // — it reported `grammars: false` for an install whose grammars were
-        // present. The one report a user pastes when the long tail of grammars is
-        // dead has to measure the same directory the client does, through the same
-        // ladder.
-        const dir = resolveWebTreeSitterPackageDir({
-            resolve: (specifier) => require.resolve(specifier),
-            // `root` is this probe's own walk to the package root, computed above.
-            packageRoot: () => root,
-            cwd: () => process.cwd(),
-        });
-        return (!!dir &&
-            fs.existsSync(path.join(dir, "grammars", "tree-sitter-typescript.wasm")));
-    }, false);
-    if (deps.some((d) => !d.resolved)) {
-        notes.push("One or more runtime dependencies did not resolve. This is the #285/#335 failure mode — usually a package-manager layout (pnpm symlink store / nested install) the runtime's resolver can't traverse, or an outdated runtime.");
-    }
-    if (!astGrepCli || !grammars) {
-        notes.push("ast-grep CLI and/or tree-sitter grammars are missing — pnpm/bun skip lifecycle scripts by default, so the postinstall that fetches them did not run.");
-    }
-    return {
-        piLensVersion,
-        runtime,
-        platform,
-        packageManager,
-        pkgDir: root,
-        pkgRealDir,
-        behindSymlink,
-        deps,
-        astGrepCli,
-        grammars,
-        notes,
-    };
-}
-/** Render a compact, paste-able diagnostic block for a bug report. */
-export function formatInstallDiagnostics(diag = collectInstallDiagnostics(), cause) {
-    const lines = [];
-    lines.push("──────── pi-lens install diagnostics ────────");
-    if (cause) {
-        const msg = cause?.message ?? String(cause);
-        lines.push(`LOAD ERROR: ${msg}`);
-    }
-    lines.push(`pi-lens:   ${diag.piLensVersion}`);
-    lines.push(`runtime:   ${diag.runtime}`);
-    lines.push(`platform:  ${diag.platform}`);
-    lines.push(`install:   ${diag.packageManager}${diag.behindSymlink ? " (behind symlink)" : ""}`);
-    lines.push(`pkg dir:   ${diag.pkgDir}`);
-    if (diag.behindSymlink)
-        lines.push(`real dir:  ${diag.pkgRealDir}`);
-    lines.push("deps:");
-    for (const d of diag.deps) {
-        lines.push(`  ${d.resolved ? "ok  " : "FAIL"} ${d.name}${d.error ? ` — ${d.error}` : ""}`);
-    }
-    lines.push(`assets:    ast-grep-cli=${diag.astGrepCli ? "ok" : "MISSING"} grammars=${diag.grammars ? "ok" : "MISSING"}`);
-    for (const n of diag.notes)
-        lines.push(`note: ${n}`);
-    lines.push(`Please paste this into a report at ${ISSUES_URL}`);
-    lines.push("─────────────────────────────────────────────");
-    return lines.join("\n");
-}