@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/extension-log.js

@@ -0,0 +1,432 @@
+/**
+ * Terminal-safe diagnostic sink for the in-pi extension path (#1333).
+ *
+ * pi owns the terminal: it runs the TTY in raw mode and repaints with
+ * cursor-addressed diffs, so ANY byte an extension writes to stdout/stderr
+ * lands mid-frame and desyncs pi's model of the screen — the layout stays
+ * broken until a full repaint. `clients/`, `tools/`, `index.ts` and `i18n.ts`
+ * are all reachable from the extension entry, so none of them may call
+ * `console.*` or `process.std*.write`. (`mcp/`, `scripts/` and `bin/` DO own
+ * their stdout contract and keep their writes.)
+ *
+ * This module is the general-purpose replacement sink: one `createNdjsonLogger`
+ * instance over `<global pi-lens dir>/extension.log`, per the single-writer
+ * invariant in AGENTS.md. Subsystems that already own a log (tree-sitter,
+ * review-graph, cascade, latency, sessionstart) route to THAT log instead —
+ * this file is for the areas that had no sink at all.
+ *
+ * Three-channels rule (#482/#484/#485): everything written here is
+ * LOG-audience. A genuinely user-facing degradation must ALSO reach the human
+ * through the host's own render path (`ctx.ui.notify` / a display-only session
+ * entry) — never a raw write.
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as path from "node:path";
+import { isTestMode } from "./env-utils.js";
+import { getGlobalPiLensDir } from "./file-utils.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
+import { createNdjsonLogger } from "./ndjson-logger.js";
+export const EXTENSION_LOG_FILE = path.join(getGlobalPiLensDir(), "extension.log");
+const writer = createNdjsonLogger({
+    filePath: EXTENSION_LOG_FILE,
+    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+});
+export function logExtension(entry) {
+    if (isTestMode())
+        return;
+    writer.log({
+        ts: new Date().toISOString(),
+        pid: process.pid,
+        level: entry.level ?? "error",
+        subsystem: entry.subsystem,
+        message: entry.message,
+        ...(entry.metadata ? { metadata: entry.metadata } : {}),
+    });
+}
+export function createSubsystemLogger(subsystem, defaultLevel = "debug") {
+    const at = (level) => (message, metadata) => {
+        logExtension({ subsystem, message, level, metadata });
+    };
+    const logger = at(defaultLevel);
+    logger.error = at("error");
+    logger.warn = at("warn");
+    logger.debug = at("debug");
+    return logger;
+}
+/** No-op with the `SubsystemLogger` shape, for the verbose-off branch. */
+export function noopSubsystemLogger() {
+    const noop = (() => { });
+    noop.error = () => { };
+    noop.warn = () => { };
+    noop.debug = () => { };
+    return noop;
+}
+export function getExtensionLogPath() {
+    return EXTENSION_LOG_FILE;
+}
+/** Resolve once all enqueued extension-log writes are on disk (tests/shutdown). */
+export function flushExtensionLog() {
+    return writer.flush();
+}
+/** Teardown-only: force queued entries to disk before the process exits. */
+export function flushExtensionLogSync() {
+    writer.flushSync();
+}
+// --- Defense in depth: the console reroute -----------------------------------
+const CONSOLE_METHODS = [
+    "log",
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "dir",
+];
+let consoleGuardInstalled = false;
+/** The console methods captured before the patch, for an exact restore. */
+const originalConsoleMethods = new Map();
+/** The replacements this module installed, so uninstall never clobbers a later patch. */
+const installedConsoleMethods = new Map();
+/**
+ * The async capture window (#1434).
+ *
+ * The guard must catch pi-lens's own writes without swallowing the host's. pi's
+ * one-shot CLI commands print through `console.log`, so a permanent global
+ * reroute makes `pi list` print nothing in any project whose cwd loads the
+ * extension first. The store answers "is pi-lens executing right now?" and
+ * `AsyncLocalStorage` carries that answer into every promise, timer and
+ * callback created inside the window — so an async handler still captures after
+ * an `await`, while host code outside the window keeps its real sink.
+ *
+ * Built LAZILY (S1b, #1434 review): an active `AsyncLocalStorage` enables an
+ * async_hooks init hook for every promise in the process on Node 22 — the same
+ * hazard `tree-sitter-client.ts`'s `parseCacheMeasurement.disable()` comment
+ * documents — so constructing one at module scope taxes every `await` in the
+ * host even when the kill switch (`PI_LENS_CONSOLE_GUARD=0`) or test mode means
+ * the guard never installs and nothing ever reads the store. Construction is
+ * deferred to the first `runInConsoleCaptureWindow` call, and only happens once
+ * `installConsoleGuard()` has actually installed (never under the kill switch
+ * or test mode, since `consoleGuardInstalled` stays false in both).
+ */
+let consoleCaptureStorage;
+function getConsoleCaptureStorage() {
+    if (!consoleGuardInstalled)
+        return undefined;
+    if (consoleCaptureStorage === undefined) {
+        consoleCaptureStorage = new AsyncLocalStorage();
+    }
+    return consoleCaptureStorage;
+}
+/**
+ * Module evaluation is the one window `AsyncLocalStorage` cannot wrap: the
+ * module graph is evaluated by the loader, not by a pi-lens call. It is
+ * synchronous, so a plain flag is enough (#1333's original concern — a
+ * transitively loaded dependency writing during its own init).
+ */
+let moduleLoadWindowOpen = false;
+/**
+ * True while pi-lens owns execution, so console writes belong in the log.
+ *
+ * `consoleCaptureStorage` may not have been constructed yet (S1b) — that state
+ * means "no window was ever opened through `runInConsoleCaptureWindow`", i.e.
+ * the same as an empty store, so it reads as "no window" rather than throwing.
+ */
+export function isConsoleCaptureActive() {
+    return (moduleLoadWindowOpen || consoleCaptureStorage?.getStore() === true);
+}
+/**
+ * Open the module-evaluation window. Called by `clients/console-guard-install.ts`
+ * before any other pi-lens module evaluates.
+ *
+ * The window closes explicitly at the end of `index.ts`. The backstop below
+ * closes it anyway if that never runs (an import throws, or the entry changes
+ * shape), because a leaked window would capture the host's output — the very
+ * bug this design fixes. Module evaluation is synchronous, so the end of the
+ * current macrotask is always past it. The timer is unref'd, so it can never
+ * hold a one-shot CLI process open (defect shape 4).
+ */
+export function openModuleLoadConsoleWindow() {
+    if (moduleLoadWindowOpen)
+        return;
+    moduleLoadWindowOpen = true;
+    const backstop = setImmediate(() => {
+        moduleLoadWindowOpen = false;
+    });
+    backstop.unref?.();
+}
+/** Close the module-evaluation window. Idempotent. */
+export function closeModuleLoadConsoleWindow() {
+    moduleLoadWindowOpen = false;
+}
+/**
+ * Run `fn` inside a capture window. Console writes from `fn`, and from anything
+ * `fn` schedules, go to the extension log instead of the terminal.
+ *
+ * When the guard was never installed (kill switch or test mode), there is
+ * nothing for a window to gate — `installConsoleGuard`'s own dispatcher is the
+ * only reader of `isConsoleCaptureActive()`, and it short-circuits before that
+ * call in both cases. Skip constructing the `AsyncLocalStorage` (S1b) and run
+ * `fn` directly.
+ */
+export function runInConsoleCaptureWindow(fn) {
+    const storage = getConsoleCaptureStorage();
+    if (!storage)
+        return fn();
+    return storage.run(true, fn);
+}
+function inCaptureWindow(fn) {
+    return function (...args) {
+        return runInConsoleCaptureWindow(() => fn.apply(this, args));
+    };
+}
+/**
+ * True for every host API member that can hand pi-lens's own functions back to
+ * the host to be called later: `on(event, handler)` and any `register*`
+ * method (`registerTool`, `registerCommand`, `registerMessageRenderer`,
+ * `registerShortcut`, `registerFlag`, `registerMarkdownTransformer`,
+ * `registerEntryRenderer`, `registerProvider`, and any the host adds later).
+ *
+ * This is a DENY-LIST, not an allow-list (#1434 S1a review): every member
+ * matching this predicate gets its function arguments wrapped, with no
+ * per-method exemption. The earlier allow-list form (only `on` and
+ * `registerTool`) let the 9 `registerCommand` call sites and
+ * `registerMessageRenderer` bypass the window, regressing #1333 for those
+ * paths — a host callback fired for one of them would still write straight to
+ * the terminal.
+ */
+function isCaptureSeam(prop) {
+    return prop === "on" || (typeof prop === "string" && prop.startsWith("register"));
+}
+/**
+ * Wrap every function value found in `value`, in place. Handles the two
+ * shapes a `register*`/`on` call takes today: a function passed directly
+ * (`on(event, handler)`, `registerMessageRenderer(type, fn)`), and a
+ * function ONE level inside a plain options/definition object
+ * (`options.handler`, `tool.execute`).
+ *
+ * Deliberately NOT recursive past that one level (#1434 perf review): a tool
+ * definition's `parameters`/`schema` is a large, deeply nested TypeBox object
+ * that holds no functions, but walking its full tree on every `registerTool`
+ * call — across every tool, on every extension activation, across the many
+ * test files that re-activate the extension per case — measurably slowed
+ * activation (a wiring test tripped its 5s budget under transform load; see
+ * the commit body for the measured before/after). Checking only the
+ * argument's own top-level keys is O(keys), independent of how deep an
+ * unrelated nested value's own structure goes, and covers every shape
+ * PI-LENS actually registers (`options.handler`, `tool.execute` — never two
+ * levels deep). It does NOT cover every shape the host's `ExtensionAPI` type
+ * permits: `registerProvider`'s `config.oauth.*` callbacks sit two levels
+ * deep and `config.models[]` sits behind a skipped array. pi-lens never
+ * calls `registerProvider`; extend the descent if that changes (same known-
+ * gap convention as the `pi.events` note in AGENTS.md).
+ *
+ * Mutates the object in place rather than copying — a spread copy would drop
+ * non-enumerable or prototype-carried members of a definition object (defect
+ * shape 5), and these definitions are pi-lens's own, built just above the
+ * register call.
+ */
+function wrapFunctionsInPlace(value) {
+    if (typeof value === "function") {
+        return inCaptureWindow(value);
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return value;
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+        const propValue = obj[key];
+        if (typeof propValue === "function") {
+            assignWrapped(obj, key, propValue);
+        }
+    }
+    return value;
+}
+/**
+ * Assign a wrapped function back onto `obj[key]`, degrading instead of
+ * throwing or dropping the registration when the property resists (S2b).
+ * ESM is always strict mode, so assigning into a non-writable data property
+ * throws a `TypeError`; `Object.defineProperty` is tried next (it can
+ * redefine a configurable-but-non-writable property); if both fail the
+ * property is frozen solid, so the ORIGINAL unwrapped function is left in
+ * place — the registration still succeeds, just without the console-capture
+ * net for that one callback, which is strictly better than the tool/command
+ * never registering at all.
+ */
+function assignWrapped(obj, key, fn) {
+    const wrapped = inCaptureWindow(fn);
+    try {
+        obj[key] = wrapped;
+        return;
+    }
+    catch {
+        // Non-writable data property — fall through to defineProperty.
+    }
+    try {
+        Object.defineProperty(obj, key, {
+            value: wrapped,
+            writable: true,
+            configurable: true,
+            enumerable: true,
+        });
+    }
+    catch {
+        // Frozen solid: leave the original unwrapped function in place rather
+        // than throwing (which would abort the whole register call) or silently
+        // dropping it.
+    }
+}
+/**
+ * Wrap the host extension API so every pi-lens entry point runs in a capture
+ * window.
+ *
+ * pi calls our event handlers and tool bodies from its own async context, so a
+ * window opened during registration does not reach them. Wrapping every
+ * `register*`/`on` seam (see `isCaptureSeam`) covers every current and future
+ * handler from one place, instead of a hand-maintained list of call sites.
+ * Everything else forwards untouched, except it is bound to `target` (S3a) so
+ * a destructured reference (`const { getFlag } = pi`) keeps working, and
+ * wrapper functions are memoized per-proxy in `wrapperCache` (S3b) so
+ * `proxy.on === proxy.on` — code that compares handler identity, or a test
+ * asserting a mock was called with a specific function reference across two
+ * reads of the same property, sees a stable value.
+ */
+export function withConsoleCaptureWindows(api) {
+    const wrapperCache = new Map();
+    const proxy = new Proxy(api, {
+        get(target, prop) {
+            // A non-configurable, non-writable OWN data property is a proxy
+            // invariant: the get trap MUST return the exact value the target
+            // holds, or the engine throws a TypeError on read. Degrade to the raw
+            // value instead of tripping that invariant (S2a) — a frozen host API
+            // loses the capture window for that member, but keeps working.
+            const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+            if (descriptor && descriptor.writable === false && descriptor.configurable === false) {
+                return descriptor.value;
+            }
+            const cached = wrapperCache.get(prop);
+            if (cached !== undefined)
+                return cached;
+            const value = Reflect.get(target, prop, target);
+            if (typeof value !== "function")
+                return value;
+            const method = value;
+            // A host that returns `this` for chaining would hand back the raw API,
+            // so a chained `on(...).on(...)` would register an unwrapped handler.
+            // Keep the proxy on the chain.
+            const keepProxy = (result) => result === target ? proxy : result;
+            // Pass-through members are cached too (S3a/S3b: `proxy.getFlag ===
+            // proxy.getFlag`), but the cached wrapper re-reads `target[prop]` on
+            // EVERY call rather than closing over `method` -- a plain
+            // `method.bind(target)` pins the function reference captured at first
+            // access, so a host (or a test simulating one) that reassigns its own
+            // method after registration would silently keep calling the stale one.
+            // Re-reading keeps the cached wrapper's identity stable while staying
+            // live to whatever `target[prop]` currently is.
+            const wrapper = isCaptureSeam(prop)
+                ? (...args) => {
+                    const wrapped = args.map((arg) => wrapFunctionsInPlace(arg));
+                    return keepProxy(method.apply(target, wrapped));
+                }
+                : (...args) => {
+                    const current = Reflect.get(target, prop, target);
+                    return current.apply(target, args);
+                };
+            wrapperCache.set(prop, wrapper);
+            return wrapper;
+        },
+    });
+    return proxy;
+}
+function formatConsoleArgs(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg === "string")
+            return arg;
+        if (arg instanceof Error)
+            return arg.stack ?? arg.message;
+        try {
+            return JSON.stringify(arg) ?? String(arg);
+        }
+        catch {
+            return String(arg);
+        }
+    })
+        .join(" ");
+}
+/**
+ * Patch every console method on the extension entry path so a transitively
+ * loaded dependency cannot write raw bytes into pi's frame — the pi-side
+ * mirror of `mcp/server.ts`'s `console.log = console.error` guard, which
+ * protects the JSON-RPC stdout channel for the same structural reason.
+ *
+ * The patch is a DISPATCHER, not a permanent reroute (#1434). It sends a write
+ * to the extension log only while pi-lens owns execution; every other write
+ * goes to the original console method. pi's own one-shot CLI commands print
+ * through `console.log`, so an unconditional reroute silenced them: `pi list`
+ * exited 0 with no output in any project whose cwd loaded the extension first.
+ *
+ * This is a NET, not the fix: pi-lens's own sites are migrated to real sinks
+ * with real schemas. Idempotent, and inert under test mode (vitest owns the
+ * console) and under `PI_LENS_CONSOLE_GUARD=0`.
+ *
+ * Returns true when the patch was applied by this call.
+ */
+export function installConsoleGuard() {
+    if (consoleGuardInstalled)
+        return false;
+    if (isTestMode())
+        return false;
+    if (process.env.PI_LENS_CONSOLE_GUARD === "0")
+        return false;
+    consoleGuardInstalled = true;
+    const target = console;
+    for (const method of CONSOLE_METHODS) {
+        const original = target[method];
+        if (typeof original !== "function")
+            continue;
+        const originalFn = original;
+        originalConsoleMethods.set(method, originalFn);
+        const replacement = (...args) => {
+            if (!isConsoleCaptureActive()) {
+                originalFn.apply(console, args);
+                return;
+            }
+            logExtension({
+                subsystem: "console",
+                level: method === "warn" ? "warn" : method === "error" ? "error" : "debug",
+                message: formatConsoleArgs(args),
+                metadata: { method },
+            });
+        };
+        installedConsoleMethods.set(method, replacement);
+        target[method] = replacement;
+    }
+    return true;
+}
+/**
+ * Restore the exact console methods captured at install time.
+ *
+ * A method someone else patched after us is left alone — restoring it would
+ * clobber their replacement. Returns true when this call uninstalled.
+ */
+export function uninstallConsoleGuard() {
+    if (!consoleGuardInstalled)
+        return false;
+    consoleGuardInstalled = false;
+    const target = console;
+    for (const [method, original] of originalConsoleMethods) {
+        if (target[method] === installedConsoleMethods.get(method)) {
+            target[method] = original;
+        }
+    }
+    originalConsoleMethods.clear();
+    installedConsoleMethods.clear();
+    return true;
+}
+/** Test-only: uninstall the guard and close every open capture window. */
+export function _resetConsoleGuardForTests() {
+    uninstallConsoleGuard();
+    consoleGuardInstalled = false;
+    consoleCaptureStorage = undefined;
+    moduleLoadWindowOpen = false;
+}

package/node_modules/pi-lens/dist/clients/extension-mode.js

@@ -0,0 +1,73 @@
+/**
+ * Host run-mode awareness (#1334 S2).
+ *
+ * pi tells every extension which mode it is running in — verified against the
+ * pinned host types (`@earendil-works/pi-coding-agent/dist/core/extensions/
+ * types.d.ts`):
+ *
+ *   export type ExtensionMode = "tui" | "rpc" | "json" | "print";   // line 208
+ *   interface ExtensionContext { mode: ExtensionMode; hasUI: boolean; … }
+ *                                                       // lines 212-215
+ *
+ * The host's own comment on `mode` is the contract this module encodes:
+ * *"Use `"tui"` to guard terminal-only UI such as custom components."*
+ *
+ * pi-lens previously derived terminal ownership from nothing at all — it
+ * mounted its widget and chattered through `ui.notify` in every mode, including
+ * `print` and `json`, where the process is a one-shot producing machine- or
+ * pipe-consumed output and there is no live TUI to render into.
+ *
+ * Two independent questions, deliberately NOT the same predicate:
+ *
+ *   - *Is there a TUI to mount a custom component into?* Only `"tui"`. `rpc`
+ *     has `hasUI: true` (dialogs work over the protocol) but no terminal
+ *     component surface, so the widget must not mount there either.
+ *   - *Should proactive chatter reach the human?* No in `print` and `json` —
+ *     one-shot/machine output. Yes in `tui` and `rpc`.
+ *
+ * This is complementary to, and independent of, the #1338/#1333 console guard:
+ * that establishes "never write raw to the terminal"; this decides whether the
+ * HOST's own render path should be used at all in a given mode.
+ *
+ * Stateless by design: `mode` lives on the ctx pi hands to every event and
+ * command handler, so each call site reads it from the ctx it already has —
+ * no latched global to go stale across a session replacement.
+ */
+const KNOWN_MODES = new Set(["tui", "rpc", "json", "print"]);
+/**
+ * Feature-detected read of `ctx.mode`.
+ *
+ * Returns `"unknown"` for a host that predates the field, or for any value
+ * outside the four documented modes (a future pi may add one; treating an
+ * unrecognized mode as "unknown" keeps current behavior rather than guessing
+ * a suppression that could hide output).
+ */
+export function readExtensionMode(ctx) {
+    try {
+        const mode = ctx?.mode;
+        if (typeof mode !== "string" || !KNOWN_MODES.has(mode))
+            return "unknown";
+        return mode;
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Whether a terminal-only custom component (the pi-lens diagnostics widget) can
+ * be mounted. `"unknown"` mounts — older hosts must behave exactly as before.
+ */
+export function supportsTuiWidget(mode) {
+    return mode === "tui" || mode === "unknown";
+}
+/**
+ * Whether proactive `ui.notify` chatter should be suppressed (logged only).
+ * True only for the two non-interactive one-shot modes.
+ */
+export function suppressesUserNotify(mode) {
+    return mode === "print" || mode === "json";
+}
+/** Short human-readable reason for a suppression, for the ndjson/debug log. */
+export function modeSuppressionNote(mode) {
+    return `suppressed in "${mode}" mode (no interactive TUI)`;
+}

package/node_modules/pi-lens/dist/clients/file-kinds.js

@@ -88,6 +88,9 @@ export const KIND_EXTENSIONS = {
         ".hs",
         ".lhs",
     ],
+    "helm-template": [
+        ".tpl",
+    ],
     html: [
         ".htm",
         ".html",
@@ -169,6 +172,7 @@ export const KIND_EXTENSIONS = {
         ".tf",
         ".tfvars",
     ],
+    terragrunt: [],
     toml: [
         ".toml",
     ],
@@ -181,6 +185,36 @@ export const KIND_EXTENSIONS = {
         ".zon",
     ],
 };
+/** Return whether a path has an extension registered for the given file kind. */
+export function hasKindExtension(filePath, kind) {
+    const extension = extname(filePath).toLowerCase();
+    return KIND_EXTENSIONS[kind].some((candidate) => candidate === extension);
+}
+// Fact providers intentionally stay on the ordinary JS/TS source extensions.
+// Vue/Svelte files are classified as jsts for project-wide discovery, but their
+// embedded-language contents are not valid inputs for these tree-sitter facts.
+// Keep that one policy decision here so the function and import providers agree.
+const JSTS_FACT_EXTENSIONS = new Set(KIND_EXTENSIONS.jsts.filter((extension) => ![".vue", ".svelte"].includes(extension)));
+/** Whether the JS/TS fact providers should parse this path. */
+export function isJstsFactFile(filePath) {
+    return JSTS_FACT_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+// Bash access tracking also accepts common text/config files which do not have
+// a semantic FileKind. Every source extension is derived from KIND_EXTENSIONS;
+// only this explicit legacy text/config allowlist lives outside that registry.
+const NON_KIND_READABLE_EXTENSIONS = new Set([
+    ".txt",
+    ".env",
+    ".cfg",
+    ".conf",
+    ".ini",
+    ".xml",
+]);
+/** Whether bash file-access parsing should treat a path as source-like. */
+export function isReadableSourceFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    return (Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension));
+}
 // --- Shared Project Root Markers ---
 /**
  * .NET project/solution root-marker globs (refs #895). Single source of truth
@@ -200,6 +234,19 @@ export const DOTNET_FSHARP_ROOT_MARKERS = [
     "*.fsproj",
     "*.sln",
 ];
+/**
+ * Terragrunt's unit/root entrypoint filenames, lowercase. Single source of truth
+ * for every subsystem that has to agree on what counts as a terragrunt file —
+ * SPECIAL_FILENAMES below, tool-policy.ts's linter and formatter policies,
+ * formatters.ts's terragruntHclFormatter, and language-profile.ts's project/root
+ * markers. Same rule as the .NET markers above: never hand-copy this list at a
+ * call site. tests/clients/terragrunt-filenames.test.ts asserts every consumer
+ * honors every name here, so a drifting call site fails CI.
+ */
+export const TERRAGRUNT_FILENAMES = [
+    "terragrunt.hcl",
+    "root.hcl",
+];
 // Reverse map: extension → file kind (for fast lookup)
 const EXT_TO_KIND = new Map();
 for (const [kind, exts] of Object.entries(KIND_EXTENSIONS)) {
@@ -218,6 +265,10 @@ const SPECIAL_FILENAMES = [
     { pattern: /^CMakeLists\.txt$/i, kind: "cmake" },
     { pattern: /^Makefile$/i, kind: "shell" },
     { pattern: /^Dockerfile(\.\w+)?$/i, kind: "docker" },
+    ...TERRAGRUNT_FILENAMES.map((name) => ({
+        pattern: new RegExp(`^${name.replaceAll(".", "\\.")}$`, "i"),
+        kind: "terragrunt",
+    })),
 ];
 // --- Detection Functions ---
 /**
@@ -294,6 +345,7 @@ export const CODE_KINDS = new Set([
     "gleam",
     "go",
     "haskell",
+    "helm-template",
     "java",
     "jsts",
     "kotlin",
@@ -310,6 +362,7 @@ export const CODE_KINDS = new Set([
     "sql",
     "swift",
     "terraform",
+    "terragrunt",
     "zig",
 ]);
 /** Data/doc/markup/config kinds — still enumerated (that's #894's point), but
@@ -376,11 +429,13 @@ export function getFileKindLabel(kind) {
         lua: "Lua",
         zig: "Zig",
         haskell: "Haskell",
+        "helm-template": "Helm template",
         elixir: "Elixir",
         gleam: "Gleam",
         ocaml: "OCaml",
         clojure: "Clojure",
         terraform: "Terraform",
+        terragrunt: "Terragrunt",
         nix: "Nix",
         toml: "TOML",
     };
@@ -444,11 +499,13 @@ export function getLanguageId(kind) {
         lua: "lua",
         zig: "zig",
         haskell: "haskell",
+        "helm-template": "helm",
         elixir: "elixir",
         gleam: "gleam",
         ocaml: "ocaml",
         clojure: "clojure",
         terraform: "terraform",
+        terragrunt: "terragrunt",
         nix: "nix",
         toml: "toml",
     };

package/node_modules/pi-lens/dist/clients/file-role.js

@@ -5,8 +5,9 @@
  * can skip checks that don't apply (e.g. no complexity checks on generated
  * files, no logic-density checks on re-export barrels).
  */
-import { basename, dirname } from "node:path";
+import { basename, dirname, win32 } from "node:path";
 import { isGeneratedOrArtifact } from "./generated-artifacts.js";
+import { isWindowsPath } from "./path-utils.js";
 // --- Detection ---
 const RE_EXPORT_LINE = /^export\s+(type\s+)?\*\s+from\s+|^export\s*\{[^}]*\}\s+from\s+/;
 function isReExportBarrel(content) {
@@ -36,10 +37,24 @@ function isTypeStub(content) {
 /**
  * Classify the structural role of a file. Pass `content` for higher
  * accuracy (enables generated-code detection, barrel detection, etc.).
+ *
+ * `detectFileRole` is platform-native by design — normal same-OS paths
+ * (POSIX on Linux, win32 on Windows) go through the module-default
+ * `basename`/`dirname`, unchanged from before. But a WINDOWS-SHAPED path
+ * (drive letter or UNC prefix, per `isWindowsPath`) is parsed with
+ * `path.win32.basename`/`dirname` regardless of the running OS (refs #1152,
+ * the #1150 class): on Linux the module-default `dirname` finds no `/` in a
+ * `C:\...` path, collapses to `"."`, and the dir-based branches below
+ * (`/tests/`, `/spec/`, …) silently misclassify. On win32 this branch is a
+ * no-op — `win32.basename`/`dirname` already equal the module default there
+ * — so native Windows classification is unchanged.
  */
 export function detectFileRole(filePath, content) {
-    const base = basename(filePath).toLowerCase();
-    const dir = dirname(filePath).replace(/\\/g, "/").toLowerCase();
+    const windowsShaped = isWindowsPath(filePath);
+    const base = (windowsShaped ? win32.basename(filePath) : basename(filePath)).toLowerCase();
+    const dir = (windowsShaped ? win32.dirname(filePath) : dirname(filePath))
+        .replace(/\\/g, "/")
+        .toLowerCase();
     // --- Test ---
     if (base.includes(".test.") ||
         base.includes(".spec.") ||