@lapis-notes/ai 0.1.0

package/dist/memory/memory-scheduler.js

@@ -0,0 +1,143 @@
+import { sha256Text } from "./hashes";
+import { memoryScopeKey } from "./paths";
+const DEFAULT_IDLE_MS = 30 * 60 * 1_000;
+const DEFAULT_DAILY_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_LEASE_MS = 5 * 60 * 1_000;
+export class MemoryMaintenanceScheduler {
+    database;
+    memory;
+    #ownerId;
+    #idleMs;
+    #dailyMs;
+    #leaseMs;
+    #now;
+    #onError;
+    #idleTimers = new Map();
+    #scopes = new Map();
+    #dailyTimer;
+    #disposed = false;
+    constructor(database, memory, options = {}) {
+        this.database = database;
+        this.memory = memory;
+        this.#ownerId = options.ownerId ?? crypto.randomUUID();
+        this.#idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
+        this.#dailyMs = options.dailyMs ?? DEFAULT_DAILY_MS;
+        this.#leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+        this.#now = options.now ?? (() => Date.now());
+        this.#onError = options.onError ?? (() => { });
+    }
+    start() {
+        if (this.#disposed || this.#dailyTimer)
+            return;
+        this.#dailyTimer = setTimeout(() => void this.runDaily(), this.#dailyMs);
+    }
+    noteActivity(scope) {
+        if (this.#disposed)
+            return;
+        const key = memoryScopeKey(scope);
+        this.#scopes.set(key, scope);
+        const current = this.#idleTimers.get(key);
+        if (current)
+            clearTimeout(current);
+        this.#idleTimers.set(key, setTimeout(() => {
+            this.#idleTimers.delete(key);
+            void this.run(scope);
+        }, this.#idleMs));
+    }
+    async run(scope) {
+        if (this.#disposed)
+            return null;
+        const preview = await this.memory.previewConsolidation(scope);
+        if (preview.proposals === 0)
+            return null;
+        const now = this.#now();
+        const scopeKey = memoryScopeKey(scope);
+        const candidateFingerprint = (await sha256Text([...preview.candidateIds].sort().join("\n"))).slice(0, 16);
+        const job = {
+            id: `consolidate:${scopeKey}:${new Date(now).toISOString().slice(0, 10)}:${candidateFingerprint}`,
+            kind: "consolidate",
+            scopeKey,
+            status: "queued",
+            attempts: 0,
+            maxAttempts: 3,
+            createdAt: now,
+        };
+        const claimed = await this.database.claimMemoryJob({
+            job,
+            ownerId: this.#ownerId,
+            now,
+            leaseMs: this.#leaseMs,
+        });
+        if (!claimed)
+            return null;
+        const renew = setInterval(() => {
+            const renewedAt = this.#now();
+            void this.database.updateMemoryJob({
+                jobId: job.id,
+                ownerId: this.#ownerId,
+                now: renewedAt,
+                patch: {
+                    status: "running",
+                    leaseUntil: renewedAt + this.#leaseMs,
+                },
+            });
+        }, Math.max(1_000, Math.floor(this.#leaseMs / 2)));
+        try {
+            const result = await this.memory.consolidate(scope);
+            await this.database.updateMemoryJob({
+                jobId: job.id,
+                ownerId: this.#ownerId,
+                now: this.#now(),
+                patch: { status: "completed", finishedAt: this.#now() },
+            });
+            return result;
+        }
+        catch (error) {
+            await this.database.updateMemoryJob({
+                jobId: job.id,
+                ownerId: this.#ownerId,
+                now: this.#now(),
+                patch: {
+                    status: "failed",
+                    finishedAt: this.#now(),
+                    errorCode: "consolidation-failed",
+                },
+            });
+            this.#onError("consolidate", scope, error);
+            return null;
+        }
+        finally {
+            clearInterval(renew);
+        }
+    }
+    dispose() {
+        this.#disposed = true;
+        if (this.#dailyTimer)
+            clearTimeout(this.#dailyTimer);
+        this.#dailyTimer = undefined;
+        for (const timer of this.#idleTimers.values())
+            clearTimeout(timer);
+        this.#idleTimers.clear();
+        this.#scopes.clear();
+    }
+    async runDaily() {
+        this.#dailyTimer = undefined;
+        if (this.#disposed)
+            return;
+        for (const candidate of await this.database.queryMemoryCandidates({
+            states: ["staged"],
+            limit: 10_000,
+        })) {
+            const scope = candidate.candidate.scopeKind === "project"
+                ? {
+                    kind: "project",
+                    projectDir: candidate.candidate.scopePath,
+                }
+                : { kind: candidate.candidate.scopeKind };
+            this.#scopes.set(memoryScopeKey(scope), scope);
+        }
+        for (const scope of this.#scopes.values())
+            await this.run(scope);
+        this.start();
+    }
+}

package/dist/memory/memory-tools.d.ts

@@ -0,0 +1,61 @@
+import type { AppTool } from "@lapis-notes/api/agent-tools";
+import type { MemoryService } from "./types";
+export declare function createMemoryAppTools(service: MemoryService): AppTool[];
+export declare const MEMORY_APP_TOOL_SCHEMAS: {
+    memorySearch: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["query"];
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 2000;
+            };
+            readonly scope: {
+                readonly type: "string";
+                readonly enum: readonly ["current", "workspace"];
+            };
+            readonly corpus: {
+                readonly type: "string";
+                readonly enum: readonly ["curated", "episodic", "all"];
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly minimum: 1;
+                readonly maximum: 20;
+            };
+            readonly since: {
+                readonly type: "string";
+                readonly minLength: 10;
+                readonly maxLength: 64;
+            };
+            readonly before: {
+                readonly type: "string";
+                readonly minLength: 10;
+                readonly maxLength: 64;
+            };
+            readonly includeSuperseded: {
+                readonly type: "boolean";
+            };
+        };
+    };
+    memoryGet: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["ref"];
+        readonly properties: {
+            readonly ref: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 512;
+            };
+            readonly includeEvidence: {
+                readonly type: "boolean";
+            };
+            readonly includeHistory: {
+                readonly type: "boolean";
+            };
+        };
+    };
+};

package/dist/memory/memory-tools.js

@@ -0,0 +1,99 @@
+const MEMORY_SEARCH_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["query"],
+    properties: {
+        query: { type: "string", minLength: 1, maxLength: 2_000 },
+        scope: { type: "string", enum: ["current", "workspace"] },
+        corpus: { type: "string", enum: ["curated", "episodic", "all"] },
+        limit: { type: "integer", minimum: 1, maximum: 20 },
+        since: { type: "string", minLength: 10, maxLength: 64 },
+        before: { type: "string", minLength: 10, maxLength: 64 },
+        includeSuperseded: { type: "boolean" },
+    },
+};
+const MEMORY_GET_INPUT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["ref"],
+    properties: {
+        ref: { type: "string", minLength: 1, maxLength: 512 },
+        includeEvidence: { type: "boolean" },
+        includeHistory: { type: "boolean" },
+    },
+};
+export function createMemoryAppTools(service) {
+    return [createMemorySearchTool(service), createMemoryGetTool(service)];
+}
+function createMemorySearchTool(service) {
+    return {
+        name: "memory_search",
+        description: "Search app-owned durable and episodic memory in the current vault. Returns compact results with provenance references; use memory_get for exact evidence.",
+        inputSchema: structuredClone(MEMORY_SEARCH_INPUT_SCHEMA),
+        outputSchema: { type: "object" },
+        effect: "read",
+        execute: async (input, context) => {
+            context.signal.throwIfAborted();
+            const query = {
+                query: input.query,
+                ...(input.scope ? { scope: input.scope } : {}),
+                ...(input.corpus ? { corpus: input.corpus } : {}),
+                ...(input.limit ? { limit: input.limit } : {}),
+                ...(input.since ? { since: input.since } : {}),
+                ...(input.before ? { before: input.before } : {}),
+                ...(input.includeSuperseded !== undefined
+                    ? { includeSuperseded: input.includeSuperseded }
+                    : {}),
+            };
+            const results = await service.search(query, memoryContext(context), context.signal);
+            context.signal.throwIfAborted();
+            const structuredContent = { results };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: results.length === 0
+                            ? "No matching memory found."
+                            : JSON.stringify(results, null, 2),
+                    },
+                ],
+                structuredContent,
+            };
+        },
+    };
+}
+function createMemoryGetTool(service) {
+    return {
+        name: "memory_get",
+        description: "Resolve one opaque memory reference and verify its original transcript evidence without returning a complete transcript.",
+        inputSchema: structuredClone(MEMORY_GET_INPUT_SCHEMA),
+        outputSchema: { type: "object" },
+        effect: "read",
+        execute: async (input, context) => {
+            context.signal.throwIfAborted();
+            const detail = await service.get(input.ref, memoryContext(context), context.signal);
+            const projected = {
+                ...detail,
+                evidenceMessages: input.includeEvidence === false ? [] : detail.evidenceMessages.slice(0, 6),
+                history: input.includeHistory ? detail.history : undefined,
+            };
+            const structuredContent = JSON.parse(JSON.stringify(projected));
+            return {
+                content: [{ type: "text", text: JSON.stringify(projected, null, 2) }],
+                structuredContent,
+            };
+        },
+    };
+}
+function memoryContext(context) {
+    return {
+        scopeDir: context.scope.directory,
+        conversationId: context.conversationId,
+        agentBindingId: context.agentBindingId,
+        runId: context.runId,
+    };
+}
+export const MEMORY_APP_TOOL_SCHEMAS = {
+    memorySearch: MEMORY_SEARCH_INPUT_SCHEMA,
+    memoryGet: MEMORY_GET_INPUT_SCHEMA,
+};

package/dist/memory/native-memory-service.d.ts

@@ -0,0 +1,72 @@
+import type { AppDatabase } from "@lapis-notes/api";
+import type { ConversationRepository } from "../conversations/conversation-repository";
+import type { AgentContextBlock } from "../core/types";
+import type { ConversationLocation, ConversationSnapshot, TranscriptEntry } from "../conversations/types";
+import { type MemoryRecordStore } from "./memory-record-store";
+import type { ConsolidationPreview, ConsolidationResult, MemoryContext, MemoryDetail, MemoryOriginClass, MemoryRebuildResult, MemoryForgetPreview, MemoryForgetResult, MemoryScope, MemorySearchQuery, MemorySearchResult, MemoryService, MemoryConsolidationProvider } from "./types";
+type RankedEpisode = {
+    path: string;
+    result: MemorySearchResult;
+    retrievalScore: number;
+};
+export type NativeMemoryServiceOptions = {
+    now?: () => Date;
+    yieldToApp?: () => Promise<void>;
+    recordStore?: MemoryRecordStore;
+    consolidationProvider?: MemoryConsolidationProvider | (() => MemoryConsolidationProvider | undefined);
+};
+export declare class NativeMemoryService implements MemoryService {
+    #private;
+    private readonly repository;
+    private readonly database;
+    constructor(repository: ConversationRepository, database: AppDatabase, options?: NativeMemoryServiceOptions);
+    ingestConversation(location: ConversationLocation): Promise<void>;
+    search(query: MemorySearchQuery, context: MemoryContext, signal?: AbortSignal): Promise<MemorySearchResult[]>;
+    recall(query: string, context: MemoryContext, signal?: AbortSignal): Promise<AgentContextBlock[]>;
+    get(ref: string, _context: MemoryContext, signal?: AbortSignal): Promise<MemoryDetail>;
+    rebuild(scope?: MemoryScope): Promise<MemoryRebuildResult>;
+    previewForgetConversation(location: ConversationLocation): Promise<MemoryForgetPreview>;
+    forgetConversation(location: ConversationLocation): Promise<MemoryForgetResult>;
+    previewConsolidation(scope: MemoryScope): Promise<ConsolidationPreview>;
+    consolidate(scope: MemoryScope): Promise<ConsolidationResult>;
+    private markInconsistent;
+    private removeStaleConversationDocuments;
+    private curatedSearchDocument;
+    private verifyEvidence;
+    private getCurated;
+    private resolveCandidateEvidence;
+    private markCandidatePromoted;
+    private writeConsolidationReview;
+    private recordRecallSignals;
+}
+type ProjectedEpisode = {
+    entry: Extract<TranscriptEntry, {
+        type: "message" | "tool";
+    }>;
+    entryHash: string;
+    text: string;
+    originClass: MemoryOriginClass;
+};
+declare function projectEpisodes(snapshot: ConversationSnapshot): Promise<ProjectedEpisode[]>;
+declare function episodeRef(conversationId: string, entryId: string): string;
+declare function curatedRef(id: string, revision: number): string;
+declare function parseCuratedRef(ref: string): {
+    id: string;
+    revision: number;
+} | null;
+declare function parseEpisodeRef(ref: string): {
+    conversationId: string;
+    entryId: string;
+} | null;
+declare function selectMmr(candidates: RankedEpisode[], limit: number): RankedEpisode[];
+declare function contradictory(current: string, proposed: string): boolean;
+export declare const __memoryServiceInternals: {
+    contradictory: typeof contradictory;
+    curatedRef: typeof curatedRef;
+    episodeRef: typeof episodeRef;
+    parseCuratedRef: typeof parseCuratedRef;
+    parseEpisodeRef: typeof parseEpisodeRef;
+    projectEpisodes: typeof projectEpisodes;
+    selectMmr: typeof selectMmr;
+};
+export {};