pi-lens 4.2.1 → 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/install-diagnostics.js

@@ -1,143 +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";
-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(() => {
-        let dir = path.dirname(require.resolve("web-tree-sitter"));
-        while (path.basename(dir) !== "web-tree-sitter" &&
-            dir !== path.dirname(dir)) {
-            dir = path.dirname(dir);
-        }
-        return 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");
-}