@herbertgao/pi-extensions 2026.9.6 → 2026.9.8

package/node_modules/pi-lens/dist/clients/formatters.js

@@ -15,7 +15,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { BoundedLruCache } from "./bounded-cache.js";
 import { createGenerationSource } from "./generation-guard.js";
-import { normalizeMapKey } from "./path-utils.js";
+import { findNearestContaining, normalizeMapKey } from "./path-utils.js";
 import { resolveToolCwd } from "./tool-cwd.js";
 import { resolveCargoPackageEdition } from "./cargo-manifest.js";
 import { resolveKtfmtGradleStyle } from "./gradle-ktfmt-style.js";
@@ -28,6 +28,8 @@ import { compareOrdinal } from "./string-utils.js";
 import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler, } from "./dispatch/runners/utils/availability-policy.js";
 import { findGlobalBinary, findLocalBinUpwards, VENDOR_BIN_DIRS, VENV_BIN_DIRS, } from "./package-manager.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { establishToolAgreement } from "./tool-agreement.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { probeToolAsync } from "./tool-probe.js";
 import { assertInstallAllowed } from "./project-trust.js";
 import { tryLazyInstallForFormatter } from "./dispatch/runners/utils/lazy-installer.js";
@@ -71,6 +73,7 @@ export const SKIP_FORMATTING = "skip-formatting";
  * producer collapsed into an ordinary failed result).
  */
 export const FORMATTER_UNAVAILABLE = "formatter-unavailable";
+export const FORMATTER_AGREEMENT_UNAVAILABLE = "formatter-agreement-unavailable";
 // --- Utility Functions ---
 async function fileExists(filePath) {
     try {
@@ -464,11 +467,17 @@ async function canUseBundleExec(cwd) {
 async function resolveManagedSmartDefaultCommand(formatterName, filePath, args) {
     const toolId = getAutoInstallToolIdForFormatter(formatterName);
     if (!toolId)
-        return null;
+        return FORMATTER_UNAVAILABLE;
     const { ensureTool } = await import("./installer/index.js");
     const installed = await ensureTool(toolId);
-    if (!installed)
-        return null;
+    if (!installed) {
+        recordDegradationOnce({
+            kind: "formatter-unavailable",
+            subject: formatterName,
+            reason: "managed formatter lookup and installation returned no executable",
+        });
+        return FORMATTER_UNAVAILABLE;
+    }
     return [installed, ...args, filePath];
 }
 /** Resolve an explicitly selected formatter from the shared managed-tool seam. */
@@ -568,13 +577,7 @@ function hasExplicitFormatterConfig(formatterName, cwd, ext) {
 export const FORMATTERS_WITH_EXPLICIT_CONFIG_CHECK = new Set(EXPLICIT_FORMATTER_CONFIG_CHECKS.keys());
 // --- Formatter Definitions ---
 async function hasEditorConfig(cwd) {
-    try {
-        await fs.access(path.join(cwd, ".editorconfig"));
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
 }
 async function indentationArgs(filePath, tool, cwd) {
     if ((await hasEditorConfig(cwd)) ||
@@ -592,6 +595,20 @@ async function indentationArgs(filePath, tool, cwd) {
     if (!hasDetectableIndentation(content))
         return null;
     const indentation = detectIndentation(content);
+    if (!indentation) {
+        // #3038: the file HAS indentation, but only nested runs, so no unit can be
+        // proven. The caller turns this into SKIP_FORMATTING — a file the user
+        // expected to be formatted silently is not — so the refusal gets one
+        // bounded row. Subject is the tool (four possible values, recorded once
+        // per session each) rather than the path: a session that edits many such
+        // files must not write one ledger key per file.
+        recordDegradationOnce({
+            kind: "formatter-skip",
+            subject: tool,
+            reason: "indentation evidence is ambiguous; formatter style not pinned",
+        });
+        return null;
+    }
     if (tool === "shfmt")
         return indentation.style === "tab"
             ? ["-i", "0"]
@@ -634,7 +651,7 @@ export function resolveFormatterCwd(absolutePath, formatterName, homeDir = os.ho
         // ceiling prevents it from escaping the user's workspace.
         cwd: path.parse(path.resolve(absolutePath)).root,
         homeDir,
-    });
+    }).cwd;
 }
 /**
  * Every biome invocation must carry this. Biome exits 1 with "No files were
@@ -1123,6 +1140,18 @@ export const gleamFormatter = {
         return false;
     },
 };
+export const typstyleFormatter = {
+    name: "typstyle",
+    command: ["typstyle", "-i", "$FILE"],
+    extensions: [".typ", ".typc"],
+    async resolveCommand(filePath) {
+        const inPath = await which("typstyle");
+        if (inPath)
+            return [inPath, "-i", filePath];
+        return resolveManagedSmartDefaultCommand("typstyle", filePath, ["-i"]);
+    },
+    detect: managedToolDetect("typstyle", undefined, async () => (await which("typstyle")) !== null),
+};
 export const terraformFormatter = {
     name: "terraform",
     command: ["terraform", "fmt", "$FILE"],
@@ -1395,6 +1424,7 @@ export const ALL_FORMATTERS = [
     rubocopFormatter,
     standardrbFormatter,
     gleamFormatter,
+    typstyleFormatter,
     taploFormatter,
     googleJavaFormatFormatter,
     cljfmtFormatter,
@@ -1829,6 +1859,15 @@ export function firstDiagnosticLine(text) {
  * materialized.
  */
 async function resolveFormatterCommand(formatter, absolutePath, cwd) {
+    const agreement = establishToolAgreement(formatter.name, cwd);
+    if (agreement.decision === "decline") {
+        recordDegradationOnce({
+            kind: "formatter-agreement-unavailable",
+            subject: agreement.subject,
+            reason: agreement.reason,
+        });
+        return FORMATTER_AGREEMENT_UNAVAILABLE;
+    }
     const resolved = formatter.resolveCommand
         ? await formatter.resolveCommand(absolutePath, cwd)
         : null;
@@ -1859,7 +1898,7 @@ export async function formatFile(filePath, formatter) {
     try {
         const absolutePath = path.resolve(filePath);
         const cwd = path.dirname(absolutePath);
-        const formatterCwd = resolveFormatterCwd(absolutePath, formatter.name);
+        const formatterCwd = resolveToolCwd("formatter", formatter.name, absolutePath, { cwd: path.parse(absolutePath).root }).cwd;
         const contentBefore = await fs.readFile(absolutePath, "utf-8");
         // Resolve command: prefer local (venv/vendor/node_modules) over global.
         // The shared seam must honor SKIP_FORMATTING before selecting the static
@@ -1882,6 +1921,14 @@ export async function formatFile(filePath, formatter) {
                 error: `${formatter.name}: formatter executable not found`,
             };
         }
+        if (cmd === FORMATTER_AGREEMENT_UNAVAILABLE) {
+            return {
+                success: true,
+                changed: false,
+                outcome: "unavailable",
+                error: `${formatter.name}: project tool agreement could not be established`,
+            };
+        }
         // Run formatter without blocking the event loop.
         const result = await safeSpawnAsync(cmd[0], cmd.slice(1), {
             timeout: 15000,

package/node_modules/pi-lens/dist/clients/generation-guard.js

@@ -45,8 +45,8 @@
  * keyed map it is a compare while nothing has been invalidated, and a
  * normalize plus one `Map.get` once something has. The hand-rolled form it
  * replaces normalized on EVERY call, and this repo's normalizer runs
- * `realpathSync.native` on Windows, so an uninterrupted sweep pays that
- * syscall once rather than once per file. See
+ * `realpathSync.native` on Windows and, since #3098, on POSIX as well, so an
+ * uninterrupted sweep pays that syscall once rather than once per file. See
  * `GenerationMapOptions.normalizeKey` for the correctness reason the slow
  * path exists at all.
  */

package/node_modules/pi-lens/dist/clients/git-guard.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { isPathIgnoredByProject } from "./file-utils.js";
 import { tokenizeShellCommand } from "./bash-file-access.js";
 import { logLatency } from "./latency-logger.js";
+import { resolveLensToolName } from "./tool-config.js";
 import { advisoryFileHash, advisoryPathKey, MAX_ADVISORY_AFFECTED_FILES, snapshotAdvisoryProvenance, } from "./advisory-provenance.js";
 function resolveGuardPath(filePath, cwd) {
     return path.resolve(cwd, filePath);
@@ -819,7 +820,14 @@ export function clearGitGuardTestFailure(cacheManager, cwd, runtime, passedFiles
         fileContentHashes: {},
     });
 }
-export function evaluateGitGuard(runtime, cacheManager, cwd) {
+export function evaluateGitGuard(runtime, cacheManager, cwd, host = "pi") {
+    // #2535 F3: a known tool with no mapping on this host resolves to
+    // undefined — rephrase rather than naming a dead tool. `lens_diagnostics`
+    // is pinned available on both hosts, so the fallback is defensive only.
+    const diagnosticsTool = resolveLensToolName("lens_diagnostics", host);
+    const inspectLine = diagnosticsTool
+        ? `Run ${diagnosticsTool} mode=all for full details, then commit again.`
+        : "Inspect the full diagnostics, then commit again.";
     if (runtime.gitGuardHasBlockers) {
         logDecision(cwd, "blocked", "runtime_blockers", {
             projectSeq: runtime.projectSeq,
@@ -829,7 +837,7 @@ export function evaluateGitGuard(runtime, cacheManager, cwd) {
             : "";
         return {
             block: true,
-            reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.${detail}\nRun lens_diagnostics mode=all for full details, then commit again.`,
+            reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.${detail}\n${inspectLine}`,
         };
     }
     if (runtime.gitGuardCacheUnknownReason) {
@@ -910,6 +918,6 @@ export function evaluateGitGuard(runtime, cacheManager, cwd) {
     });
     return {
         block: true,
-        reason: "🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.\nRun lens_diagnostics mode=all for full details, then commit again.",
+        reason: `🔴 COMMIT BLOCKED (--lens-guard): unresolved blockers must be fixed before commit/push.\n${inspectLine}`,
     };
 }

package/node_modules/pi-lens/dist/clients/indent-retarget.js

@@ -1,3 +1,33 @@
+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.
@@ -7,39 +37,79 @@
  * 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) {
+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 (let i = 0; i < oldLines.length; i += 1) {
-        const oldIndent = oldLines[i].match(/^[\t ]*/)?.[0] ?? "";
-        const correctedIndent = correctedLines[i].match(/^[\t ]*/)?.[0] ?? "";
+    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 non-empty 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.
+    // 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 && (baseFrom === "" || from.length < baseFrom.length)) {
+        if (from.length > 0 &&
+            structuralIndents.has(from) &&
+            (baseFrom === "" || from.length < baseFrom.length)) {
             baseFrom = from;
             baseTo = to;
         }