@chendpoc/pi-memory 0.2.2 → 0.2.4

package/src/ipc/jsonlFramer.ts

@@ -1,29 +0,0 @@
-/** Incremental JSONL (one JSON object per line) framing for UDS IPC. */
-
-export class JsonlFramer {
-  private buffer = "";
-
-  push(chunk: string): string[] {
-    this.buffer += chunk;
-    const lines: string[] = [];
-    let idx: number;
-    while ((idx = this.buffer.indexOf("\n")) !== -1) {
-      const line = this.buffer.slice(0, idx);
-      this.buffer = this.buffer.slice(idx + 1);
-      if (line.trim()) lines.push(line);
-    }
-    return lines;
-  }
-
-  reset(): void {
-    this.buffer = "";
-  }
-}
-
-export function serializeJsonlFrame(value: unknown): string {
-  return `${JSON.stringify(value)}\n`;
-}
-
-export function parseJsonlLine<T>(line: string): T {
-  return JSON.parse(line) as T;
-}

package/src/pi-extension.ts

@@ -1,294 +0,0 @@
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import findLastIndex from "lodash/findLastIndex.js";
-
-import { createLlmClient, type LlmClient } from "./adapters/llm/index.js";
-import { loadEnv, readPiMemoryEnv, resolveMemoryAgentDir } from "./config/index.js";
-import { readPreflightRuntimeConfig } from "./config/preflight.js";
-import { createConsolidateScheduler, startConsolidateInterval, type ConsolidateScheduler } from "./consolidate/scheduler.js";
-import { registerCommands } from "./commands/index.js";
-import { registerCompactHandlers } from "./compact/register.js";
-import { runEpisodicPreflight } from "./preflight/episodic.js";
-import { queryIntentCache } from "./preflight/intentCache.js";
-import { mergePrivateMemoryBlocks, renderMemoryCapPrivateMemory } from "./preflight/render.js";
-import { isSubagentSession } from "./preflight/session.js";
-import { injectPrivateMemoryContext } from "./preflight/strip.js";
-import { enqueueShutdownMetadata, readParentSession } from "./shutdown/enqueue.js";
-import { resolveSidecarPaths } from "./sidecar/paths.js";
-import { formatTimestamp } from "./utils/time.js";
-import { createReindexScheduler, type ReindexScheduler } from "./sidecar/reindexBridge.js";
-import { warmSidecar } from "./sidecar/warmup.js";
-import { ensureSidecarRunning, stopSidecar } from "./sidecar/sidecarManager.js";
-import { MemoryStore } from "./store/memoryStore.js";
-
-loadEnv();
-
-type TurnPreflight = {
-  userPayload: string;
-  privateContext: string;
-};
-
-let memoryStore: MemoryStore | null = null;
-let sidecarPaths: ReturnType<typeof resolveSidecarPaths> | null = null;
-let reindexScheduler: ReindexScheduler | null = null;
-let consolidateScheduler: ConsolidateScheduler | null = null;
-let stopConsolidateInterval: (() => void) | null = null;
-let llmClient: LlmClient | null = null;
-let sessionMemoryCap: string | null = null;
-let turnPreflight: TurnPreflight | null = null;
-let isFirstTurn = false;
-let isSubagent = false;
-let sessionId: string | null = null;
-
-function getUserMessageText(message: AgentMessage): string | null {
-  if (message.role !== "user") return null;
-  if (typeof message.content === "string") return message.content;
-  return message.content
-    .filter((block) => block.type === "text")
-    .map((block) => block.text)
-    .join("\n");
-}
-
-function setUserMessageText(message: AgentMessage, text: string): AgentMessage {
-  if (message.role !== "user") return message;
-  return { ...message, content: text } as AgentMessage;
-}
-
-function findLastUserMessageIndex(messages: AgentMessage[]): number {
-  return findLastIndex(messages, (message) => message.role === "user");
-}
-
-async function refreshLlm(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void> {
-  const env = readPiMemoryEnv();
-  const flagModel = pi.getFlag("memory-helper-model");
-  const modelSpec = typeof flagModel === "string" ? flagModel : env.helperModel;
-  llmClient = await createLlmClient({ ctx, modelSpec, env });
-}
-
-async function bootstrapSidecar(): Promise<void> {
-  if (!memoryStore || !sidecarPaths) return;
-
-  await memoryStore.ensureInitialized();
-  await ensureSidecarRunning({
-    socketPath: sidecarPaths.socketPath,
-    dbPath: sidecarPaths.dbPath,
-  });
-
-  if (readPreflightRuntimeConfig().warmSidecar) {
-    try {
-      await warmSidecar(sidecarPaths.socketPath);
-    } catch {
-      // warm is best-effort
-    }
-  }
-
-  reindexScheduler ??= createReindexScheduler({
-    sidecar: sidecarPaths,
-    agentDir: memoryStore.agentDir,
-    getDocuments: () => memoryStore!.exportForIndex(),
-    debounceMs: readPiMemoryEnv().reindexDebounceMs,
-  });
-
-  memoryStore.onSyncToSidecar(() => reindexScheduler?.schedule());
-
-  await reindexScheduler.runNow();
-}
-
-function bootstrapConsolidate(): void {
-  if (!memoryStore) return;
-
-  consolidateScheduler = createConsolidateScheduler({
-    getStore: () => memoryStore,
-    getAgentDir: () => memoryStore?.agentDir ?? null,
-    getLlm: () => llmClient,
-    debounceMs: readPiMemoryEnv().consolidateDebounceMs,
-    onComplete: preloadSessionMemoryCap,
-  });
-
-  memoryStore.onConsolidateCheck(() => consolidateScheduler?.schedule());
-
-  stopConsolidateInterval?.();
-  stopConsolidateInterval = startConsolidateInterval(() => {
-    void consolidateScheduler?.runNow();
-  });
-
-  void consolidateScheduler.runNow();
-}
-
-async function preloadSessionMemoryCap(): Promise<void> {
-  if (!memoryStore) return;
-  const fallback = await memoryStore.readForFallback();
-  sessionMemoryCap = renderMemoryCapPrivateMemory(fallback) || null;
-}
-
-export default function piMemoryExtension(pi: ExtensionAPI): void {
-  pi.on("session_start", async (_event, ctx) => {
-    const agentDir = resolveMemoryAgentDir();
-    memoryStore = new MemoryStore({ agentDir });
-    sidecarPaths = resolveSidecarPaths(agentDir);
-    isSubagent = isSubagentSession(ctx);
-    isFirstTurn = true;
-    turnPreflight = null;
-    sessionId = ctx.sessionManager.getSessionFile() ?? null;
-
-    await refreshLlm(ctx, pi);
-
-    try {
-      await bootstrapSidecar();
-      bootstrapConsolidate();
-      await preloadSessionMemoryCap();
-    } catch {
-      // sidecar optional; preflight falls back to MEMORY.md
-    }
-  });
-
-  pi.on("session_shutdown", async (event, ctx) => {
-    if (memoryStore) {
-      const header = ctx.sessionManager.getHeader() as unknown as Record<string, unknown> | null;
-      void enqueueShutdownMetadata(memoryStore.agentDir, {
-        sessionFile: ctx.sessionManager.getSessionFile() ?? "",
-        parentSession: readParentSession(header),
-        reason: event.reason,
-        isSubagent,
-        enqueuedAt: formatTimestamp(),
-      }).catch(() => {});
-    }
-
-    if (sessionId) {
-      queryIntentCache.clearSession(sessionId);
-    }
-
-    stopConsolidateInterval?.();
-    stopConsolidateInterval = null;
-    consolidateScheduler = null;
-    reindexScheduler = null;
-    memoryStore = null;
-    sidecarPaths = null;
-    llmClient = null;
-    sessionMemoryCap = null;
-    turnPreflight = null;
-    isFirstTurn = false;
-    isSubagent = false;
-    sessionId = null;
-
-    try {
-      await stopSidecar();
-    } catch {
-      // ignore shutdown errors
-    }
-  });
-
-  pi.on("model_select", async (_event, ctx) => {
-    await refreshLlm(ctx, pi);
-  });
-
-  pi.on("before_agent_start", async (event, ctx) => {
-    if (!memoryStore || !sidecarPaths) return;
-
-    const userPayload = String(event.prompt ?? "").trim();
-    if (!userPayload) return;
-
-    const forceHelper = isFirstTurn;
-    isFirstTurn = false;
-
-    if (isSubagent) {
-      turnPreflight = { userPayload, privateContext: sessionMemoryCap ?? "" };
-      return;
-    }
-
-    const workingUi = ctx.hasUI
-      ? {
-          show: (msg: string) => ctx.ui.setWorkingMessage(msg),
-          update: (msg: string) => ctx.ui.setWorkingMessage(msg),
-          clear: () => ctx.ui.setWorkingMessage(),
-        }
-      : null;
-
-    try {
-      workingUi?.show("Recalling memory…");
-      const env = readPiMemoryEnv();
-      const result = await runEpisodicPreflight(userPayload, {
-        socketPath: sidecarPaths.socketPath,
-        agentDir: memoryStore.agentDir,
-        store: memoryStore,
-        llm: llmClient,
-        forceEpisodic: forceHelper,
-        sessionId: sessionId ?? undefined,
-        budgetMs: env.preflightBudgetMs,
-        signal: ctx.signal,
-        onProgress: workingUi?.update,
-      });
-
-      const episodicContext = result?.privateContext ?? null;
-      const combined = mergePrivateMemoryBlocks(sessionMemoryCap, episodicContext);
-      turnPreflight = { userPayload, privateContext: combined ?? "" };
-    } finally {
-      workingUi?.clear();
-    }
-  });
-
-  pi.on("context", async (event, ctx) => {
-    if (!memoryStore || !sidecarPaths) return;
-
-    const userIndex = findLastUserMessageIndex(event.messages);
-    if (userIndex < 0) return;
-
-    const scaffolded = getUserMessageText(event.messages[userIndex]!);
-    if (!scaffolded?.trim()) return;
-
-    let privateContext: string | undefined;
-    let userPayload: string;
-
-    if (turnPreflight && turnPreflight.userPayload === scaffolded.trim()) {
-      privateContext = turnPreflight.privateContext || undefined;
-      userPayload = turnPreflight.userPayload;
-    } else {
-      const userTurnCount = event.messages.filter((message) => message.role === "user").length;
-      const env = readPiMemoryEnv();
-
-      if (isSubagent) {
-        privateContext = sessionMemoryCap ?? undefined;
-        userPayload = scaffolded;
-        turnPreflight = { userPayload: scaffolded, privateContext: privateContext ?? "" };
-      } else {
-        const preflight = await runEpisodicPreflight(scaffolded, {
-          socketPath: sidecarPaths.socketPath,
-          agentDir: memoryStore.agentDir,
-          store: memoryStore,
-          llm: llmClient,
-          forceEpisodic: userTurnCount === 1,
-          sessionId: sessionId ?? undefined,
-          budgetMs: env.preflightBudgetMs,
-          signal: ctx.signal,
-        });
-        privateContext = mergePrivateMemoryBlocks(
-          sessionMemoryCap,
-          preflight?.privateContext,
-        ) || undefined;
-        userPayload = scaffolded;
-        turnPreflight = { userPayload: scaffolded, privateContext: privateContext ?? "" };
-      }
-    }
-
-    if (!privateContext) return;
-
-    const injectedText = injectPrivateMemoryContext(scaffolded, userPayload, privateContext);
-    const messages = [...event.messages];
-    messages[userIndex] = setUserMessageText(messages[userIndex]!, injectedText);
-    return { messages };
-  });
-
-  registerCommands(pi, {
-    getMemoryStore: () => memoryStore,
-    onRemembered: preloadSessionMemoryCap,
-    getAgentDir: () => memoryStore?.agentDir ?? resolveMemoryAgentDir(),
-  });
-
-  registerCompactHandlers(pi, {
-    getMemoryStore: () => memoryStore,
-    getLlmClient: () => llmClient,
-    onCompactionIngested: preloadSessionMemoryCap,
-  });
-}
-
-export { piMemoryExtension };

package/src/preflight/episodic.ts

@@ -1,183 +0,0 @@
-import { readPreflightRuntimeConfig } from "../config/preflight.js";
-import { resolvePreflightBudget } from "../config/preflightBudget.js";
-import type { LlmClient } from "../adapters/llm/types.js";
-import { debugMemory } from "../utils/debugLog.js";
-import { nowMs, remainingMs } from "../utils/time.js";
-import type { MemoryStore } from "../store/memoryStore.js";
-import { query } from "../sidecar/client.js";
-import {
-  buildRetrievalQuery,
-  extractQueryIntent,
-  shouldRunEpisodicPreflight,
-} from "./queryIntent.js";
-import { sidecarQueryCache } from "./queryCache.js";
-import {
-  renderFallbackPrivateMemory,
-  renderSidecarPrivateMemory,
-} from "./render.js";
-
-export type EpisodicPreflightOptions = {
-  socketPath: string;
-  agentDir: string;
-  store: MemoryStore;
-  llm?: LlmClient | null;
-  /** Force episodic gate (first turn); does not force helper LLM. */
-  forceEpisodic?: boolean;
-  /** Force helper LLM intent extraction. */
-  forceIntent?: boolean;
-  /** @deprecated Use forceEpisodic */
-  force?: boolean;
-  sessionId?: string;
-  budgetMs?: number;
-  signal?: AbortSignal;
-  onProgress?: (message: string) => void;
-};
-
-export type EpisodicPreflightResult = {
-  privateContext: string;
-};
-
-async function withTimeout<T>(
-  promise: Promise<T>,
-  timeoutMs: number,
-  signal?: AbortSignal,
-): Promise<T> {
-  if (signal?.aborted) {
-    throw new Error("aborted");
-  }
-  if (timeoutMs <= 0) {
-    throw new Error("preflight timeout");
-  }
-
-  return new Promise<T>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error("preflight timeout")), timeoutMs);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(new Error("aborted"));
-    };
-
-    signal?.addEventListener("abort", onAbort, { once: true });
-
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        resolve(value);
-      },
-      (error) => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", onAbort);
-        reject(error);
-      },
-    );
-  });
-}
-
-/**
- * Fail-silent episodic preflight: QueryIntent (optional) → buildRetrievalQuery → sidecar.query → fallback.
- */
-export async function runEpisodicPreflight(
-  userInput: string,
-  options: EpisodicPreflightOptions,
-): Promise<EpisodicPreflightResult | null> {
-  const startedAt = nowMs();
-  const forceEpisodic = options.forceEpisodic ?? options.force ?? false;
-  const runtime = readPreflightRuntimeConfig();
-
-  try {
-    if (await options.store.isEmpty()) {
-      debugMemory("preflight", "skipped", { reason: "empty" });
-      return null;
-    }
-
-    if (!shouldRunEpisodicPreflight(userInput, forceEpisodic)) {
-      debugMemory("preflight", "skipped", { reason: "gate" });
-      return null;
-    }
-
-    options.onProgress?.("Searching memory...");
-    const budget = resolvePreflightBudget(options.budgetMs);
-    const deadline = nowMs() + budget.totalMs;
-
-    const intentStartedAt = nowMs();
-    const intentBudget = Math.min(budget.intentMs, remainingMs(deadline));
-    let intent;
-    let intentSkipped = false;
-    let intentCacheHit = false;
-
-    try {
-      const extracted = await withTimeout(
-        extractQueryIntent(userInput, options.llm ?? null, {
-          forceIntent: options.forceIntent,
-          signal: options.signal,
-          sessionId: options.sessionId,
-          intentCache: runtime.intentCache,
-        }),
-        intentBudget,
-        options.signal,
-      );
-      intent = extracted.intent;
-      intentSkipped = extracted.skipped;
-      intentCacheHit = extracted.cacheHit;
-    } catch {
-      intent = { raw_query: userInput.trim() };
-    }
-    const intentMs = nowMs() - intentStartedAt;
-
-    const retrievalQuery = buildRetrievalQuery(intent, userInput);
-    const cached = sidecarQueryCache.get(options.agentDir, retrievalQuery);
-
-    let privateContext = "";
-    let cacheHit = false;
-    let sidecarMs = 0;
-    let resultCount = 0;
-    let usedFallback = false;
-
-    if (cached) {
-      cacheHit = true;
-      resultCount = cached.length;
-      privateContext = renderSidecarPrivateMemory(retrievalQuery, cached);
-    } else {
-      const sidecarStartedAt = nowMs();
-      const queryBudget = Math.min(budget.sidecarMs, remainingMs(deadline));
-      try {
-        const result = await withTimeout(
-          query(options.socketPath, retrievalQuery, queryBudget),
-          queryBudget,
-          options.signal,
-        );
-        sidecarMs = nowMs() - sidecarStartedAt;
-        resultCount = result.results.length;
-        sidecarQueryCache.set(options.agentDir, retrievalQuery, result.results);
-        privateContext = renderSidecarPrivateMemory(retrievalQuery, result.results);
-      } catch {
-        sidecarMs = nowMs() - sidecarStartedAt;
-        // sidecar unavailable or timed out → fallback
-      }
-    }
-
-    if (!privateContext.trim()) {
-      usedFallback = true;
-      const fallback = await options.store.readForFallback();
-      privateContext = renderFallbackPrivateMemory(fallback);
-      resultCount = fallback.trim() ? 1 : 0;
-    }
-
-    debugMemory("preflight", "recall", {
-      intent_ms: intentMs,
-      intent_skipped: intentSkipped,
-      intent_cache_hit: intentCacheHit,
-      sidecar_ms: sidecarMs,
-      total_ms: nowMs() - startedAt,
-      cache_hit: cacheHit,
-      fallback: usedFallback,
-      results: resultCount,
-    });
-
-    if (!privateContext.trim()) return null;
-    return { privateContext };
-  } catch {
-    debugMemory("preflight", "failed", { total_ms: nowMs() - startedAt });
-    return null;
-  }
-}

package/src/preflight/intentCache.ts

@@ -1,44 +0,0 @@
-import { LRUCache } from "lru-cache";
-
-import { INTENT_CACHE_MAX_ENTRIES } from "../constants/preflight.js";
-import type { QueryIntent } from "./queryIntent.js";
-
-function normalizeInput(input: string): string {
-  return input.trim().replace(/\s+/g, " ").toLowerCase();
-}
-
-function cacheKey(sessionId: string, userInput: string): string {
-  return `${sessionId}\0${normalizeInput(userInput)}`;
-}
-
-class QueryIntentCache {
-  private readonly lru = new LRUCache<string, QueryIntent>({ max: INTENT_CACHE_MAX_ENTRIES });
-
-  get(sessionId: string | undefined, userInput: string): QueryIntent | null {
-    if (!sessionId) return null;
-    return this.lru.get(cacheKey(sessionId, userInput)) ?? null;
-  }
-
-  set(sessionId: string | undefined, userInput: string, intent: QueryIntent): void {
-    if (!sessionId) return;
-    this.lru.set(cacheKey(sessionId, userInput), intent);
-  }
-
-  clearSession(sessionId: string): void {
-    const prefix = `${sessionId}\0`;
-    for (const key of this.lru.keys()) {
-      if (key.startsWith(prefix)) this.lru.delete(key);
-    }
-  }
-
-  /** @internal test hook */
-  resetForTests(): void {
-    this.lru.clear();
-  }
-}
-
-export const queryIntentCache = new QueryIntentCache();
-
-export function resetQueryIntentCacheForTests(): void {
-  queryIntentCache.resetForTests();
-}

package/src/preflight/queryCache.ts

@@ -1,59 +0,0 @@
-import { LRUCache } from "lru-cache";
-
-import { QUERY_CACHE_MAX_ENTRIES } from "../constants/timing.js";
-import type { MemoryEntry } from "../sidecar/protocol.js";
-
-type CacheValue = {
-  results: MemoryEntry[];
-  indexGeneration: number;
-};
-
-function normalizeQuery(query: string): string {
-  return query.trim().replace(/\s+/g, " ").toLowerCase();
-}
-
-function cacheKey(agentDir: string, query: string): string {
-  return `${agentDir}\0${normalizeQuery(query)}`;
-}
-
-class SidecarQueryCache {
-  private readonly generationByAgent = new Map<string, number>();
-  private readonly lru = new LRUCache<string, CacheValue>({ max: QUERY_CACHE_MAX_ENTRIES });
-
-  getGeneration(agentDir: string): number {
-    return this.generationByAgent.get(agentDir) ?? 0;
-  }
-
-  get(agentDir: string, query: string): MemoryEntry[] | null {
-    const hit = this.lru.get(cacheKey(agentDir, query));
-    if (!hit) return null;
-    if (hit.indexGeneration !== this.getGeneration(agentDir)) return null;
-    return hit.results;
-  }
-
-  set(agentDir: string, query: string, results: MemoryEntry[]): void {
-    this.lru.set(cacheKey(agentDir, query), {
-      results,
-      indexGeneration: this.getGeneration(agentDir),
-    });
-  }
-
-  onReindexComplete(agentDir: string, indexGeneration: number): void {
-    this.generationByAgent.set(agentDir, indexGeneration);
-    for (const key of this.lru.keys()) {
-      if (key.startsWith(`${agentDir}\0`)) this.lru.delete(key);
-    }
-  }
-
-  /** @internal test hook */
-  resetForTests(): void {
-    this.generationByAgent.clear();
-    this.lru.clear();
-  }
-}
-
-export const sidecarQueryCache = new SidecarQueryCache();
-
-export function resetSidecarQueryCacheForTests(): void {
-  sidecarQueryCache.resetForTests();
-}