@oyasmi/pipiclaw 0.5.1 → 0.5.3

package/dist/memory/lifecycle.js

@@ -0,0 +1,246 @@
+import * as log from "../log.js";
+import { runBackgroundMaintenance, runInlineConsolidation, } from "./consolidation.js";
+import { updateChannelSessionMemory } from "./session.js";
+const IDLE_CONSOLIDATION_DELAY_MS = 60_000;
+export class MemoryLifecycle {
+    constructor(options) {
+        this.options = options;
+        this.backgroundQueue = Promise.resolve();
+        this.sessionRefreshQueue = Promise.resolve();
+        this.turnsSinceSessionUpdate = 0;
+        this.toolCallsSinceSessionUpdate = 0;
+        this.thresholdFailureBackoffTurnsRemaining = 0;
+        this.thresholdRefreshQueued = false;
+        this.sessionRefreshRunning = false;
+        this.durableDirty = false;
+        this.durableRevision = 0;
+        this.lastAssistantTurnRevision = 0;
+        this.lastDurableConsolidationRevision = 0;
+        this.idleConsolidationTimer = null;
+        this.idleConsolidationQueued = false;
+    }
+    buildRunOptions(messages, sessionEntries) {
+        return {
+            channelDir: this.options.channelDir,
+            model: this.options.getModel(),
+            resolveApiKey: this.options.resolveApiKey,
+            messages: messages ?? this.options.getMessages(),
+            sessionEntries: sessionEntries ?? this.options.getSessionEntries(),
+        };
+    }
+    createExtensionFactory() {
+        return (pi) => {
+            pi.on("session_before_compact", async (event) => {
+                await this.handleSessionBeforeCompact(event);
+            });
+            pi.on("session_compact", async (event) => {
+                this.handleSessionCompact(event);
+            });
+            pi.on("session_before_switch", async (event) => {
+                await this.handleSessionBeforeSwitch(event);
+            });
+            pi.on("session_switch", async (event) => {
+                this.handleSessionSwitch(event);
+            });
+        };
+    }
+    noteUserTurnStarted() {
+        this.clearIdleConsolidationTimer();
+    }
+    noteToolCall() {
+        this.durableDirty = true;
+        this.durableRevision++;
+        this.toolCallsSinceSessionUpdate++;
+        this.clearIdleConsolidationTimer();
+    }
+    noteCompletedAssistantTurn() {
+        this.durableDirty = true;
+        this.durableRevision++;
+        this.lastAssistantTurnRevision = this.durableRevision;
+        const settings = this.options.getSessionMemorySettings();
+        if (settings.enabled) {
+            this.turnsSinceSessionUpdate++;
+            let canTriggerThresholdRefresh = true;
+            if (this.thresholdFailureBackoffTurnsRemaining > 0) {
+                this.thresholdFailureBackoffTurnsRemaining--;
+                canTriggerThresholdRefresh = this.thresholdFailureBackoffTurnsRemaining === 0;
+            }
+            if (canTriggerThresholdRefresh &&
+                (this.turnsSinceSessionUpdate >= settings.minTurnsBetweenUpdate ||
+                    this.toolCallsSinceSessionUpdate >= settings.minToolCallsBetweenUpdate)) {
+                this.requestThresholdSessionRefresh();
+            }
+        }
+        this.scheduleIdleConsolidation();
+    }
+    clearIdleConsolidationTimer() {
+        if (!this.idleConsolidationTimer) {
+            return;
+        }
+        clearTimeout(this.idleConsolidationTimer);
+        this.idleConsolidationTimer = null;
+    }
+    shouldForceRefreshFor(reason, settings) {
+        if (!settings.enabled) {
+            return false;
+        }
+        return reason === "compaction" ? settings.forceRefreshBeforeCompact : settings.forceRefreshBeforeNewSession;
+    }
+    async refreshSessionMemory(request) {
+        const settings = this.options.getSessionMemorySettings();
+        if (!settings.enabled) {
+            return false;
+        }
+        const { reason } = request;
+        this.sessionRefreshRunning = true;
+        try {
+            await updateChannelSessionMemory({
+                channelDir: this.options.channelDir,
+                messages: request.messages ?? this.options.getMessages(),
+                model: this.options.getModel(),
+                resolveApiKey: this.options.resolveApiKey,
+                timeoutMs: settings.timeoutMs,
+            });
+            this.turnsSinceSessionUpdate = 0;
+            this.toolCallsSinceSessionUpdate = 0;
+            this.thresholdFailureBackoffTurnsRemaining = 0;
+            log.logInfo(`[${this.options.channelId}] Session memory updated (${reason})`);
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (reason === "threshold") {
+                this.thresholdFailureBackoffTurnsRemaining = Math.max(0, settings.failureBackoffTurns);
+            }
+            log.logWarning(`[${this.options.channelId}] Session memory update failed (${reason})`, message);
+            return false;
+        }
+        finally {
+            this.sessionRefreshRunning = false;
+        }
+    }
+    runSessionRefreshSerial(request) {
+        const run = async () => this.refreshSessionMemory(request);
+        const resultPromise = this.sessionRefreshQueue.then(run, run);
+        this.sessionRefreshQueue = resultPromise.then(() => undefined, () => undefined);
+        return resultPromise;
+    }
+    requestThresholdSessionRefresh() {
+        if (this.thresholdRefreshQueued || this.sessionRefreshRunning) {
+            return;
+        }
+        this.thresholdRefreshQueued = true;
+        void this.runSessionRefreshSerial({ reason: "threshold" }).finally(() => {
+            this.thresholdRefreshQueued = false;
+        });
+    }
+    enqueueBackgroundJob(job, failureMessage) {
+        this.backgroundQueue = this.backgroundQueue.then(job).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            log.logWarning(failureMessage, message);
+        });
+    }
+    hasPendingAssistantSnapshot() {
+        return this.durableDirty && this.lastAssistantTurnRevision > this.lastDurableConsolidationRevision;
+    }
+    markDurableConsolidationCheckpoint(revision) {
+        this.lastDurableConsolidationRevision = Math.max(this.lastDurableConsolidationRevision, revision);
+        this.durableDirty = this.durableRevision > this.lastDurableConsolidationRevision;
+    }
+    logConsolidationResult(reason, result) {
+        if (result.skipped) {
+            log.logInfo(`[${this.options.channelId}] Memory consolidation skipped (${reason}): no meaningful snapshot`);
+            return;
+        }
+        log.logInfo(`[${this.options.channelId}] Memory consolidation finished (${reason}): memory entries=${result.appendedMemoryEntries}, history=${result.appendedHistoryBlock ? "yes" : "no"}`);
+    }
+    scheduleIdleConsolidation() {
+        this.clearIdleConsolidationTimer();
+        if (!this.hasPendingAssistantSnapshot() || this.idleConsolidationQueued) {
+            return;
+        }
+        this.idleConsolidationTimer = setTimeout(() => {
+            this.idleConsolidationTimer = null;
+            if (!this.hasPendingAssistantSnapshot() || this.idleConsolidationQueued) {
+                return;
+            }
+            this.idleConsolidationQueued = true;
+            const messageSnapshot = [...this.options.getMessages()];
+            const sessionEntrySnapshot = [...this.options.getSessionEntries()];
+            const revisionSnapshot = this.durableRevision;
+            this.enqueueBackgroundJob(async () => {
+                try {
+                    log.logInfo(`[${this.options.channelId}] Memory consolidation starting (idle)`);
+                    const result = await runInlineConsolidation(this.buildRunOptions(messageSnapshot, sessionEntrySnapshot));
+                    this.markDurableConsolidationCheckpoint(revisionSnapshot);
+                    this.logConsolidationResult("idle", result);
+                    const maintenance = await runBackgroundMaintenance(this.buildRunOptions(messageSnapshot, sessionEntrySnapshot));
+                    this.logBackgroundResult(maintenance);
+                }
+                finally {
+                    this.idleConsolidationQueued = false;
+                    if (this.durableDirty) {
+                        this.scheduleIdleConsolidation();
+                    }
+                }
+            }, `[${this.options.channelId}] Memory consolidation failed (idle)`);
+        }, IDLE_CONSOLIDATION_DELAY_MS);
+    }
+    async runPreflightConsolidation(reason, messages, sessionEntries) {
+        this.clearIdleConsolidationTimer();
+        const messageSnapshot = [...(messages ?? this.options.getMessages())];
+        const sessionEntrySnapshot = sessionEntries ? [...sessionEntries] : [...this.options.getSessionEntries()];
+        const revisionSnapshot = this.durableRevision;
+        const settings = this.options.getSessionMemorySettings();
+        if (this.shouldForceRefreshFor(reason, settings)) {
+            await this.runSessionRefreshSerial({
+                reason,
+                messages: messageSnapshot,
+            });
+        }
+        try {
+            log.logInfo(`[${this.options.channelId}] Memory consolidation starting (${reason})`);
+            const result = await runInlineConsolidation(this.buildRunOptions(messageSnapshot, sessionEntrySnapshot));
+            this.markDurableConsolidationCheckpoint(revisionSnapshot);
+            this.logConsolidationResult(reason, result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.logWarning(`[${this.options.channelId}] Memory consolidation failed (${reason})`, message);
+        }
+    }
+    async handleSessionBeforeCompact(event) {
+        await this.runPreflightConsolidation("compaction", event.preparation.messagesToSummarize);
+    }
+    handleSessionCompact(_event) {
+        this.enqueueBackgroundMaintenance();
+    }
+    async handleSessionBeforeSwitch(event) {
+        if (event.reason !== "new") {
+            return;
+        }
+        await this.runPreflightConsolidation("new-session");
+    }
+    handleSessionSwitch(event) {
+        if (event.reason !== "new") {
+            return;
+        }
+        this.enqueueBackgroundMaintenance();
+    }
+    enqueueBackgroundMaintenance() {
+        this.enqueueBackgroundJob(async () => {
+            const result = await runBackgroundMaintenance(this.buildRunOptions([], []));
+            this.logBackgroundResult(result);
+        }, `[${this.options.channelId}] Background memory maintenance failed`);
+    }
+    logBackgroundResult(result) {
+        if (!result.cleanedMemory && !result.foldedHistory) {
+            return;
+        }
+        const details = [
+            `memory cleanup=${result.cleanedMemory ? "yes" : "no"}`,
+            `history fold=${result.foldedHistory ? "yes" : "no"}`,
+        ].join(", ");
+        log.logInfo(`[${this.options.channelId}] Background memory maintenance complete: ${details}`);
+    }
+}

package/dist/{memory-recall.d.ts → memory/recall.d.ts}

@@ -1,5 +1,5 @@
 import type { Api, Model } from "@mariozechner/pi-ai";
-import { type MemoryCandidate, type MemoryCandidateCache } from "./memory-candidates.js";
+import { type MemoryCandidate, type MemoryCandidateCache } from "./candidates.js";
 export interface RecallRequest {
     query: string;
     workspaceDir: string;
@@ -25,5 +25,5 @@ export interface RecallResult {
     items: RecalledMemory[];
     renderedText: string;
 }
+export declare function tokenizeRecallText(text: string): string[];
 export declare function recallRelevantMemory(request: RecallRequest): Promise<RecallResult>;
-//# sourceMappingURL=memory-recall.d.ts.map