pim-agent 0.9.0 → 0.10.0

package/packages/core/src/session/SessionRegistry.ts

@@ -1,8 +1,13 @@
-import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import {
+  SessionManager,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
 
 import { Directories } from "../shared/Directories";
+import { Pool } from "../shared/Pool";
+import type { Surface } from "../shared/Surface";
 import { AgentRuntime, type ModelChoice } from "./AgentRuntime";
 import { EventLog } from "./EventLog";
 import { SessionCache } from "./SessionCache";
@@ -11,6 +16,8 @@ import {
   type CustomToolContext,
   type HostSettings,
 } from "./SessionHost";
+import { SessionLease } from "./SessionLease";
+import { SessionName } from "./SessionName";
 
 /** A session as pi stores it: one JSONL file under a cwd-encoded directory. */
 export type SessionSummary = {
@@ -33,6 +40,8 @@ export type SessionRegistryDeps = {
   ) => readonly ToolDefinition[];
   /** Appended to every session's system prompt. */
   readonly systemInstruction?: () => Promise<string | undefined>;
+  /** Where this frontend's human is reading. */
+  readonly surface?: Surface;
 };
 
 export type SessionCreateOptions = {
@@ -41,6 +50,9 @@ export type SessionCreateOptions = {
   readonly like?: SessionHost;
 };
 
+/** A session tree is thousands of files and each header is one open; fanning out over all of them at once is how a listing runs the process out of descriptors. */
+const HEADER_READS = 32;
+
 /** Live sessions keyed on pi's session UUID; the catalogue is pi's sessions directory, read on demand. */
 export class SessionRegistry {
   private readonly deps: SessionRegistryDeps;
@@ -63,18 +75,13 @@ export class SessionRegistry {
 
   /** Sessions on disk, newest first; reads only each file's header line. */
   public async list(cwd?: string): Promise<readonly SessionSummary[]> {
-    const root = this.sessionsRoot;
-    if (!(await stat(root).catch(() => undefined))?.isDirectory()) {
-      return [];
-    }
-    const paths: string[] = [];
-    for await (const relative of new Bun.Glob("*/*.jsonl").scan({
-      cwd: root,
-      onlyFiles: true,
-    })) {
-      paths.push(join(root, relative));
-    }
-    const summaries = (await Promise.all(paths.map(readSummary))).filter(
+    const summaries = (
+      await Pool.mapPooled(
+        await this.paths("*/*.jsonl"),
+        HEADER_READS,
+        readSummary
+      )
+    ).filter(
       (summary): summary is SessionSummary =>
         summary !== undefined && (cwd === undefined || summary.cwd === cwd)
     );
@@ -86,6 +93,38 @@ export class SessionRegistry {
     return this.hosts.peek(sessionId);
   }
 
+  /**
+   * Rename a session through pi's own session name, so its `/resume` picker shows
+   * it too; `null` clears it. A live session is renamed by its agent, a closed one
+   * by appending to its file under the turn lease. Answers with the name pi kept.
+   */
+  public async setName(
+    sessionId: string,
+    name: string | null
+  ): Promise<string | undefined> {
+    const host = this.peek(sessionId);
+    if (host?.agentSession) {
+      return await host.setName(name);
+    }
+    const summary = await this.find(sessionId);
+    if (summary === undefined) {
+      throw new Error(`unknown session: ${sessionId}`);
+    }
+    const next = SessionName.normalise(name);
+    // Reopening is a plain read today, but a pi that migrates the file rewrites it.
+    // The lease is only ever held for a whole turn, so a rename refuses rather than queues.
+    return await SessionLease.hold(
+      summary.path,
+      "daemon",
+      async () => {
+        const manager = SessionManager.open(summary.path);
+        manager.appendSessionInfo(next);
+        return manager.getSessionName();
+      },
+      { timeoutMs: 0 }
+    );
+  }
+
   /** Every model this machine has credentials for, qualified as `SessionHost.setModel` takes them. */
   public models(): readonly ModelChoice[] {
     return this.runtime.models();
@@ -96,7 +135,7 @@ export class SessionRegistry {
     if (cached) {
       return cached;
     }
-    const summary = (await this.list()).find((s) => s.sessionId === sessionId);
+    const summary = await this.find(sessionId);
     if (!summary) {
       throw new Error(`unknown session: ${sessionId}`);
     }
@@ -134,6 +173,39 @@ export class SessionRegistry {
     await this.hosts.disposeAll();
   }
 
+  /**
+   * One session by id. Pi names a file for the id it carries, so the usual
+   * answer is one glob and one header; resolving it by listing would read the
+   * header of every session on disk to throw all but one away.
+   */
+  private async find(sessionId: string): Promise<SessionSummary | undefined> {
+    for (const path of await this.paths(`*/*${sessionId}.jsonl`)) {
+      const summary = await readSummary(path);
+      if (summary?.sessionId === sessionId) {
+        return summary;
+      }
+    }
+    // A file named something else entirely: the id is the header's, not the name's.
+    return (await this.list()).find(
+      (summary) => summary.sessionId === sessionId
+    );
+  }
+
+  private async paths(pattern: string): Promise<readonly string[]> {
+    const root = this.sessionsRoot;
+    if (!(await stat(root).catch(() => undefined))?.isDirectory()) {
+      return [];
+    }
+    const found: string[] = [];
+    for await (const relative of new Bun.Glob(pattern).scan({
+      cwd: root,
+      onlyFiles: true,
+    })) {
+      found.push(join(root, relative));
+    }
+    return found;
+  }
+
   private buildHost(label: string, settings: HostSettings): SessionHost {
     return new SessionHost({
       label: `session ${label}`,
@@ -150,6 +222,9 @@ export class SessionRegistry {
       ...(this.deps.systemInstruction === undefined
         ? {}
         : { systemInstruction: this.deps.systemInstruction }),
+      ...(this.deps.surface === undefined
+        ? {}
+        : { surface: this.deps.surface }),
     });
   }
 }

package/packages/core/src/session/WriteMark.ts

@@ -33,5 +33,19 @@ function foreignSince(mark: WriteMark, next: WriteMark): boolean {
   return next.head - base.head - (next.entries - base.entries) > 0;
 }
 
+/**
+ * Whether every line the file gained since `mark` is one no reader has to replay.
+ * A rename appends `session_info` and moves no history, so a surface that absorbs
+ * it stays on the session it is already holding. Only ask between turns: a window
+ * that also holds our own appends is not benign, and a running turn's is.
+ */
+async function benignSince(log: EventLog, mark: WriteMark): Promise<boolean> {
+  const added = await log.read(mark.head);
+  return (
+    added.length > 0 &&
+    added.every(({ entry }) => entry.type === "session_info")
+  );
+}
+
 /** Write accounting over one session file: whose lines are these? */
-export const WriteMark = { UNREAD, of, foreignSince };
+export const WriteMark = { UNREAD, of, foreignSince, benignSince };

package/packages/core/src/shared/DiffLines.ts

@@ -301,4 +301,4 @@ function partLines(value: string): readonly string[] {
 
 const emptySide: ToolDiffSide = { lines: [], hasTrailingNewline: false };
 
-export const DiffLines = { buildToolDiff, fromText, emptySide };
+export const DiffLines = { buildToolDiff, fromText, emptySide, attachEmphasis };

package/packages/core/src/shared/DiffPatch.ts

@@ -0,0 +1,70 @@
+import * as Diff from "diff";
+import {
+  DiffLines,
+  type ToolDiff,
+  type ToolDiffHunk,
+  type ToolDiffLine,
+  type ToolDiffLineKind,
+} from "./DiffLines";
+
+function fromUnified(path: string, patch: string): ToolDiff | undefined {
+  const hunks = Diff.parsePatch(patch)
+    .flatMap((file) => file.hunks)
+    .map(toHunk)
+    .filter((hunk) => hunk.lines.length > 0);
+
+  return hunks.length === 0 ? undefined : { path, hunks };
+}
+
+function toHunk(hunk: Diff.StructuredPatchHunk): ToolDiffHunk {
+  const lines: ToolDiffLine[] = [];
+  let oldLine = hunk.oldStart;
+  let newLine = hunk.newStart;
+
+  for (const raw of hunk.lines) {
+    if (raw.startsWith("\\")) {
+      continue;
+    }
+
+    const kind = kindOf(raw);
+    const text = raw.slice(1);
+
+    if (kind === "added") {
+      lines.push({ kind, newLine, text });
+      newLine += 1;
+      continue;
+    }
+
+    if (kind === "removed") {
+      lines.push({ kind, oldLine, text });
+      oldLine += 1;
+      continue;
+    }
+
+    lines.push({ kind, oldLine, newLine, text });
+    oldLine += 1;
+    newLine += 1;
+  }
+
+  return {
+    oldStart: hunk.oldStart,
+    oldLines: hunk.oldLines,
+    newStart: hunk.newStart,
+    newLines: hunk.newLines,
+    lines: DiffLines.attachEmphasis(lines),
+  };
+}
+
+function kindOf(line: string): ToolDiffLineKind {
+  if (line.startsWith("+")) {
+    return "added";
+  }
+
+  if (line.startsWith("-")) {
+    return "removed";
+  }
+
+  return "context";
+}
+
+export const DiffPatch = { fromUnified };

package/packages/core/src/shared/DiffRenderer.ts

@@ -95,7 +95,7 @@ function highlightHunkLines(
   hunk: ToolDiffHunk,
   highlighter: DiffHighlighter
 ): readonly string[] {
-  const highlighted = DiffLayout.mapSides(hunk, highlighter);
+  const highlighted = DiffLayout.mapSides(hunk.lines, highlighter);
   return hunk.lines.map((line, index) => highlighted[index] ?? line.text);
 }
 

package/packages/core/src/shared/FileWatch.ts

@@ -8,6 +8,12 @@ import { basename, dirname, join } from "node:path";
 
 const POLL_MS = 1_000;
 
+/**
+ * A burst coalesces into one event, and the read it triggers can land inside
+ * the burst — so look once more after it, or the last write waits on the poll.
+ */
+const SETTLE_MS = 25;
+
 function signatureOf(path: string): string {
   const stats = statSync(path, { throwIfNoEntry: false });
   return stats === undefined
@@ -41,6 +47,13 @@ function follow(
   pollMs: number
 ): () => void {
   let watcher: FSWatcher | undefined;
+  let settle: ReturnType<typeof setTimeout> | undefined;
+  const fire = (): void => {
+    onEvent();
+    clearTimeout(settle);
+    settle = setTimeout(onEvent, SETTLE_MS);
+    settle.unref?.();
+  };
   const arm = (): void => {
     if (watcher !== undefined) {
       return;
@@ -48,7 +61,7 @@ function follow(
     try {
       watcher = watchFs(watched, { persistent: false }, (_event, changed) => {
         if (entry === undefined || changed === null || changed === entry) {
-          onEvent();
+          fire();
         }
       });
       watcher.on("error", () => {
@@ -66,6 +79,7 @@ function follow(
   timer.unref?.();
   return (): void => {
     clearInterval(timer);
+    clearTimeout(settle);
     try {
       watcher?.close();
     } catch {}