@chendpoc/pi-memory 0.2.3 → 0.3.1

package/dist/extension/createMemoryRuntime.js

@@ -0,0 +1,203 @@
+import { createLlmClient } from "../adapters/llm/index.js";
+import { readPiMemoryEnv, resolveMemoryAgentDir } from "../config/index.js";
+import { runEpisodicPreflight } from "../preflight/episodic.js";
+import { queryIntentCache } from "../preflight/intentCache.js";
+import { injectPrivateMemoryContext } from "../preflight/strip.js";
+import { enqueueShutdownMetadata } from "../shutdown/enqueue.js";
+import { resolveSidecarPaths } from "../sidecar/paths.js";
+import { stopSidecar } from "../sidecar/sidecarManager.js";
+import { isSubagentSession, readParentSession } from "../utils/session/index.js";
+import { formatTimestamp } from "../utils/time.js";
+import { MemoryStore } from "../store/memoryStore.js";
+import { syncMaintenanceScheduler } from "../scheduler/sync.js";
+import { bootstrapConsolidate, bootstrapSidecar, loadSessionMemoryCap, mergePrivateMemoryBlocks, } from "./lifecycle.js";
+import { findLastUserMessageIndex, getUserMessageText, setUserMessageText, } from "./messageUtils.js";
+class MemoryRuntimeImpl {
+    store;
+    sidecarPaths;
+    sessionId;
+    isSubagent;
+    llmClient = null;
+    sessionMemoryCap = null;
+    turnPreflight = null;
+    isFirstTurn = true;
+    reindexScheduler = null;
+    consolidateScheduler = null;
+    stopConsolidateInterval = null;
+    unsubSyncToSidecar = null;
+    unsubConsolidateCheck = null;
+    constructor(opts) {
+        const agentDir = opts.agentDir ?? resolveMemoryAgentDir();
+        this.store = new MemoryStore({ agentDir });
+        this.sidecarPaths = resolveSidecarPaths(agentDir);
+        this.isSubagent = isSubagentSession(opts.ctx);
+        this.sessionId = opts.ctx.sessionManager.getSessionFile() ?? null;
+    }
+    getLlm() {
+        return this.llmClient;
+    }
+    getSessionMemoryCap() {
+        return this.sessionMemoryCap;
+    }
+    getTurnPreflight() {
+        return this.turnPreflight;
+    }
+    async bootstrap(ctx, pi) {
+        this.isFirstTurn = true;
+        this.turnPreflight = null;
+        await this.refreshLlm(ctx, pi);
+        await this.store.ensureInitialized();
+        void syncMaintenanceScheduler({ agentDir: this.store.agentDir });
+        try {
+            const sidecar = await bootstrapSidecar({
+                store: this.store,
+                sidecarPaths: this.sidecarPaths,
+                reindexScheduler: this.reindexScheduler,
+            });
+            this.reindexScheduler = sidecar.reindexScheduler;
+            this.unsubSyncToSidecar = sidecar.unsubSyncToSidecar;
+            const consolidate = bootstrapConsolidate({
+                store: this.store,
+                getLlm: () => this.llmClient,
+                onComplete: () => this.reloadSessionMemoryCap(),
+                stopExistingInterval: this.stopConsolidateInterval,
+            });
+            this.consolidateScheduler = consolidate.consolidateScheduler;
+            this.stopConsolidateInterval = consolidate.stopConsolidateInterval;
+            this.unsubConsolidateCheck = consolidate.unsubConsolidateCheck;
+            await this.reloadSessionMemoryCap();
+        }
+        catch {
+            // sidecar optional; preflight falls back to MEMORY.md
+        }
+    }
+    async refreshLlm(ctx, pi) {
+        const env = readPiMemoryEnv();
+        const flagModel = pi.getFlag("memory-helper-model");
+        const modelSpec = typeof flagModel === "string" ? flagModel : env.helperModel;
+        this.llmClient = await createLlmClient({ ctx, modelSpec, env });
+    }
+    async runBeforeAgentStart(event, ctx) {
+        const userPayload = String(event.prompt ?? "").trim();
+        if (!userPayload)
+            return;
+        const forceHelper = this.isFirstTurn;
+        this.isFirstTurn = false;
+        if (this.isSubagent) {
+            this.turnPreflight = { userPayload, privateContext: this.sessionMemoryCap ?? "" };
+            return;
+        }
+        const workingUi = ctx.hasUI
+            ? {
+                show: (msg) => ctx.ui.setWorkingMessage(msg),
+                update: (msg) => ctx.ui.setWorkingMessage(msg),
+                clear: () => ctx.ui.setWorkingMessage(),
+            }
+            : null;
+        try {
+            workingUi?.show("Recalling memory…");
+            const env = readPiMemoryEnv();
+            const result = await runEpisodicPreflight(userPayload, {
+                socketPath: this.sidecarPaths.socketPath,
+                agentDir: this.store.agentDir,
+                store: this.store,
+                llm: this.llmClient,
+                forceEpisodic: forceHelper,
+                sessionId: this.sessionId ?? undefined,
+                budgetMs: env.preflightBudgetMs,
+                signal: ctx.signal,
+                onProgress: workingUi?.update,
+            });
+            const episodicContext = result?.privateContext ?? null;
+            const combined = mergePrivateMemoryBlocks(this.sessionMemoryCap, episodicContext);
+            this.turnPreflight = { userPayload, privateContext: combined ?? "" };
+        }
+        finally {
+            workingUi?.clear();
+        }
+    }
+    async runContext(event, ctx) {
+        const userIndex = findLastUserMessageIndex(event.messages);
+        if (userIndex < 0)
+            return;
+        const scaffolded = getUserMessageText(event.messages[userIndex]);
+        if (!scaffolded?.trim())
+            return;
+        let privateContext;
+        let userPayload;
+        if (this.turnPreflight && this.turnPreflight.userPayload === scaffolded.trim()) {
+            privateContext = this.turnPreflight.privateContext || undefined;
+            userPayload = this.turnPreflight.userPayload;
+        }
+        else {
+            const userTurnCount = event.messages.filter((message) => message.role === "user").length;
+            const env = readPiMemoryEnv();
+            if (this.isSubagent) {
+                privateContext = this.sessionMemoryCap ?? undefined;
+                userPayload = scaffolded;
+                this.turnPreflight = { userPayload: scaffolded, privateContext: privateContext ?? "" };
+            }
+            else {
+                const preflight = await runEpisodicPreflight(scaffolded, {
+                    socketPath: this.sidecarPaths.socketPath,
+                    agentDir: this.store.agentDir,
+                    store: this.store,
+                    llm: this.llmClient,
+                    forceEpisodic: userTurnCount === 1,
+                    sessionId: this.sessionId ?? undefined,
+                    budgetMs: env.preflightBudgetMs,
+                    signal: ctx.signal,
+                });
+                privateContext =
+                    mergePrivateMemoryBlocks(this.sessionMemoryCap, preflight?.privateContext) || undefined;
+                userPayload = scaffolded;
+                this.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 };
+    }
+    async shutdown(event, ctx) {
+        const header = ctx.sessionManager.getHeader();
+        void enqueueShutdownMetadata(this.store.agentDir, {
+            sessionFile: ctx.sessionManager.getSessionFile() ?? "",
+            parentSession: readParentSession(header),
+            reason: event.reason,
+            isSubagent: this.isSubagent,
+            enqueuedAt: formatTimestamp(),
+        }).catch(() => { });
+        if (this.sessionId) {
+            queryIntentCache.clearSession(this.sessionId);
+        }
+    }
+    async reloadSessionMemoryCap() {
+        this.sessionMemoryCap = await loadSessionMemoryCap(this.store);
+    }
+    async dispose() {
+        this.stopConsolidateInterval?.();
+        this.stopConsolidateInterval = null;
+        this.unsubSyncToSidecar?.();
+        this.unsubSyncToSidecar = null;
+        this.unsubConsolidateCheck?.();
+        this.unsubConsolidateCheck = null;
+        this.consolidateScheduler = null;
+        this.reindexScheduler = null;
+        this.llmClient = null;
+        this.sessionMemoryCap = null;
+        this.turnPreflight = null;
+        this.isFirstTurn = false;
+        try {
+            await stopSidecar();
+        }
+        catch {
+            // ignore shutdown errors
+        }
+    }
+}
+export function createMemoryRuntime(opts) {
+    return new MemoryRuntimeImpl(opts);
+}

package/dist/extension/index.d.ts

@@ -0,0 +1,2 @@
+export { createMemoryRuntime } from "./createMemoryRuntime.js";
+export type { CreateMemoryRuntimeOptions, MemoryRuntime, TurnPreflight } from "./types.js";

package/dist/extension/index.js

@@ -0,0 +1 @@
+export { createMemoryRuntime } from "./createMemoryRuntime.js";

package/dist/extension/lifecycle.d.ts

@@ -0,0 +1,28 @@
+import { type ConsolidateScheduler } from "../consolidate/scheduler.js";
+import type { LlmClient } from "../adapters/llm/types.js";
+import { mergePrivateMemoryBlocks } from "../preflight/render.js";
+import { type ReindexScheduler } from "../sidecar/reindexBridge.js";
+import type { SidecarPaths } from "../sidecar/paths.js";
+import type { MemoryStore } from "../store/memoryStore.js";
+export type SidecarBootstrapResult = {
+    reindexScheduler: ReindexScheduler;
+    unsubSyncToSidecar: () => void;
+};
+export declare function bootstrapSidecar(opts: {
+    store: MemoryStore;
+    sidecarPaths: SidecarPaths;
+    reindexScheduler: ReindexScheduler | null;
+}): Promise<SidecarBootstrapResult>;
+export type ConsolidateBootstrapResult = {
+    consolidateScheduler: ConsolidateScheduler;
+    stopConsolidateInterval: () => void;
+    unsubConsolidateCheck: () => void;
+};
+export declare function bootstrapConsolidate(opts: {
+    store: MemoryStore;
+    getLlm: () => LlmClient | null;
+    onComplete: () => Promise<void>;
+    stopExistingInterval: (() => void) | null;
+}): ConsolidateBootstrapResult;
+export declare function loadSessionMemoryCap(store: MemoryStore): Promise<string | null>;
+export { mergePrivateMemoryBlocks };

package/dist/extension/lifecycle.js

@@ -0,0 +1,52 @@
+import { readPiMemoryEnv } from "../config/index.js";
+import { readPreflightRuntimeConfig } from "../config/preflight.js";
+import { createConsolidateScheduler, startConsolidateInterval, } from "../consolidate/scheduler.js";
+import { mergePrivateMemoryBlocks, renderMemoryCapPrivateMemory } from "../preflight/render.js";
+import { createReindexScheduler } from "../sidecar/reindexBridge.js";
+import { ensureSidecarRunning } from "../sidecar/sidecarManager.js";
+import { warmSidecar } from "../sidecar/warmup.js";
+export async function bootstrapSidecar(opts) {
+    await ensureSidecarRunning({
+        socketPath: opts.sidecarPaths.socketPath,
+        dbPath: opts.sidecarPaths.dbPath,
+    });
+    if (readPreflightRuntimeConfig().warmSidecar) {
+        try {
+            await warmSidecar(opts.sidecarPaths.socketPath);
+        }
+        catch {
+            // warm is best-effort
+        }
+    }
+    const reindexScheduler = opts.reindexScheduler ??
+        createReindexScheduler({
+            sidecar: opts.sidecarPaths,
+            agentDir: opts.store.agentDir,
+            getDocuments: () => opts.store.exportForIndex(),
+            debounceMs: readPiMemoryEnv().reindexDebounceMs,
+        });
+    const unsubSyncToSidecar = opts.store.onSyncToSidecar(() => reindexScheduler.schedule());
+    await reindexScheduler.runNow();
+    return { reindexScheduler, unsubSyncToSidecar };
+}
+export function bootstrapConsolidate(opts) {
+    const consolidateScheduler = createConsolidateScheduler({
+        getStore: () => opts.store,
+        getAgentDir: () => opts.store.agentDir,
+        getLlm: opts.getLlm,
+        debounceMs: readPiMemoryEnv().consolidateDebounceMs,
+        onComplete: opts.onComplete,
+    });
+    const unsubConsolidateCheck = opts.store.onConsolidateCheck(() => consolidateScheduler.schedule());
+    opts.stopExistingInterval?.();
+    const stopConsolidateInterval = startConsolidateInterval(() => {
+        void consolidateScheduler.runNow();
+    });
+    void consolidateScheduler.runNow();
+    return { consolidateScheduler, stopConsolidateInterval, unsubConsolidateCheck };
+}
+export async function loadSessionMemoryCap(store) {
+    const fallback = await store.readForFallback();
+    return renderMemoryCapPrivateMemory(fallback) || null;
+}
+export { mergePrivateMemoryBlocks };

package/dist/extension/messageUtils.d.ts

@@ -0,0 +1,4 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+export declare function getUserMessageText(message: AgentMessage): string | null;
+export declare function setUserMessageText(message: AgentMessage, text: string): AgentMessage;
+export declare function findLastUserMessageIndex(messages: AgentMessage[]): number;

package/dist/extension/messageUtils.js

@@ -0,0 +1,18 @@
+export function getUserMessageText(message) {
+    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");
+}
+export function setUserMessageText(message, text) {
+    if (message.role !== "user")
+        return message;
+    return { ...message, content: text };
+}
+export function findLastUserMessageIndex(messages) {
+    return messages.findLastIndex((message) => message.role === "user");
+}

package/dist/extension/types.d.ts

@@ -0,0 +1,35 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ExtensionAPI, ExtensionContext, SessionShutdownEvent } from "@earendil-works/pi-coding-agent";
+import type { LlmClient } from "../adapters/llm/types.js";
+import type { SidecarPaths } from "../sidecar/paths.js";
+import type { MemoryStore } from "../store/memoryStore.js";
+export type TurnPreflight = {
+    userPayload: string;
+    privateContext: string;
+};
+export type MemoryRuntime = {
+    readonly store: MemoryStore;
+    readonly sidecarPaths: SidecarPaths;
+    readonly sessionId: string | null;
+    readonly isSubagent: boolean;
+    getLlm(): LlmClient | null;
+    getSessionMemoryCap(): string | null;
+    getTurnPreflight(): TurnPreflight | null;
+    bootstrap(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void>;
+    refreshLlm(ctx: ExtensionContext, pi: ExtensionAPI): Promise<void>;
+    runBeforeAgentStart(event: {
+        prompt?: unknown;
+    }, ctx: ExtensionContext): Promise<void>;
+    runContext(event: {
+        messages: AgentMessage[];
+    }, ctx: ExtensionContext): Promise<{
+        messages: AgentMessage[];
+    } | undefined>;
+    shutdown(event: SessionShutdownEvent, ctx: ExtensionContext): Promise<void>;
+    reloadSessionMemoryCap(): Promise<void>;
+    dispose(): Promise<void>;
+};
+export type CreateMemoryRuntimeOptions = {
+    ctx: ExtensionContext;
+    agentDir?: string;
+};

package/dist/extension/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,11 +1,9 @@
-export { initializeMemoryWorkspace, type InitMemoryWorkspaceResult } from "./init/workspace.js";
-export { loadEnv } from "./config/loadEnv.js";
-export { resolveAgentDirFromEnv, resolveMemoryAgentDir, type ResolveMemoryAgentDirOptions } from "./config/agentDir.js";
-export { readPiMemoryEnv, resolveEmbedDim, type PiMemoryEnv } from "./config/env.js";
+export { initializeMemoryWorkspace, type InitMemoryWorkspaceResult } from "./store/initWorkspace.js";
+export { resolveAgentDirFromEnv, resolveMemoryAgentDir, type ResolveMemoryAgentDirOptions, } from "./config/agentDir.js";
+export { createMemoryStore, MemoryStore } from "./store/memoryStore.js";
 export { runConsolidateJob, type RunConsolidateJobResult } from "./consolidate/runJob.js";
-export * from "./constants/index.js";
-export * from "./utils/index.js";
-export { MemoryStore } from "./store/memoryStore.js";
-export { ensureSidecarRunning, stopSidecar } from "./sidecar/sidecarManager.js";
-export { query, reindex, ping } from "./sidecar/client.js";
+export { mergeMemoryEntries, scheduleMergeMemoryEntriesInBackground } from "./consolidate/mergeMemoryEntries.js";
+export { runDrainShutdownQueueJob, type RunDrainShutdownQueueResult, } from "./shutdown/runDrainJob.js";
 export { createLlmClient, type LlmClient } from "./adapters/llm/index.js";
+export { DEFAULT_MEMORY_FILE, MEMORY_SECTIONS, type MemorySection, } from "./constants/memory.js";
+export { PI_MEMORY_DATA_SUBDIR, PI_MEMORY_ENV_FILE_NAME } from "./constants/paths.js";

package/dist/index.js

@@ -1,11 +1,9 @@
-export { initializeMemoryWorkspace } from "./init/workspace.js";
-export { loadEnv } from "./config/loadEnv.js";
-export { resolveAgentDirFromEnv, resolveMemoryAgentDir } from "./config/agentDir.js";
-export { readPiMemoryEnv, resolveEmbedDim } from "./config/env.js";
+export { initializeMemoryWorkspace } from "./store/initWorkspace.js";
+export { resolveAgentDirFromEnv, resolveMemoryAgentDir, } from "./config/agentDir.js";
+export { createMemoryStore, MemoryStore } from "./store/memoryStore.js";
 export { runConsolidateJob } from "./consolidate/runJob.js";
-export * from "./constants/index.js";
-export * from "./utils/index.js";
-export { MemoryStore } from "./store/memoryStore.js";
-export { ensureSidecarRunning, stopSidecar } from "./sidecar/sidecarManager.js";
-export { query, reindex, ping } from "./sidecar/client.js";
+export { mergeMemoryEntries, scheduleMergeMemoryEntriesInBackground } from "./consolidate/mergeMemoryEntries.js";
+export { runDrainShutdownQueueJob, } from "./shutdown/runDrainJob.js";
 export { createLlmClient } from "./adapters/llm/index.js";
+export { DEFAULT_MEMORY_FILE, MEMORY_SECTIONS, } from "./constants/memory.js";
+export { PI_MEMORY_DATA_SUBDIR, PI_MEMORY_ENV_FILE_NAME } from "./constants/paths.js";