pi-monofold 0.12.4 → 0.12.5

package/README.md

@@ -52,7 +52,7 @@ pi install -l git:github.com/eiei114/pi-monofold
 Pin a version:
 
 ```powershell
-pi install git:github.com/eiei114/pi-monofold@v0.12.4
+pi install git:github.com/eiei114/pi-monofold@v0.12.5
 ```
 
 Try without installing:
@@ -76,7 +76,7 @@ pi install -l npm:pi-monofold
 Pin a version:
 
 ```powershell
-pi install npm:pi-monofold@0.12.4
+pi install npm:pi-monofold@0.12.5
 ```
 
 Try without installing:
@@ -171,6 +171,7 @@ pi-monofold/
 │   ├── focus-skills-auto-load.test.ts
 │   ├── focus-skills.test.ts
 │   ├── changelog-hygiene.test.ts
+│   ├── contributing-docs.test.ts
 │   ├── github-actions-pin.test.ts
 │   ├── monofold-read-caps.test.ts
 │   ├── monofold-read-ops.test.ts
@@ -179,7 +180,9 @@ pi-monofold/
 │   ├── release-docs.test.ts
 │   ├── readme-version-pin.test.ts
 │   ├── runtime-path-overlays.test.ts
-│   └── unknown-path-allows.test.ts
+│   ├── tsconfig-publishable-files.test.ts
+│   ├── unknown-path-allows.test.ts
+│   └── workspace-path-lookup.test.ts
 ├── CHANGELOG.md
 ├── SECURITY.md
 ├── file-read-preview.ts
@@ -197,6 +200,7 @@ pi-monofold/
 ├── README.md
 ├── unknown-path-allows.ts
 ├── validation.ts
+├── workspace-path-lookup.ts
 └── tsconfig.json
 ```
 

package/index.ts

@@ -25,6 +25,12 @@ import {
   setActiveFocusPresetId,
   warnZeroTargetMatchesForPreset,
 } from "./focus-preset.js";
+import {
+  buildPathLookupWorkspaces,
+  findWorkspaceForAbsolutePath,
+  isPathInsideWorkspace,
+  resolveAbsoluteTargetPath,
+} from "./workspace-path-lookup.js";
 import {
   resolveWriteRouteType,
   type MonofoldRouteType,
@@ -130,6 +136,7 @@ type LoadedConfig = {
   root: string;
   raw: MultiWorkspaceConfig;
   workspaces: ResolvedWorkspace[];
+  pathLookupWorkspaces: ResolvedWorkspace[];
   activeRuntime: RuntimeInfo;
 };
 
@@ -278,10 +285,7 @@ function asPathOverlayMap(label: string, value: unknown): RuntimePathOverlayMap
 }
 
 function isInside(parent: string, child: string): boolean {
-  const normalizedParent = normalizeGuardPath(parent);
-  const normalizedChild = normalizeGuardPath(child);
-  const relative = path.relative(normalizedParent, normalizedChild);
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  return isPathInsideWorkspace(parent, child);
 }
 
 function assertWorkspaceInternalRelative(label: string, value: string): void {
@@ -585,6 +589,7 @@ async function validateConfigObject(cwd: string, configPath: string, parsed: unk
       workspaces: workspaces.filter((workspace) => workspace.kind === "workspace"),
     },
     workspaces,
+    pathLookupWorkspaces: buildPathLookupWorkspaces(workspaces),
     activeRuntime,
   };
 }
@@ -1498,8 +1503,8 @@ function classifyPath(targetPath: string): "docs" | "code" | "unknown" {
 }
 
 function findWorkspaceForPath(loaded: LoadedConfig, targetPath: string): ResolvedWorkspace | undefined {
-  const absolute = normalizeGuardPath(path.isAbsolute(targetPath) ? targetPath : path.resolve(loaded.root, targetPath));
-  return [...loaded.workspaces].sort((a, b) => b.resolvedPath.length - a.resolvedPath.length).find((workspace) => isInside(workspace.resolvedPath, absolute));
+  const absolute = resolveAbsoluteTargetPath(loaded.root, targetPath);
+  return findWorkspaceForAbsolutePath(loaded.pathLookupWorkspaces, absolute);
 }
 
 async function confirm(ctx: ExtensionContext, title: string, body: string): Promise<boolean> {

package/monofold-read-ops.ts

@@ -51,7 +51,8 @@ export async function shallowTree(
   }
   const entries = await readdir(path.join(root, prefix), { withFileTypes: true });
   const lines: string[] = [];
-  for (const entry of entries.filter((e) => e.name !== ".git" && e.name !== "node_modules")) {
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
     if (budget && budget.remaining <= 0) {
       budget.truncated = true;
       break;
@@ -60,7 +61,10 @@ export async function shallowTree(
     lines.push(entry.isDirectory() ? `${rel}/` : rel);
     if (budget) budget.remaining -= 1;
     if (entry.isDirectory() && depth > 0) {
-      lines.push(...(await shallowTree(root, depth - 1, rel, budget)));
+      const childLines = await shallowTree(root, depth - 1, rel, budget);
+      for (const childLine of childLines) {
+        lines.push(childLine);
+      }
     }
   }
   return lines;

package/package.json

@@ -12,7 +12,7 @@
   },
   "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
   "type": "module",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "pi": {
     "extensions": [
       "./index.ts"
@@ -32,7 +32,8 @@
     "focus-session-state.ts",
     "monofold-read-ops.ts",
     "read-caps.ts",
-    "validation.ts"
+    "validation.ts",
+    "workspace-path-lookup.ts"
   ],
   "name": "pi-monofold",
   "devDependencies": {

package/path-normalize.ts

@@ -18,8 +18,8 @@ function repairMsysPath(value: string): string {
 }
 
 /** Normalizes local paths before workspace guard comparisons. */
-export function normalizeGuardPath(input: string): string {
+export function normalizeGuardPath(input: string, impl: Pick<typeof path, "resolve"> = path): string {
   const trimmed = input.trim();
   if (!trimmed) return trimmed;
-  return path.resolve(repairMsysPath(trimmed));
+  return impl.resolve(repairMsysPath(trimmed));
 }

package/workspace-path-lookup.ts

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { normalizeGuardPath } from "./path-normalize.js";
+
+type PathImpl = Pick<typeof path, "isAbsolute" | "relative" | "resolve" | "sep">;
+
+/** Detects Windows drive-letter (`C:/...`) or UNC (`\\...`) syntax on any host. */
+function isWindowsStylePath(value: string): boolean {
+  return /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith("\\\\");
+}
+
+/** Selects the path implementation matching the given path syntax. */
+function selectPathImpl(...values: string[]): PathImpl {
+  return values.some(isWindowsStylePath) ? path.win32 : path;
+}
+
+/** Returns true when `child` is inside or equal to `parent`. */
+export function isPathInsideWorkspace(parent: string, child: string): boolean {
+  const impl = selectPathImpl(parent, child);
+  const normalizedParent = normalizeGuardPath(parent, impl);
+  const normalizedChild = normalizeGuardPath(child, impl);
+  const relative = impl.relative(normalizedParent, normalizedChild);
+  return (
+    relative === "" ||
+    (relative !== ".." && !relative.startsWith(`..${impl.sep}`) && !impl.isAbsolute(relative))
+  );
+}
+
+/** Pre-sorts workspaces once so path guards prefer the longest matching root. */
+export function buildPathLookupWorkspaces<T extends { resolvedPath: string }>(workspaces: T[]): T[] {
+  return [...workspaces].sort((a, b) => b.resolvedPath.length - a.resolvedPath.length);
+}
+
+export function resolveAbsoluteTargetPath(root: string, targetPath: string): string {
+  const impl = selectPathImpl(root, targetPath);
+  return normalizeGuardPath(impl.isAbsolute(targetPath) ? targetPath : impl.resolve(root, targetPath), impl);
+}
+
+export function findWorkspaceForAbsolutePath<T extends { resolvedPath: string }>(
+  pathLookupWorkspaces: readonly T[],
+  absolutePath: string,
+): T | undefined {
+  const impl = selectPathImpl(absolutePath, ...pathLookupWorkspaces.map((workspace) => workspace.resolvedPath));
+  const absolute = normalizeGuardPath(absolutePath, impl);
+  return pathLookupWorkspaces.find((workspace) => isPathInsideWorkspace(workspace.resolvedPath, absolute));
+}