pi-lens 3.8.71 → 3.8.73

package/dist/clients/instance-registry.js

@@ -22,6 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 // #735: reuse the #449/#525 reaper's exact conservative liveness check
 // (`process.kill(pid, 0)`, ESRCH-only-means-dead) rather than inventing a
@@ -34,6 +35,7 @@ import { getGlobalPiLensDir } from "./file-utils.js";
 // import is actually invoked.
 import { realIsPidAlive } from "./instance-reaper.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { getSubagentIdentity, isSubagentSession, } from "./subagent-mode.js";
 function registryPath() {
     return path.join(getGlobalPiLensDir(), "instances.json");
 }
@@ -87,44 +89,32 @@ export async function readInstanceRegistry() {
     const file = await readRegistryAsync();
     return file.instances;
 }
-// --- Write (atomic tmp + rename, same pattern as review-graph/builder.ts) ---
+// --- Write (atomic tmp + rename via clients/atomic-write.ts, #762) ---
 async function writeRegistryAsync(file) {
     const dir = getGlobalPiLensDir();
     const target = registryPath();
-    const tmpPath = `${target}.tmp-${process.pid}`;
     try {
         await fs.promises.mkdir(dir, { recursive: true });
-        await fs.promises.writeFile(tmpPath, JSON.stringify(file), "utf-8");
-        await fs.promises.rename(tmpPath, target);
     }
     catch {
-        // Best-effort observability substrate — a failed write just means this
+        // Best-effort observability substrate — a failed mkdir just means this
         // update is lost, never a thrown error for the caller.
-        try {
-            await fs.promises.rm(tmpPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
+        return;
     }
+    // bestEffort (default): a failed write just means this update is lost,
+    // never a thrown error for the caller.
+    await writeFileAtomicAsync(target, JSON.stringify(file));
 }
 function writeRegistrySync(file) {
     const dir = getGlobalPiLensDir();
     const target = registryPath();
-    const tmpPath = `${target}.tmp-${process.pid}`;
     try {
         fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(tmpPath, JSON.stringify(file), "utf-8");
-        fs.renameSync(tmpPath, target);
     }
     catch {
-        try {
-            fs.rmSync(tmpPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
+        return;
     }
+    writeFileAtomic(target, JSON.stringify(file));
 }
 // --- Mutations (all read-modify-write whole file) ---
 /** Create/overwrite this process's entry. */
@@ -137,6 +127,15 @@ export async function registerInstance(projectRoot) {
     const now = new Date().toISOString();
     const others = file.instances.filter((entry) => entry.pid !== pid);
     const existing = file.instances.find((entry) => entry.pid === pid);
+    const identity = isSubagentSession() ? getSubagentIdentity() : undefined;
+    const subagent = identity
+        ? {
+            marker: identity.marker,
+            agentType: identity.agentName,
+            parentPid: identity.parentPid,
+            runId: identity.runId,
+        }
+        : undefined;
     others.push({
         pid,
         startedAt: existing?.startedAt ?? now,
@@ -145,6 +144,7 @@ export async function registerInstance(projectRoot) {
         lspChildCount: existing?.lspChildren?.length ?? 0,
         rssBytes: process.memoryUsage().rss,
         heartbeatAt: now,
+        ...(subagent ? { subagent } : {}),
     });
     await writeRegistryAsync({ instances: others });
 }
@@ -226,8 +226,19 @@ export async function recordLspChild(entry) {
     }
     await writeRegistryAsync(file);
 }
+// LSP client shutdown intentionally does not await registry removal (the
+// process-exiting path must stay non-blocking), but concurrent removals still
+// need to serialize their read-modify-write sequence or siblings can be lost
+// to last-writer-wins. Process kills remain fully concurrent; this queue only
+// covers the small best-effort registry mutation.
+let lspChildRemovalTail = Promise.resolve();
 /** Remove an LSP child (by pid) from this process's entry. */
-export async function removeLspChild(pid) {
+export function removeLspChild(pid) {
+    const removal = lspChildRemovalTail.then(() => removeLspChildNow(pid));
+    lspChildRemovalTail = removal.catch(() => { });
+    return removal;
+}
+async function removeLspChildNow(pid) {
     if (!isInstanceRegistryEnabled())
         return;
     const selfPid = process.pid;

package/dist/clients/jscpd-client.js

@@ -11,9 +11,12 @@ import * as fs from "node:fs";
 import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
+import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, } from "./file-utils.js";
 import { findNodeToolBinary } from "./package-manager.js";
+import { isAtOrAboveHomeDir } from "./path-utils.js";
+import { getJscpdMaxEntriesDerived } from "./project-scale.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
 const EMPTY_RESULT = {
     success: false,
     clones: [],
@@ -45,46 +48,42 @@ export class JscpdClient {
      * them.
      */
     hasSourceFilesRecursive(rootDir) {
-        const stack = [rootDir];
         const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
-        let visited = 0;
-        const MAX_ENTRIES = 6000;
-        while (stack.length > 0 && visited < MAX_ENTRIES) {
-            const dir = stack.pop();
-            if (!dir)
-                continue;
-            let entries;
-            try {
-                entries = fs.readdirSync(dir, { withFileTypes: true });
-            }
-            catch {
-                continue;
+        const state = { visited: 0 };
+        // #776: derived from the `maxProjectFiles` scale knob (project-scale.ts),
+        // reproducing this same 6,000 default at the default base.
+        const MAX_ENTRIES = getJscpdMaxEntriesDerived(rootDir);
+        // #761: the traversal loop, readdir-safety, and directory-recursion
+        // decision are the shared `walkTreeStackSync` engine; this client keeps
+        // its own per-entry policy (skip ALL symlinks — files too — before the
+        // dir/file branch, its own multi-language source regex, and a
+        // per-directory entry budget via `shouldStop`, matching the pre-#761
+        // `while (stack.length > 0 && visited < MAX_ENTRIES)` condition: the
+        // current directory's entry loop always finishes, but no further
+        // directory is popped once the budget is spent).
+        return walkTreeStackSync(rootDir, (entry, fullPath) => {
+            state.visited += 1;
+            if (entry.isSymbolicLink())
+                return "skip";
+            if (entry.isDirectory()) {
+                return shouldRecurseIntoDir(entry, fullPath, {
+                    ignoreMatcher,
+                    followSymlinks: true,
+                })
+                    ? "recurse"
+                    : "skip";
             }
-            for (const entry of entries) {
-                visited += 1;
-                if (entry.isSymbolicLink())
-                    continue;
-                if (entry.isDirectory()) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (isExcludedDirName(entry.name))
-                        continue;
-                    if (ignoreMatcher.isIgnored(fullPath, true))
-                        continue;
-                    stack.push(fullPath);
-                    continue;
-                }
-                if (!entry.isFile())
-                    continue;
-                if (ignoreMatcher.isIgnored(path.join(dir, entry.name), false))
-                    continue;
-                if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
-                    if (entry.name.endsWith(".d.ts"))
-                        continue;
-                    return true;
-                }
+            if (!entry.isFile())
+                return "skip";
+            if (ignoreMatcher.isIgnored(fullPath, false))
+                return "skip";
+            if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
+                if (entry.name.endsWith(".d.ts"))
+                    return "skip";
+                return "stop";
             }
-        }
-        return false;
+            return "skip";
+        }, { shouldStop: () => state.visited >= MAX_ENTRIES });
     }
     /**
      * Check if jscpd is available, auto-install if not
@@ -144,9 +143,23 @@ export class JscpdClient {
      * Scan a directory for duplicate code blocks.
      * Uses a temp output dir to capture JSON report.
      * @param isTsProject - If true, excludes .js files (they're compiled artifacts in TS projects)
+     *
+     * Root contract (#747/#250): unlike `KnipClient`/`DeadCodeClient`, this
+     * client does NOT resolve a project root via `findNearestMarkerRoot`, so it
+     * has historically relied on every caller to guard the scan root itself. The
+     * `isAtOrAboveHomeDir` refusal below is belt-and-braces internal protection
+     * so a FUTURE caller that forgets that contract can't spawn a whole-$HOME
+     * jscpd walk (the observed OOM: a jscpd run from a WSL home reached 44 GB
+     * RSS). `options.homeDir` overrides `os.homedir()` for tests.
      */
-    async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false) {
+    async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false, options = {}) {
         const targetDir = path.resolve(cwd);
+        // #747/#250: never walk from a cwd at/above $HOME — from there jscpd's
+        // tokenizer would run across every unrelated repo under home.
+        if (isAtOrAboveHomeDir(targetDir, options.homeDir)) {
+            this.log(`Refusing scan of unsafe root at/above home: ${targetDir}`);
+            return { ...EMPTY_RESULT };
+        }
         // Return early for non-existent or empty directories before probing/installing.
         if (!fs.existsSync(targetDir)) {
             return { ...EMPTY_RESULT };

package/dist/clients/language-profile.js

@@ -5,6 +5,7 @@ import { getProjectIgnoreMatcher } from "./file-utils.js";
 import { LANGUAGE_POLICY, } from "./language-policy.js";
 import { getSourceFiles } from "./scan-utils.js";
 import { readDirEntriesSafe, shouldRecurseIntoDir } from "./source-walker.js";
+import { findNearestDirWithAnyBasename } from "./workspace-topology.js";
 export const SUPPORTED_FILE_KINDS = [
     "jsts",
     "python",
@@ -114,24 +115,6 @@ const ROOT_MARKERS_BY_KIND = {
     nix: ["flake.nix"],
     toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
 };
-function nearestRoot(start, markers) {
-    let dir = path.resolve(start);
-    const { root } = path.parse(dir);
-    while (true) {
-        for (const marker of markers) {
-            if (fs.existsSync(path.join(dir, marker))) {
-                return dir;
-            }
-        }
-        if (dir === root)
-            break;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return undefined;
-}
 // Process-lifetime memo keyed on projectRoot. Only populated when the
 // caller did not pass an explicit `sourceFiles` array — the explicit-array
 // case is used by the warmup pipeline to inject pre-collected files and
@@ -225,7 +208,17 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
     if (!markers || markers.length === 0) {
         return path.resolve(workspaceRoot);
     }
-    const found = nearestRoot(startDir, markers);
+    // #807: nearest-marker discovery now shares workspace-topology.ts's single
+    // walk/cache/invalidation seam instead of this file's own per-kind
+    // `existsSync` climb loop. `findNearestDirWithAnyBasename` additionally
+    // rejects a marker at/above `$HOME` (the pre-#807 loop didn't), matching
+    // the AGENTS.md walker invariant — harmless here because the
+    // workspace-relative check right below already discards any candidate
+    // outside `workspaceRoot`, and `workspaceRoot` is never at/above `$HOME`
+    // in practice. This keeps resolveLanguageRootForFile's OWN stricter
+    // workspace-relative policy check unchanged: the topology service only
+    // supplies discovery, not this function's policy.
+    const found = findNearestDirWithAnyBasename(startDir, markers);
     if (!found)
         return path.resolve(workspaceRoot);
     const workspace = path.resolve(workspaceRoot);

package/dist/clients/lens-config.js

@@ -1,18 +1,38 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parseEnabledShape } from "./config-enabled-shape.js";
+import { findNestedProjectMutationValue, } from "./project-lens-config.js";
 export function getPiLensGlobalConfigPath(homeDir = os.homedir()) {
     const override = process.env.PI_LENS_CONFIG_PATH;
     if (override)
         return path.resolve(override);
     return path.join(homeDir, ".pi-lens", "config.json");
 }
+const warnedInvalidGlobalConfigs = new Set();
+/**
+ * Same warn-once-per-(path, reason) contract as project-lens-config.ts's
+ * `warnInvalidConfigOnce` — a malformed global config value is logged once
+ * and then treated as absent, rather than silently dropped (#792).
+ */
+function warnInvalidGlobalConfigOnce(configPath, reason) {
+    const key = `${configPath}:${reason}`;
+    if (warnedInvalidGlobalConfigs.has(key))
+        return;
+    warnedInvalidGlobalConfigs.add(key);
+    console.error(`[pi-lens] ignoring invalid global config ${configPath}: ${reason}`);
+}
+/** For tests that need to force the warn-once cache to reset between cases. */
+export function resetGlobalConfigWarnCache() {
+    warnedInvalidGlobalConfigs.clear();
+}
 export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath()) {
     try {
         const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
         if (!parsed || typeof parsed !== "object")
             return undefined;
         const raw = parsed;
+        const warnInvalid = (reason) => warnInvalidGlobalConfigOnce(configPath, reason);
         const dispatchRaw = raw.dispatch;
         const dispatch = dispatchRaw && typeof dispatchRaw === "object"
             ? dispatchRaw
@@ -21,19 +41,17 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         const widget = widgetRaw && typeof widgetRaw === "object"
             ? widgetRaw
             : undefined;
-        const formatRaw = raw.format;
-        const format = formatRaw && typeof formatRaw === "object"
-            ? formatRaw
+        const format = parseEnabledShape(raw.format, "format", warnInvalid);
+        const autofix = parseEnabledShape(raw.autofix, "autofix", warnInvalid);
+        const formatModeRaw = raw.format;
+        const formatModeSource = formatModeRaw && typeof formatModeRaw === "object"
+            ? formatModeRaw
             : undefined;
         const actionableWarningsRaw = raw.actionableWarnings;
         const actionableWarnings = actionableWarningsRaw && typeof actionableWarningsRaw === "object"
             ? actionableWarningsRaw
             : undefined;
-        const actionableWarningsAutoFixRaw = actionableWarnings?.autoFix;
-        const actionableWarningsAutoFix = actionableWarningsAutoFixRaw &&
-            typeof actionableWarningsAutoFixRaw === "object"
-            ? actionableWarningsAutoFixRaw
-            : undefined;
+        const actionableWarningsAutoFix = parseEnabledShape(actionableWarnings?.autoFix, "actionableWarnings.autoFix", warnInvalid);
         const contextInjectionRaw = raw.contextInjection;
         const contextInjection = contextInjectionRaw && typeof contextInjectionRaw === "object"
             ? contextInjectionRaw
@@ -42,8 +60,9 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         const turnSummary = turnSummaryRaw && typeof turnSummaryRaw === "object"
             ? turnSummaryRaw
             : undefined;
-        const formatMode = format?.mode === "immediate" || format?.mode === "deferred"
-            ? format.mode
+        const formatMode = formatModeSource?.mode === "immediate" ||
+            formatModeSource?.mode === "deferred"
+            ? formatModeSource.mode
             : undefined;
         const ignore = Array.isArray(raw.ignore)
             ? raw.ignore.filter((p) => typeof p === "string")
@@ -66,10 +85,11 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
                 : undefined,
             format: format
                 ? {
-                    enabled: typeof format.enabled === "boolean" ? format.enabled : undefined,
+                    enabled: format.enabled,
                     mode: formatMode,
                 }
                 : undefined,
+            autofix: autofix ? { enabled: autofix.enabled } : undefined,
             actionableWarnings: actionableWarnings
                 ? {
                     enabled: typeof actionableWarnings.enabled === "boolean"
@@ -82,11 +102,7 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
                         ? actionableWarnings.deltaOnly
                         : undefined,
                     autoFix: actionableWarningsAutoFix
-                        ? {
-                            enabled: typeof actionableWarningsAutoFix.enabled === "boolean"
-                                ? actionableWarningsAutoFix.enabled
-                                : undefined,
-                        }
+                        ? { enabled: actionableWarningsAutoFix.enabled }
                         : undefined,
                 }
                 : undefined,
@@ -119,6 +135,9 @@ export function getGlobalWidgetDefaultVisible(configPath) {
 export function getGlobalAutoformatEnabled(configPath) {
     return loadPiLensGlobalConfig(configPath)?.format?.enabled !== false;
 }
+export function getGlobalAutofixEnabled(configPath) {
+    return loadPiLensGlobalConfig(configPath)?.autofix?.enabled !== false;
+}
 export function getGlobalImmediateFormatDefault(configPath) {
     return loadPiLensGlobalConfig(configPath)?.format?.mode === "immediate";
 }
@@ -128,32 +147,92 @@ export function getGlobalContextInjectionEnabled(configPath) {
 export function getGlobalTurnSummaryEnabled(configPath) {
     return loadPiLensGlobalConfig(configPath)?.turnSummary?.enabled === true;
 }
-export function resolvePiLensFlag(name, value, config) {
+/**
+ * Resolve a flag AND report which config tier decided it — same precedence
+ * as {@link resolvePiLensFlag} (which now delegates here), just also
+ * returning the `source` so callers can log e.g.
+ * "(--no-autofix, source=project)" instead of a bare boolean (#792).
+ *
+ * Precedence (unchanged, maintainer decision — project wins over global,
+ * including re-enabling; only an explicit CLI disabling flag outranks
+ * project config): cli → project → global → default.
+ */
+export function resolvePiLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot) {
     if (value)
-        return value;
+        return { value, source: "cli" };
+    const mutationFlag = name === "no-autoformat" ||
+        name === "no-autofix" ||
+        name === "lens-actionable-warning-autofix"
+        ? name
+        : undefined;
+    const nested = mutationFlag && editedFilePath && projectRoot
+        ? findNestedProjectMutationValue(mutationFlag, editedFilePath, projectRoot)
+        : undefined;
+    const nestedSource = nested
+        ? path.resolve(nested.dir) === path.resolve(projectRoot)
+            ? "project"
+            : `nested-project:${nested.dir}`
+        : undefined;
     if (name === "no-autoformat") {
-        return config?.format?.enabled === false;
+        if (nested)
+            return { value: !nested.value, source: nestedSource };
+        if (projectConfig?.format?.enabled !== undefined) {
+            return { value: !projectConfig.format.enabled, source: "project" };
+        }
+        if (config?.format?.enabled === false) {
+            return { value: true, source: "global" };
+        }
+        return { value: false, source: "default" };
+    }
+    if (name === "no-autofix") {
+        if (nested)
+            return { value: !nested.value, source: nestedSource };
+        if (projectConfig?.autofix?.enabled !== undefined) {
+            return { value: !projectConfig.autofix.enabled, source: "project" };
+        }
+        if (config?.autofix?.enabled === false) {
+            return { value: true, source: "global" };
+        }
+        return { value: false, source: "default" };
     }
     if (name === "immediate-format") {
-        return config?.format?.mode === "immediate";
+        const immediate = config?.format?.mode === "immediate";
+        return { value: immediate, source: immediate ? "global" : "default" };
     }
     if (name === "lens-actionable-warnings") {
-        return config?.actionableWarnings?.enabled === true;
+        const enabled = config?.actionableWarnings?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-actions") {
-        return config?.actionableWarnings?.includeLspCodeActions === true;
+        const enabled = config?.actionableWarnings?.includeLspCodeActions === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-autofix") {
-        return config?.actionableWarnings?.autoFix?.enabled === true;
+        if (nested)
+            return { value: nested.value, source: nestedSource };
+        if (projectConfig?.actionableWarnings?.autoFix?.enabled !== undefined) {
+            return {
+                value: projectConfig.actionableWarnings.autoFix.enabled,
+                source: "project",
+            };
+        }
+        const enabled = config?.actionableWarnings?.autoFix?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-all") {
-        return config?.actionableWarnings?.deltaOnly === false;
+        const all = config?.actionableWarnings?.deltaOnly === false;
+        return { value: all, source: all ? "global" : "default" };
     }
     if (name === "no-lens-context") {
-        return config?.contextInjection?.enabled === false;
+        const disabled = config?.contextInjection?.enabled === false;
+        return { value: disabled, source: disabled ? "global" : "default" };
     }
     if (name === "lens-turn-summary") {
-        return config?.turnSummary?.enabled === true;
+        const enabled = config?.turnSummary?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
-    return value;
+    return { value, source: "default" };
+}
+export function resolvePiLensFlag(name, value, config, projectConfig, editedFilePath, projectRoot) {
+    return resolvePiLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot).value;
 }