pi-hashline-edit-pro 6.4.4 → 6.4.5

package/README.md

@@ -341,7 +341,7 @@ Auto-read keeps the same 50KB and 2000-line budget as `read`. Auto-read and Diff
 
 Auto-read all is off by default and has three modes, selected in `/hashline-config`: `off` injects nothing; `outline` attaches an anchor-stamped structural outline per file; and `full` discovers every file in the working directory that is not git-ignored (`git ls-files`, falling back to `ripgrep`, then to a directory walk) and attaches full contents. `Git repos only` is on by default and keeps the whole injection inside a git repository; turn it off to attach files in any directory. On the first turn of a session, the extension discovers the files, reads each one, and attaches the resulting `anchor│content` rows to the conversation as one extension message before the model answers. Those anchors are served exactly like `read` output, so the model can `replace` and `insert` immediately without calling `read` first. The message is injected once per session; resumed, forked, and cloned sessions that already contain it skip the injection.
 
-Files are filtered before injection: symlinks, directories, image extensions (including SVG), binary files (a NUL byte in the first 8KB), files over 200KB, any path with a vendored segment (vendor, node_modules, bower_components, third_party, thirdparty, jspm_packages, .venv, venv, site-packages, __pycache__, .tox, .gradle, .terraform, Pods, Carthage, DerivedData, coreui, coreui-icons, case-insensitive; `resources/views/vendor` is kept so Laravel view overrides stay attached), and vendored or generated names and patterns (*.min.js, *.min.css, *.min.mjs, *-min.js, *-min.css, *.bundle.*, *.chunk.*, *.umd.js, *.map, *.lock, package-lock.json, yarn.lock, composer.lock, Gemfile.lock, Cargo.lock, poetry.lock, Pipfile.lock, go.sum, flake.lock, *.generated.*, *.gen.*, *_pb2.py, *.pb.go, *.g.dart, *.freezed.dart, *.designer.cs, *.g.cs, *.snap, _ide_helper.php, _ide_helper_models.php, .phpstorm.meta.php, .eslintcache, coreui-icons.*, coreui.css) are skipped. The attachment stops at 500 files or at a byte budget derived from the model context window (200KB floor, 2MB ceiling), and it never drops below one file; `full` also caps the budget at 2MB, while `outline` follows the context-derived budget because outlines stay compact. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A model matched by `disableOnModels` skips the injection entirely.
+Files are filtered before injection: symlinks, directories, image extensions (including SVG), binary files (a NUL byte in the first 8KB), files over 200KB, any path with a vendored segment (vendor, node_modules, bower_components, third_party, thirdparty, jspm_packages, .venv, venv, site-packages, __pycache__, .tox, .gradle, .terraform, Pods, Carthage, DerivedData, coreui, coreui-icons, case-insensitive; `resources/views/vendor` is kept so Laravel view overrides stay attached), and vendored or generated names and patterns (*.min.js, *.min.css, *.min.mjs, *-min.js, *-min.css, *.bundle.*, *.chunk.*, *.umd.js, *.map, *.lock, package-lock.json, yarn.lock, composer.lock, Gemfile.lock, Cargo.lock, poetry.lock, Pipfile.lock, go.sum, flake.lock, *.generated.*, *.gen.*, *_pb2.py, *.pb.go, *.g.dart, *.freezed.dart, *.designer.cs, *.g.cs, *.snap, _ide_helper.php, _ide_helper_models.php, .phpstorm.meta.php, .eslintcache, coreui-icons.*, coreui.css) are skipped. The attachment stops at 500 files or at a byte budget derived from the model context window (200KB floor, 2MB ceiling), and it never drops below one file; `full` also caps the budget at 2MB, while `outline` follows the context-derived budget because outlines stay compact. Files are ranked before the budget applies: working-tree changes first, then manifest and entry files, then the dominant source tree, then everything else, and no single top-level directory may take more than 40% of the budget in the first pass, so one large subtree cannot crowd out the rest. Skipped and not-attached files are named at the end of the message so the model can `read` them on demand. A model matched by `disableOnModels` skips the injection entirely.
 
 Each attached file starts with a header (`=== path ===` in `full` mode, `=== path (language) — lines ===` in `outline` mode) followed by its anchor rows. Edit directly from the attachment with replace and insert, so no `read` is needed. `full` attaches files whole; `outline` attaches each file's structural outline within the budget. In outline mode, multi-line symbols appear as labels with `[limit N]` and single-line symbols appear as their content.
 

package/index.ts

@@ -46,6 +46,11 @@ import { valAccess } from "./src/validation";
 import { splitLines } from "./src/utils";
 import { AUTO_READ_ALL_CUSTOM_TYPE } from "./src/constants";
 
+interface PendingRegistrySession {
+  key: string | undefined;
+  alive: () => boolean;
+}
+
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
 
@@ -72,7 +77,7 @@ export default function (pi: ExtensionAPI): void {
   let grepFlavorCwd: string | undefined;
   const baseAnchorTools = new Set<string>();
   let gateApplied = false;
-  const pendingRegistrySessionKeys: Array<string | undefined> = [];
+  const pendingRegistrySessions: PendingRegistrySession[] = [];
 
   async function refreshEditTools(): Promise<void> {
     try {
@@ -145,8 +150,32 @@ export default function (pi: ExtensionAPI): void {
     pi.setActiveTools([...new Set([...base, ...enabled])]);
   }
 
+  function captureRegistrySession(ctx: AnchorSessionContext | undefined): void {
+    const key = sessionKeyFor(ctx);
+    const entry: PendingRegistrySession = {
+      key,
+      alive: () => {
+        try {
+          void ctx?.sessionManager;
+          return true;
+        } catch {
+          return false;
+        }
+      },
+    };
+    const index = key === undefined ? -1 : pendingRegistrySessions.findIndex((candidate) => candidate.key === key);
+    if (index >= 0) pendingRegistrySessions[index] = entry;
+    else pendingRegistrySessions.push(entry);
+  }
+
+  function releaseCapturedRegistrySession(key: string): void {
+    const index = pendingRegistrySessions.findIndex((entry) => entry.key === key);
+    if (index >= 0) pendingRegistrySessions.splice(index, 1);
+    releaseRegistrySession(key);
+  }
+
   async function withRegistrySession<T>(ctx: AnchorSessionContext | undefined, fn: () => Promise<T> | T): Promise<T> {
-    pendingRegistrySessionKeys.push(sessionKeyFor(ctx));
+    captureRegistrySession(ctx);
     return withAnchorSession(ctx, fn);
   }
 
@@ -197,19 +226,38 @@ export default function (pi: ExtensionAPI): void {
     }
   }));
 
-  pi.on("session_shutdown", async () => {
+  pi.on("session_shutdown", async (_event, ctx) => {
     try {
-      const key = pendingRegistrySessionKeys.shift();
-      if (key !== undefined) releaseRegistrySession(key);
+      let key: string | undefined;
+      let readable = true;
+      try {
+        key = sessionKeyFor(ctx);
+      } catch {
+        readable = false;
+      }
+      if (readable && key !== undefined) {
+        releaseCapturedRegistrySession(key);
+        return;
+      }
+      if (readable) {
+        const dead = pendingRegistrySessions.findIndex((entry) => entry.key === undefined && !entry.alive());
+        const fallback = pendingRegistrySessions.findIndex((entry) => entry.key === undefined);
+        const index = dead >= 0 ? dead : fallback;
+        if (index >= 0) pendingRegistrySessions.splice(index, 1);
+        return;
+      }
+      const dead = pendingRegistrySessions.findIndex((entry) => !entry.alive());
+      const entry = dead >= 0 ? pendingRegistrySessions.splice(dead, 1)[0] : pendingRegistrySessions.shift();
+      if (entry?.key !== undefined) releaseRegistrySession(entry.key);
     } catch (error) {
       console.error("Failed to release anchor registry session:", error);
     }
   });
-  pi.on("model_select", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("model_select", async (event, ctx) => withRegistrySession(ctx, async () => {
     await syncModelGate(event.model, ctx.cwd);
   }));
 
-  pi.on("before_agent_start", async (_event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("before_agent_start", async (_event, ctx) => withRegistrySession(ctx, async () => {
     await syncModelGate(ctx.model, ctx.cwd);
     if (autoReadAll === "off" || autoReadAllInjected) return;
     if (modelDisabled(ctx.model, disableOnModels)) return;
@@ -287,12 +335,12 @@ export default function (pi: ExtensionAPI): void {
 
   pi.registerCommand("clear-anchors", {
     description: "Clear the session's anchor claims (path-free resolution state); anchors are re-claimed on the next read",
-    handler: async (_args, ctx) => withAnchorSession(ctx, async () => {
+    handler: async (_args, ctx) => withRegistrySession(ctx, async () => {
       clearRegistry();
       ctx.ui.notify(`Anchor claims cleared for this session`, "info");
     }),
   });
-  pi.on("message_end", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("message_end", async (event, ctx) => withRegistrySession(ctx, async () => {
     try {
       await planAssistantMessage(event.message, ctx.cwd);
     } catch (error) {
@@ -307,7 +355,7 @@ export default function (pi: ExtensionAPI): void {
       console.error("Failed to finalize edit batch:", error);
     }
   });
-  pi.on("tool_result", async (event, ctx) => withAnchorSession(ctx, async () => {
+  pi.on("tool_result", async (event, ctx) => withRegistrySession(ctx, async () => {
     if (event.isError) return;
     const gated = modelDisabled(ctx.model, disableOnModels);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "6.4.4",
+  "version": "6.4.5",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/auto-read-all.ts

@@ -3,6 +3,7 @@ import { lstat, open, readdir } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
 import { formatSize } from "@earendil-works/pi-coding-agent";
 import {
+  AUTO_READ_ALL_DIR_BUDGET_SHARE,
   AUTO_READ_ALL_MAX_BUDGET_BYTES,
   AUTO_READ_ALL_MAX_FILE_BYTES,
   AUTO_READ_ALL_MAX_FILES,
@@ -108,6 +109,137 @@ function isExcludedByPattern(baseLower: string): boolean {
     || baseLower.startsWith("coreui-icons.")
     || baseLower === "coreui.css";
 }
+
+const MANIFEST_BASE_NAMES = new Set([
+  "package.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "pyproject.toml",
+  "setup.py",
+  "setup.cfg",
+  "requirements.txt",
+  "pipfile",
+  "cargo.toml",
+  "go.mod",
+  "gemfile",
+  "rakefile",
+  "makefile",
+  "gnumakefile",
+  "cmakelists.txt",
+  "meson.build",
+  "build.gradle",
+  "build.gradle.kts",
+  "settings.gradle",
+  "settings.gradle.kts",
+  "pom.xml",
+  "mix.exs",
+  "composer.json",
+  "dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "compose.yml",
+  "compose.yaml",
+  "readme.md",
+  "readme.rst",
+  "readme.txt",
+  "readme",
+]);
+
+const SOURCE_TOP_LEVEL_NAMES = new Set([
+  "src",
+  "source",
+  "lib",
+  "libs",
+  "app",
+  "apps",
+  "packages",
+  "server",
+  "client",
+  "web",
+  "api",
+  "cmd",
+  "internal",
+  "pkg",
+  "core",
+  "modules",
+  "components",
+  "services",
+  "plugins",
+  "include",
+]);
+
+const NON_SOURCE_TOP_LEVEL_NAMES = new Set([
+  "test",
+  "tests",
+  "spec",
+  "specs",
+  "__tests__",
+  "__mocks__",
+  "docs",
+  "doc",
+  "documentation",
+  "examples",
+  "example",
+  "samples",
+  "sample",
+  "fixtures",
+  "benchmark",
+  "benchmarks",
+  "bench",
+  "e2e",
+  "scripts",
+  "assets",
+  "static",
+  "public",
+  "coverage",
+  "migrations",
+  "locales",
+  "i18n",
+  "styles",
+]);
+
+function topSegmentOf(path: string): string | undefined {
+  const index = path.indexOf("/");
+  return index < 0 ? undefined : path.slice(0, index);
+}
+
+function detectSourceTopLevel(files: readonly string[]): Set<string> {
+  const counts = new Map<string, number>();
+  for (const file of files) {
+    const top = topSegmentOf(file)?.toLowerCase();
+    if (top === undefined || NON_SOURCE_TOP_LEVEL_NAMES.has(top)) continue;
+    counts.set(top, (counts.get(top) ?? 0) + 1);
+  }
+  let dominant: string | undefined;
+  let dominantCount = 0;
+  for (const [name, count] of counts) {
+    if (count > dominantCount) {
+      dominant = name;
+      dominantCount = count;
+    }
+  }
+  const source = new Set(SOURCE_TOP_LEVEL_NAMES);
+  if (dominant !== undefined) source.add(dominant);
+  return source;
+}
+
+function priorityOf(file: string, changed: ReadonlySet<string>, sourceTopLevel: ReadonlySet<string>): number {
+  if (changed.has(file)) return 0;
+  if (MANIFEST_BASE_NAMES.has(baseNameOf(file).toLowerCase())) return 1;
+  const top = topSegmentOf(file)?.toLowerCase();
+  if (top !== undefined && sourceTopLevel.has(top)) return 2;
+  return 3;
+}
+
+function rankFiles(files: readonly string[], changed: ReadonlySet<string>, sourceTopLevel: ReadonlySet<string>): string[] {
+  return [...files].sort((a, b) => {
+    const byPriority = priorityOf(a, changed, sourceTopLevel) - priorityOf(b, changed, sourceTopLevel);
+    if (byPriority !== 0) return byPriority;
+    if (a === b) return 0;
+    return a < b ? -1 : 1;
+  });
+}
+
 export function normalizeAutoReadAllIgnoreList(entries: readonly string[] | undefined): string[] {
   const seen = new Set<string>();
   const out: string[] = [];
@@ -228,6 +360,36 @@ async function listFromGit(cwd: string): Promise<string[] | undefined> {
   return result.stdout.split("\0").filter((entry) => entry.length > 0);
 }
 
+async function listChangedFiles(cwd: string): Promise<Set<string>> {
+  const changed = new Set<string>();
+  const prefixResult = await runCommand("git", ["rev-parse", "--show-prefix"], cwd);
+  const prefix = prefixResult.code === 0 ? toPosix(prefixResult.stdout.trim()) : "";
+  const result = await runCommand("git", ["status", "--porcelain", "-z", "-uall"], cwd);
+  if (result.code !== 0) return changed;
+  const fields = result.stdout.split("\0");
+  for (let index = 0; index < fields.length; index += 1) {
+    const field = fields[index];
+    if (field === undefined || field.length < 4) continue;
+    const status = field.slice(0, 2);
+    addChangedPath(changed, field.slice(3), prefix);
+    if (status.includes("R") || status.includes("C")) {
+      index += 1;
+      const source = fields[index];
+      if (source !== undefined && source.length > 0) addChangedPath(changed, source, prefix);
+    }
+  }
+  return changed;
+}
+
+function addChangedPath(changed: Set<string>, path: string, prefix: string): void {
+  const posix = toPosix(path);
+  if (prefix.length > 0 && posix.startsWith(prefix)) {
+    changed.add(posix.slice(prefix.length));
+    return;
+  }
+  changed.add(posix);
+}
+
 async function listFromRg(cwd: string): Promise<string[] | undefined> {
   let rgPath: string;
   try {
@@ -331,16 +493,19 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
   const unique = [...new Set(candidates.map(toPosix))].sort();
   const includable: string[] = [];
   let skippedByName = 0;
+  let skippedBinary = 0;
+  let skippedLarge = 0;
+  let skippedOther = 0;
   for (const file of unique) {
     const baseLower = baseNameOf(file).toLowerCase();
     if (EXCLUDED_NAME_SET.has(baseLower) || isExcludedBySegment(file) || isExcludedByPattern(baseLower) || isExcludedByCustomIgnore(file, customIgnore)) skippedByName += 1;
+    else if (IMAGE_EXTENSIONS.has(extensionOf(file))) skippedBinary += 1;
     else includable.push(file);
   }
-  const scanWindow = includable.slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
+  const changed = source === "git" ? await listChangedFiles(cwd) : new Set<string>();
+  const sourceTopLevel = detectSourceTopLevel(includable);
+  const scanWindow = rankFiles(includable, changed, sourceTopLevel).slice(0, AUTO_READ_ALL_MAX_FILES * SCAN_LIMIT_MULTIPLIER);
   const sized: string[] = [];
-  let skippedBinary = 0;
-  let skippedLarge = 0;
-  let skippedOther = 0;
 
   await forEachLimit(scanWindow, SCAN_CONCURRENCY, async (file) => {
     let stats;
@@ -358,10 +523,6 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
       skippedLarge += 1;
       return;
     }
-    if (IMAGE_EXTENSIONS.has(extensionOf(file))) {
-      skippedBinary += 1;
-      return;
-    }
     sized.push(file);
   });
 
@@ -372,8 +533,7 @@ export async function discoverAutoReadAllFiles(cwd: string, mode: AutoReadAllMod
     else if (nul) skippedBinary += 1;
     else textual.push(file);
   });
-  textual.sort();
-  const files = textual.slice(0, AUTO_READ_ALL_MAX_FILES);
+  const files = rankFiles(textual, changed, sourceTopLevel).slice(0, AUTO_READ_ALL_MAX_FILES);
 
   return { files, source, discovered: unique.length, skippedBinary, skippedLarge, skippedOther, skippedByName };
 }
@@ -430,34 +590,52 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   const outline = isOutlineAutoReadAll(mode);
   const sections: AutoReadAllSection[] = [];
   const omitted: string[] = [];
+  const backlog: string[] = [];
+  const usedByDir = new Map<string, number>();
+  const dirBudget = Math.max(1, Math.floor(budgetBytes * AUTO_READ_ALL_DIR_BUDGET_SHARE));
   let bytes = 0;
   let completeFiles = 0;
-  for (const file of discovery.files) {
+
+  const take = async (file: string, respectDirBudget: boolean): Promise<void> => {
     if (sections.length > 0 && bytes >= budgetBytes) {
       omitted.push(file);
-      continue;
+      return;
     }
-    if (!outline && sections.length > 0) {
+    const group = topSegmentOf(file) ?? ".";
+    const used = usedByDir.get(group) ?? 0;
+    if (sections.length > 0) {
       const size = await candidateFileBytes(cwd, file);
       if (size !== undefined && bytes + size > budgetBytes) {
         omitted.push(file);
-        continue;
+        return;
+      }
+      if (respectDirBudget && size !== undefined && used + size > dirBudget) {
+        backlog.push(file);
+        return;
       }
     }
     const section = await renderFile(file, cwd, outline);
     if (section === undefined) {
       omitted.push(file);
-      continue;
+      return;
     }
     const sectionBytes = Buffer.byteLength(section.text, "utf-8") + 1;
     if (sections.length > 0 && bytes + sectionBytes > budgetBytes) {
       omitted.push(file);
-      continue;
+      return;
+    }
+    if (sections.length > 0 && respectDirBudget && used + sectionBytes > dirBudget) {
+      backlog.push(file);
+      return;
     }
     sections.push(section);
     bytes += sectionBytes;
+    usedByDir.set(group, used + sectionBytes);
     if (section.complete) completeFiles += 1;
-  }
+  };
+
+  for (const file of discovery.files) await take(file, true);
+  for (const file of backlog) await take(file, false);
   if (sections.length === 0) return undefined;
   const sectionTexts = sections.map((section) => section.text);
   const coverage = `[coverage: ${completeFiles} complete]`;

package/src/constants.ts

@@ -36,3 +36,4 @@ export const AUTO_READ_ALL_MAX_FILES = 500;
 export const AUTO_READ_ALL_MAX_FILE_BYTES = 200_000;
 export const AUTO_READ_ALL_MIN_BUDGET_BYTES = 200_000;
 export const AUTO_READ_ALL_MAX_BUDGET_BYTES = 2_000_000;
+export const AUTO_READ_ALL_DIR_BUDGET_SHARE = 0.4;