pi-fovea 0.18.0 → 0.18.2

package/README.md

@@ -205,7 +205,7 @@ next user prompt instead; it never restarts an idle agent. The compact update
 names changed files, route deltas, and newly relevant files. Shell commands,
 external editors, and agents without Fovea remain `unattributed` rather than
 being guessed, while the path scope still keeps unrelated sibling sandboxes
-quiet. Provenance journals are bounded, expire after seven days, and live in
+quiet. Provenance journals accept either intercepted mutations or explicit trusted SHA-1 transitions, write one bounded replacement per event batch, expire after seven days, and live in
 `$TMPDIR`; repository content remains the drift oracle. Updates list causal
 channels such as calls, imports, shared literals, tests, or co-change history.
 By default Fovea also embeds the refreshed focus context of the top drift target

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fovea",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Token-budgeted repo mapping for agent sessions: foveated heat diffusion over a cross-language code graph, with progressive disclosure.",
   "type": "module",
   "license": "MIT",

package/src/core/agent-dir.ts

@@ -0,0 +1,19 @@
+// pi's agent-dir resolution, in-process so pi-fovea modules never import the
+// pi-coding-agent runtime at extension load. pi's loader re-evaluates the host
+// module graph for every extension that imports it, costing roughly a second
+// of startup.
+
+import { homedir } from "node:os";
+import path from "node:path";
+
+export const configDirName = ".pi";
+
+const expandTilde = (value: string): string => {
+  if (value === "~") return homedir();
+  return value.startsWith("~/") ? path.join(homedir(), value.slice(2)) : value;
+};
+
+export const resolveAgentDir = (): string => {
+  const override = process.env.PI_CODING_AGENT_DIR;
+  return override ? expandTilde(override) : path.join(homedir(), configDirName, "agent");
+};

package/src/core/config.ts

@@ -4,7 +4,7 @@
 // defaults; the FOVEA_TURN_SYNC=off environment variable always wins, the
 // same way PI_FABRIC_* overrides win over stored fabric config.
 
-import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import { configDirName } from "./agent-dir.js";
 import fs from "node:fs";
 import path from "node:path";
 
@@ -88,7 +88,7 @@ export interface FoveaConfigScopes {
 }
 
 export const globalFoveaConfigPath = (agentDir: string): string => path.join(agentDir, "fovea.json");
-export const projectFoveaConfigPath = (cwd: string): string => path.join(cwd, CONFIG_DIR_NAME, "fovea.json");
+export const projectFoveaConfigPath = (cwd: string): string => path.join(cwd, configDirName, "fovea.json");
 
 const BOUNDS: Record<string, [number, number]> = {
   "sync.budget": [128, 8192],

package/src/core/provenance.ts

@@ -30,6 +30,12 @@ export interface MutationCapture {
   beforeSha?: string;
 }
 
+export interface MutationTransition {
+  path: string;
+  beforeSha?: string | undefined;
+  afterSha?: string | undefined;
+}
+
 type ProvenanceKind = "current-session" | "other-session" | "mixed" | "unattributed";
 
 export interface SyncProvenance {
@@ -68,7 +74,11 @@ export const captureMutation = async (root: string, path: string): Promise<Mutat
 
 const writeQueues = new Map<string, Promise<void>>();
 
-const persistRecord = async (target: string, journal: MutationJournal, record: MutationRecord): Promise<void> => {
+const persistRecords = async (
+  target: string,
+  journal: MutationJournal,
+  additions: readonly MutationRecord[],
+): Promise<void> => {
   const cutoff = Date.now() - JOURNAL_TTL_MS;
   let records: MutationRecord[] = [];
   try {
@@ -79,48 +89,73 @@ const persistRecord = async (target: string, journal: MutationJournal, record: M
   } catch {
     // Missing and torn journals both recover as a fresh per-session file.
   }
-  records.push(record);
+  records.push(...additions);
   journal.records = records.slice(-JOURNAL_MAX_RECORDS);
   const temporary = `${target}.tmp-${process.pid}-${randomUUID()}`;
   await writeFile(temporary, JSON.stringify(journal));
   await rename(temporary, target);
 };
 
-export const finishMutation = async (
-  capture: MutationCapture,
+export const recordMutationTransitions = async (
+  root: string,
+  transitions: readonly MutationTransition[],
   sessionId: string,
   toolCallId: string,
-): Promise<boolean> => {
-  const afterSha = await hashFile(capture.absolutePath);
-  if (capture.beforeSha === afterSha) return false;
+): Promise<number> => {
+  const resolvedRoot = resolve(root);
   const owner = ownerFor(sessionId);
-  const target = provenancePathFor(capture.root, sessionId);
-  const record: MutationRecord = {
-    file: capture.file,
-    beforeSha: capture.beforeSha,
-    afterSha,
-    owner,
-    toolCallId,
-    at: Date.now(),
-  };
+  const at = Date.now();
+  const records = transitions.flatMap((transition): MutationRecord[] => {
+    const located = repoPath(root, transition.path);
+    if (!located || transition.beforeSha === transition.afterSha) return [];
+    return [{
+      file: located.file,
+      beforeSha: transition.beforeSha,
+      afterSha: transition.afterSha,
+      owner,
+      toolCallId,
+      at,
+    }];
+  });
+  if (records.length === 0) return 0;
+  const target = provenancePathFor(resolvedRoot, sessionId);
   const previous = writeQueues.get(target) ?? Promise.resolve();
-  const queued = previous.catch(() => {}).then(() => persistRecord(target, {
-    version: JOURNAL_VERSION,
-    root: capture.root,
-    owner,
-    records: [],
-  }, record));
+  const queued = previous.catch(() => {}).then(() => persistRecords(target, {
+    version: JOURNAL_VERSION, root: resolvedRoot, owner, records: [],
+  }, records));
   writeQueues.set(target, queued);
   try {
     await queued;
-    return true;
+    return records.length;
   } finally {
     if (writeQueues.get(target) === queued) writeQueues.delete(target);
   }
 };
 
+export const recordMutationTransition = async (
+  root: string,
+  path: string,
+  beforeSha: string | undefined,
+  afterSha: string | undefined,
+  sessionId: string,
+  toolCallId: string,
+): Promise<boolean> => (await recordMutationTransitions(
+  root, [{ path, beforeSha, afterSha }], sessionId, toolCallId,
+)) === 1;
+
+export const finishMutation = async (
+  capture: MutationCapture,
+  sessionId: string,
+  toolCallId: string,
+): Promise<boolean> => recordMutationTransition(
+  capture.root, capture.file, capture.beforeSha, await hashFile(capture.absolutePath), sessionId, toolCallId,
+);
+
 const readRecords = async (root: string, since: number): Promise<MutationRecord[]> => {
   const prefix = prefixFor(root);
+  await Promise.all([...writeQueues.entries()]
+    .filter(([path]) => path.split(/[/\\]/u).at(-1)?.startsWith(prefix))
+    .map(([, pending]) => pending.catch(() => {})));
   const cutoff = Math.max(since, Date.now() - JOURNAL_TTL_MS);
   let names: string[];
   try {
@@ -180,12 +215,17 @@ export const attributeChanges = async (
   changes: Array<{ file: string; beforeSha?: string; afterSha?: string }>,
 ): Promise<SyncProvenance> => {
   const records = await readRecords(root, since);
+  const recordsByFile = new Map<string, MutationRecord[]>();
+  for (const record of records) {
+    const matching = recordsByFile.get(record.file) ?? [];
+    matching.push(record);
+    recordsByFile.set(record.file, matching);
+  }
   const currentOwner = ownerFor(sessionId);
   const files: Record<string, ProvenanceKind> = {};
   for (const change of changes) {
-    const matching = records.filter((record) => record.file === change.file);
     files[change.file] = kindForOwners(
-      ownersForTransition(matching, change.beforeSha, change.afterSha),
+      ownersForTransition(recordsByFile.get(change.file) ?? [], change.beforeSha, change.afterSha),
       currentOwner,
     );
   }

package/src/index.ts

@@ -4,8 +4,9 @@
 // incremental across sessions.
 
 import { readFileSync } from "node:fs";
-import { createGrepTool, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { resolveAgentDir } from "./core/agent-dir.js";
 import { loadFoveaConfig, type FoveaConfig } from "./core/config.js";
 import { hasAstGrep } from "./core/astgrep.js";
 import { ROOT_CACHE_LIMIT } from "./core/asyncutil.js";
@@ -13,7 +14,6 @@ import { dwell, ensureStateBackground, focus, impact, sketch } from "./core/ops.
 import { observeSessionPaths, resetSessions } from "./core/session.js";
 import { captureMutation, finishMutation, type MutationCapture } from "./core/provenance.js";
 import { resetSyncBaselines, sync, warmSync } from "./core/sync.js";
-import { openFoveaSettings } from "./ui/settings.js";
 import type { NodeKind } from "./core/types.js";
 
 const PACKAGE_VERSION = (() => {
@@ -89,7 +89,7 @@ export default function fovea(pi: ExtensionAPI) {
       configs.set(root, hit);
       return hit;
     }
-    const cfg = loadFoveaConfig({ cwd: root, agentDir: agentDir ?? getAgentDir(), projectTrusted: trusted });
+    const cfg = loadFoveaConfig({ cwd: root, agentDir: agentDir ?? resolveAgentDir(), projectTrusted: trusted });
     configs.set(root, cfg);
     while (configs.size > ROOT_CACHE_LIMIT) configs.delete(configs.keys().next().value!);
     return cfg;
@@ -159,6 +159,10 @@ export default function fovea(pi: ExtensionAPI) {
       return undefined;
     }
   });
+  // pi-core's createGrepTool drags the whole host module graph into this
+  // extension's loader (~1s of startup). Load it only on first native use.
+  const loadNativeGrepTool = (root: string) =>
+    import("@earendil-works/pi-coding-agent").then(({ createGrepTool }) => createGrepTool(root));
   const registerGrepOverride = (): void => {
     if (grepOverrideRegistered) return;
     grepOverrideRegistered = true;
@@ -175,7 +179,7 @@ export default function fovea(pi: ExtensionAPI) {
       async execute(id, params, signal, onUpdate, ctx) {
         const root = ctx.cwd;
         if (requestsNativeGrep(params)) {
-          const native = createGrepTool(root);
+          const native = await loadNativeGrepTool(root);
           return native.execute(id, params, signal, onUpdate);
         }
         const budget = configFor(root, ctx.isProjectTrusted()).tools.defaultBudget;
@@ -183,7 +187,7 @@ export default function fovea(pi: ExtensionAPI) {
         try {
           const result = await focus(root, query, budget, { fresh: true });
           if (Number(result.details.seeds ?? 0) === 0) {
-            const native = createGrepTool(root);
+            const native = await loadNativeGrepTool(root);
             return native.execute(id, params, signal, onUpdate);
           }
           return {
@@ -194,7 +198,7 @@ export default function fovea(pi: ExtensionAPI) {
           // A broken graph backend must not break text search: degrade to
           // native grep and mark the result, the way a graph miss does.
           const message = error instanceof Error ? error.message : String(error);
-          const native = createGrepTool(root);
+          const native = await loadNativeGrepTool(root);
           const fallback = await native.execute(id, params, signal, onUpdate);
           return {
             ...fallback,
@@ -542,6 +546,7 @@ export default function fovea(pi: ExtensionAPI) {
         return;
       }
       if (sub === "settings") {
+        const { openFoveaSettings } = await import("./ui/settings.js");
         const result = await openFoveaSettings(ctx, { onConfigApplied: () => configs.clear() });
         if (result.grepRegistrationChanged) {
           ctx.ui.notify("Reloading extensions to apply the grep tool change…", "info");

package/src/ui/settings.ts

@@ -6,12 +6,11 @@
 // external-editor keybinding switches the configuration layer being viewed and saved.
 
 import {
-  CONFIG_DIR_NAME,
   DynamicBorder,
-  getAgentDir,
   type ExtensionContext,
   type Theme,
 } from "@earendil-works/pi-coding-agent";
+import { configDirName, resolveAgentDir } from "../core/agent-dir.js";
 import {
   Container,
   type Component,
@@ -216,8 +215,8 @@ export class FoveaSettingsComponent extends Container {
 
   private updateSaveScopeText(): void {
     const destination = this.saveScope === "project"
-      ? `Project overrides (${CONFIG_DIR_NAME}/fovea.json)`
-      : `Global defaults (~/${CONFIG_DIR_NAME}/agent/fovea.json)`;
+      ? `Project overrides (${configDirName}/fovea.json)`
+      : `Global defaults (~/${configDirName}/agent/fovea.json)`;
     const keys = this.keybindings?.getKeys("app.editor.external") ?? [];
     const shortcut = keys.map(formatKey).join("/");
     const hint = !this.projectScopeAvailable
@@ -328,7 +327,7 @@ export const openFoveaSettings = async (
     context.ui.notify("Fovea settings are available in TUI mode", "warning");
     return { grepRegistrationChanged: false };
   }
-  const agentDir = getAgentDir();
+  const agentDir = resolveAgentDir();
   const scopes = {
     cwd: context.cwd,
     agentDir,