pi-monofold 0.3.0 → 0.3.2

package/package.json

@@ -1,58 +1,61 @@
-{
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --test tests/**/*.test.ts",
-    "check": "npm run typecheck && npm test && npm pack --dry-run"
-  },
-  "peerDependencies": {
-    "typebox": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-ai": "*"
-  },
-  "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
-  "type": "module",
-  "version": "0.3.0",
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "files": [
-    "README.md",
-    "LICENSE",
-    "index.ts",
-    "focus-preset.ts",
-    "validation.ts"
-  ],
-  "name": "pi-monofold",
-  "devDependencies": {
-    "typescript": "^6.0.3",
-    "typebox": "^1.1.38",
-    "@types/node": "^25.9.1",
-    "tsx": "^4.20.5",
-    "@earendil-works/pi-coding-agent": "^0.75.4",
-    "@earendil-works/pi-ai": "^0.75.4"
-  },
-  "dependencies": {
-    "yaml": "^2.8.1"
-  },
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "ai-coding",
-    "virtual-monorepo",
-    "multi-repo"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/eiei114/pi-monofold.git"
-  },
-  "bugs": {
-    "url": "https://github.com/eiei114/pi-monofold/issues"
-  },
-  "homepage": "https://github.com/eiei114/pi-monofold#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT"
-}
+{
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/**/*.test.ts",
+    "check": "npm run typecheck && npm test && npm pack --dry-run"
+  },
+  "peerDependencies": {
+    "typebox": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*"
+  },
+  "description": "Pi extension that folds multiple repositories and folders into a guarded virtual monorepo for AI agents.",
+  "type": "module",
+  "version": "0.3.2",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "index.ts",
+    "path-normalize.ts",
+    "file-read-preview.ts",
+    "focus-preset.ts",
+    "read-caps.ts",
+    "validation.ts"
+  ],
+  "name": "pi-monofold",
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "typebox": "^1.1.38",
+    "@types/node": "^25.9.1",
+    "tsx": "^4.20.5",
+    "@earendil-works/pi-coding-agent": "^0.75.4",
+    "@earendil-works/pi-ai": "^0.75.4"
+  },
+  "dependencies": {
+    "yaml": "^2.8.1"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "ai-coding",
+    "virtual-monorepo",
+    "multi-repo"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eiei114/pi-monofold.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eiei114/pi-monofold/issues"
+  },
+  "homepage": "https://github.com/eiei114/pi-monofold#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/path-normalize.ts

@@ -0,0 +1,25 @@
+import path from "node:path";
+
+/** Converts MSYS/Git-Bash style paths into canonical absolute Windows paths. */
+function repairMsysPath(value: string): string {
+  let normalized = value.replace(/\\/g, "/");
+
+  const unixDrive = normalized.match(/^\/([a-zA-Z])\/(.*)$/);
+  if (unixDrive) {
+    normalized = `${unixDrive[1].toUpperCase()}:/${unixDrive[2]}`;
+  }
+
+  const mixedDrive = normalized.match(/^([a-zA-Z]):\/?(?:c|C)\/(.*)$/);
+  if (mixedDrive) {
+    normalized = `${mixedDrive[1].toUpperCase()}:/${mixedDrive[2]}`;
+  }
+
+  return normalized;
+}
+
+/** Normalizes local paths before workspace guard comparisons. */
+export function normalizeGuardPath(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return trimmed;
+  return path.resolve(repairMsysPath(trimmed));
+}

package/read-caps.ts

@@ -0,0 +1,137 @@
+export const DEFAULT_MAX_MATCHES = 50;
+export const DEFAULT_MAX_CHARS = 8_000;
+export const DEFAULT_MAX_ENTRIES = 200;
+
+export type ResolvedSearchCaps = {
+  maxMatches: number;
+  maxChars: number;
+};
+
+export type ResolvedTreeCaps = {
+  maxEntries: number;
+};
+
+export type SearchCapResult = {
+  text: string;
+  matchCount: number;
+  returnedMatchCount: number;
+  maxMatches: number;
+  maxChars: number;
+  truncated: boolean;
+  hint?: string;
+};
+
+export type TreeCapResult = {
+  text: string;
+  entryCount: number;
+  returnedEntryCount: number;
+  maxEntries: number;
+  truncated: boolean;
+  hint?: string;
+};
+
+function assertPositiveInt(name: string, value: number): number {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+  return value;
+}
+
+export function resolveSearchCaps(input?: { maxMatches?: number; maxChars?: number }): ResolvedSearchCaps {
+  return {
+    maxMatches: input?.maxMatches === undefined ? DEFAULT_MAX_MATCHES : assertPositiveInt("maxMatches", input.maxMatches),
+    maxChars: input?.maxChars === undefined ? DEFAULT_MAX_CHARS : assertPositiveInt("maxChars", input.maxChars),
+  };
+}
+
+export function resolveTreeCaps(input?: { maxEntries?: number }): ResolvedTreeCaps {
+  return {
+    maxEntries:
+      input?.maxEntries === undefined ? DEFAULT_MAX_ENTRIES : assertPositiveInt("maxEntries", input.maxEntries),
+  };
+}
+
+export function searchTruncationHint(matchCount: number, returnedMatchCount: number, caps: ResolvedSearchCaps): string {
+  return (
+    `[truncated: showing ${returnedMatchCount} of ${matchCount} matches ` +
+    `(maxMatches=${caps.maxMatches}, maxChars=${caps.maxChars}). ` +
+    "Narrow path/query or pass higher maxMatches/maxChars intentionally.]"
+  );
+}
+
+export function treeTruncationHint(entryCount: number, returnedEntryCount: number, caps: ResolvedTreeCaps): string {
+  return (
+    `[truncated: showing ${returnedEntryCount} of ${entryCount} entries ` +
+    `(maxEntries=${caps.maxEntries}). ` +
+    "Narrow path/depth or pass a higher maxEntries intentionally.]"
+  );
+}
+
+export function capSearchOutput(rawOutput: string, caps: ResolvedSearchCaps): SearchCapResult {
+  const trimmed = rawOutput.trim();
+  if (!trimmed) {
+    return {
+      text: "No matches",
+      matchCount: 0,
+      returnedMatchCount: 0,
+      maxMatches: caps.maxMatches,
+      maxChars: caps.maxChars,
+      truncated: false,
+    };
+  }
+
+  const lines = trimmed.split("\n");
+  const matchCount = lines.length;
+  const matchLimited = lines.slice(0, caps.maxMatches);
+  let truncated = matchLimited.length < matchCount;
+
+  const charLimited: string[] = [];
+  let charTotal = 0;
+  for (const line of matchLimited) {
+    const separator = charLimited.length > 0 ? 1 : 0;
+    if (charTotal + separator + line.length > caps.maxChars) {
+      truncated = true;
+      break;
+    }
+    charLimited.push(line);
+    charTotal += separator + line.length;
+  }
+
+  const returnedMatchCount = charLimited.length;
+  const hint = truncated ? searchTruncationHint(matchCount, returnedMatchCount, caps) : undefined;
+  const body = charLimited.join("\n");
+  const text = hint ? `${body}\n\n${hint}` : body;
+
+  return {
+    text,
+    matchCount,
+    returnedMatchCount,
+    maxMatches: caps.maxMatches,
+    maxChars: caps.maxChars,
+    truncated,
+    hint,
+  };
+}
+
+export function capTreeLines(
+  lines: string[],
+  caps: ResolvedTreeCaps,
+  traversalTruncated = false,
+): TreeCapResult {
+  const entryCount = traversalTruncated ? lines.length + 1 : lines.length;
+  const limited = lines.slice(0, caps.maxEntries);
+  const truncated = traversalTruncated || limited.length < lines.length;
+  const returnedEntryCount = limited.length;
+  const hint = truncated ? treeTruncationHint(entryCount, returnedEntryCount, caps) : undefined;
+  const body = limited.join("\n");
+  const text = hint ? `${body}\n\n${hint}` : body;
+
+  return {
+    text,
+    entryCount,
+    returnedEntryCount,
+    maxEntries: caps.maxEntries,
+    truncated,
+    hint,
+  };
+}