@selesai/code 0.13.0 → 0.13.1

package/dist/extensions/pi-hermes-memory/src/handlers/session-flush.ts

@@ -0,0 +1,151 @@
+/**
+ * Session flush — gives the agent one turn to save memories before context is lost.
+ * Ported from hermes-agent/run_agent.py (flush_memories).
+ * See PLAN.md → "Hermes Source File Reference Map" for source lines.
+ *
+ * Default transport: in-process direct completion (same mechanism as
+ * background review — see review-memory-ops.ts). Falls back to a `pi -p`
+ * subprocess only if direct mode fails or reviewTransport forces subprocess.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { DatabaseManager } from "../store/db.js";
+import {
+  buildMemoryTargetRoutingGuidance,
+  DIRECT_FLUSH_SYSTEM_PROMPT,
+  ENTRY_DELIMITER,
+  FLUSH_PROMPT,
+} from "../constants.js";
+import type { MemoryConfig } from "../types.js";
+import { measureLifecycle } from "../lifecycle-timing.js";
+import { collectMessageParts } from "./message-parts.js";
+import { execChildPrompt, resolveChildPiModel } from "./pi-child-process.js";
+import { runDirectMemoryCompletion, usesDirectTransport } from "./review-memory-ops.js";
+import { resolveProjectName, resolveProjectStore, type ProjectNameRef, type ProjectStoreRef } from "../project-context.js";
+
+function buildDirectFlushUserPrompt(
+  store: MemoryStore,
+  projectStore: MemoryStore | null,
+  parts: string[],
+): string {
+  const sections = [
+    "--- Current Memory ---",
+    store.getMemoryEntries().join(ENTRY_DELIMITER) || "(empty)",
+    "",
+    "--- Current User Profile ---",
+    store.getUserEntries().join(ENTRY_DELIMITER) || "(empty)",
+  ];
+
+  if (projectStore) {
+    sections.push(
+      "",
+      "--- Current Project Memory ---",
+      projectStore.getMemoryEntries().join(ENTRY_DELIMITER) || "(empty)",
+    );
+  }
+
+  sections.push(
+    "",
+    "--- Conversation ---",
+    parts.join("\n\n"),
+  );
+
+  return sections.join("\n");
+}
+
+export function setupSessionFlush(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+  projectStore: ProjectStoreRef,
+  config: MemoryConfig,
+  dbManager: DatabaseManager | null = null,
+  projectName: ProjectNameRef = null,
+  deps: { runDirectMemoryCompletion?: typeof runDirectMemoryCompletion } = {},
+): void {
+  let userTurnCount = 0;
+  const runDirect = deps.runDirectMemoryCompletion ?? runDirectMemoryCompletion;
+
+  pi.on("message_end", async (event, _ctx) => {
+    if (event.message.role === "user") userTurnCount++;
+  });
+
+  /** Shared flush logic — builds conversation snapshot and saves memories */
+  async function flush(
+    ctx: Pick<ExtensionContext, "sessionManager" | "model" | "modelRegistry" | "cwd">,
+    signal?: AbortSignal,
+    timeoutMs = 30000,
+  ): Promise<void> {
+    if (userTurnCount < config.flushMinTurns) return;
+
+    let entries;
+    try {
+      entries = ctx.sessionManager.getBranch();
+    } catch {
+      return; // Context already stale
+    }
+
+    const parts = collectMessageParts(entries, config.flushRecentMessages);
+    const activeProjectStore = resolveProjectStore(projectStore);
+    const activeProjectName = resolveProjectName(projectName);
+
+    if (usesDirectTransport(config)) {
+      try {
+        const directResult = await runDirect(
+          ctx,
+          store,
+          activeProjectStore,
+          {
+            systemPrompt: [
+              DIRECT_FLUSH_SYSTEM_PROMPT,
+              "",
+              buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+            ].join("\n"),
+            userPrompt: buildDirectFlushUserPrompt(store, activeProjectStore, parts),
+            config,
+            timeoutMs,
+            signal,
+          },
+          dbManager,
+          activeProjectName,
+        );
+        if (directResult.ok) return;
+      } catch {
+        // Fall through to subprocess below.
+      }
+    }
+
+    const flushMessage = [
+      FLUSH_PROMPT,
+      "",
+      buildMemoryTargetRoutingGuidance(activeProjectStore !== null),
+      "",
+      "--- Conversation ---",
+      parts.join("\n\n"),
+    ].join("\n");
+
+    try {
+      await execChildPrompt(pi, flushMessage, config, {
+        cwd: ctx.cwd,
+        model: resolveChildPiModel(ctx.model),
+        signal,
+        timeoutMs,
+      });
+    } catch {
+      // Best-effort flush — never block compaction or shutdown.
+    }
+  }
+
+  // Flush before compaction (can afford to wait)
+  pi.on("session_before_compact", async (event, ctx) => {
+    if (!config.flushOnCompact) return;
+    await flush(ctx, event.signal, 30000);
+  });
+
+  // Flush before session shutdown. Pi awaits async session_shutdown handlers
+  // before invalidating the session, so await the bounded flush here.
+  pi.on("session_shutdown", async (event, ctx) => {
+    if (!config.flushOnShutdown || event.reason === "reload") return;
+    await measureLifecycle("shutdown.flush", () => flush(ctx, undefined, 10000));
+  });
+}

package/dist/extensions/pi-hermes-memory/src/handlers/session-live-index.ts

@@ -0,0 +1,94 @@
+import { measureLifecycleSync } from '../lifecycle-timing.js';
+import type { DatabaseManager } from '../store/db.js';
+import { indexLiveSession } from '../store/session-indexer.js';
+
+export const SESSION_LIVE_INDEX_DELAY_MS = 50;
+export const SESSION_LIVE_INDEX_SHUTDOWN_TIMEOUT_MS = 5000;
+
+type SetTimeoutFn = (callback: () => void, ms: number) => unknown;
+
+type SessionManagerSnapshot = Parameters<typeof indexLiveSession>[1];
+
+export interface SessionLiveIndexState {
+  inProgress: boolean;
+  promise: Promise<void> | null;
+}
+
+export const sessionLiveIndexState: SessionLiveIndexState = {
+  inProgress: false,
+  promise: null,
+};
+
+export interface ScheduleLiveSessionIndexOptions {
+  state?: SessionLiveIndexState;
+  setTimeoutFn?: SetTimeoutFn;
+  indexLiveSessionFn?: typeof indexLiveSession;
+  delayMs?: number;
+  onError?: (error: unknown) => void;
+}
+
+/**
+ * Schedule non-blocking indexing of the current live session.
+ *
+ * Pi emits message_end before it appends the finalized message to the JSONL
+ * session file/session manager. Deferring briefly lets Pi persist the entry
+ * first, then we index any message ids not already present in SQLite. Multiple
+ * message_end events in the same window coalesce into one all-missing sync.
+ */
+export function scheduleLiveSessionIndex(
+  dbManager: DatabaseManager,
+  sessionManager: SessionManagerSnapshot,
+  options: ScheduleLiveSessionIndexOptions = {},
+): boolean {
+  const state = options.state ?? sessionLiveIndexState;
+  if (state.inProgress) {
+    return false;
+  }
+
+  const setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+  const indexLiveSessionFn = options.indexLiveSessionFn ?? indexLiveSession;
+  const delayMs = options.delayMs ?? SESSION_LIVE_INDEX_DELAY_MS;
+
+  state.inProgress = true;
+  state.promise = new Promise<void>((resolve) => {
+    setTimeoutFn(() => {
+      measureLifecycleSync('live-index.callback', () => {
+        try {
+          dbManager.withCorruptionRecovery(() => {
+            indexLiveSessionFn(dbManager, sessionManager);
+          });
+        } catch (err) {
+          try { options.onError?.(err); } catch { /* best effort */ }
+        } finally {
+          state.inProgress = false;
+          state.promise = null;
+          resolve();
+        }
+      });
+    }, delayMs);
+  });
+
+  return true;
+}
+
+export async function waitForLiveSessionIndex(
+  timeoutMs = SESSION_LIVE_INDEX_SHUTDOWN_TIMEOUT_MS,
+  state: SessionLiveIndexState = sessionLiveIndexState,
+): Promise<boolean> {
+  const promise = state.promise;
+  if (!state.inProgress || !promise) {
+    return true;
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise.then(() => true),
+      new Promise<boolean>((resolve) => {
+        timeout = setTimeout(() => resolve(false), timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}