@lapis-notes/ai 0.1.2 → 0.1.5

package/dist/memory/memory-record-store.js

@@ -1,14 +1,13 @@
 import { TFile, TFolder } from "@lapis-notes/api/vault";
-import { parse, stringify } from "yaml";
-import { canonicalJson, sha256Text } from "./hashes";
-import { hasHiddenApplicationSegment, normalizeConversationScope, } from "../conversations/paths";
-const MEMORY_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,127}$/u;
-const MAX_MEMORY_FILE_BYTES = 512 * 1024;
-export class MemoryRecordConflictError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "MemoryRecordConflictError";
-    }
+import { stringify } from "yaml";
+import { MemoryRecordConflictError, serializeMemoryRecord, validateMemoryRecord, recordPath, recordDirectory, memoryRoot, sha256Text, __memoryRecordStoreInternals, } from "@lapismd/ai-controller/memory/lapis";
+export { InMemoryMemoryRecordStore, MemoryRecordConflictError, serializeMemoryRecord, validateMemoryRecord, recordPath, recordDirectory, memoryRoot, __memoryRecordStoreInternals, } from "@lapismd/ai-controller/memory/lapis";
+const { parseStoredRecord, revisionDirectory, scopeKey } = __memoryRecordStoreInternals;
+function sameScope(left, right) {
+    return scopeKey(left) === scopeKey(right);
+}
+function assertMemoryId(id) {
+    recordPath({ kind: "workspace" }, id);
 }
 export class VaultMemoryRecordStore {
     vault;
@@ -60,7 +59,8 @@ export class VaultMemoryRecordStore {
             throw new MemoryRecordConflictError(`Memory ${record.id} changed after consolidation preview`);
         }
         if (current) {
-            if (current.record.id !== record.id || !sameScope(current.record.scope, record.scope)) {
+            if (current.record.id !== record.id ||
+                !sameScope(current.record.scope, record.scope)) {
                 throw new MemoryRecordConflictError("Memory identity or scope changed externally");
             }
             if (record.revision !== current.record.revision + 1) {
@@ -71,7 +71,8 @@ export class VaultMemoryRecordStore {
             }
             await this.writeImmutablePreimage(current);
         }
-        else if (record.revision !== 1 || record.previousRevisionHash !== undefined) {
+        else if (record.revision !== 1 ||
+            record.previousRevisionHash !== undefined) {
             throw new MemoryRecordConflictError("A new memory must begin at revision 1 without a previous hash");
         }
         const content = serializeMemoryRecord(record);
@@ -95,7 +96,8 @@ export class VaultMemoryRecordStore {
         const records = [];
         for (const file of files) {
             try {
-                records.push((await parseStoredRecord(file.path, await this.vault.read(file))).record);
+                records.push((await parseStoredRecord(file.path, await this.vault.read(file)))
+                    .record);
             }
             catch {
                 // Corrupt external revision files stay visible in the vault but not active data.
@@ -119,9 +121,7 @@ export class VaultMemoryRecordStore {
             ...this.vault.getFilesByGlob(".lapis/agents/memory/exclusions/*.yaml"),
             ...this.vault.getFilesByGlob("**/.lapis/agents/memory/exclusions/*.yaml"),
         ];
-        return new Set(files
-            .map((file) => file.name.replace(/\.yaml$/u, ""))
-            .filter(Boolean));
+        return new Set(files.map((file) => file.name.replace(/\.yaml$/u, "")).filter(Boolean));
     }
     async writeConversationExclusion(location) {
         const scope = location.scopeDir
@@ -163,207 +163,3 @@ export class VaultMemoryRecordStore {
         await this.vault.create(path, content);
     }
 }
-export class InMemoryMemoryRecordStore {
-    #records = new Map();
-    #history = new Map();
-    #reviews = new Map();
-    #exclusions = new Map();
-    async list(scope) {
-        return [...this.#records.values()]
-            .filter((stored) => !scope || sameScope(scope, stored.record.scope))
-            .map((stored) => structuredClone(stored));
-    }
-    async find(id) {
-        return (await this.list()).filter((stored) => stored.record.id === id);
-    }
-    async write(record, options = {}) {
-        validateMemoryRecord(record);
-        const key = `${scopeKey(record.scope)}\u0000${record.id}`;
-        const current = this.#records.get(key);
-        if (!current &&
-            [...this.#records.values()].some((stored) => stored.record.id === record.id)) {
-            throw new MemoryRecordConflictError(`Memory ${record.id} already exists in another scope`);
-        }
-        if (options.expectedCurrentHash !== undefined &&
-            current?.hash !== options.expectedCurrentHash) {
-            throw new MemoryRecordConflictError("Memory changed after preview");
-        }
-        if (current) {
-            if (record.revision !== current.record.revision + 1 ||
-                record.previousRevisionHash !== current.hash) {
-                throw new MemoryRecordConflictError("Invalid memory revision preimage");
-            }
-            const history = this.#history.get(key) ?? [];
-            history.push(structuredClone(current.record));
-            this.#history.set(key, history);
-        }
-        else if (record.revision !== 1 || record.previousRevisionHash) {
-            throw new MemoryRecordConflictError("Invalid first memory revision");
-        }
-        const content = serializeMemoryRecord(record);
-        const stored = {
-            record: structuredClone(record),
-            path: recordPath(record.scope, record.id),
-            hash: await sha256Text(content),
-            content,
-        };
-        this.#records.set(key, stored);
-        return structuredClone(stored);
-    }
-    async listHistory(id, scope) {
-        return structuredClone(this.#history.get(`${scopeKey(scope)}\u0000${id}`) ?? []);
-    }
-    async writeReview(scope, jobId, markdown) {
-        const path = `${memoryRoot(scope)}/reviews/${jobId}.md`;
-        if (this.#reviews.has(path))
-            throw new MemoryRecordConflictError("Review exists");
-        this.#reviews.set(path, markdown);
-        return path;
-    }
-    async listExcludedConversationIds() {
-        return new Set(this.#exclusions.keys());
-    }
-    async writeConversationExclusion(location) {
-        const scope = location.scopeDir
-            ? { kind: "project", projectDir: location.scopeDir }
-            : { kind: "workspace" };
-        const path = `${memoryRoot(scope)}/exclusions/${location.conversationId}.yaml`;
-        this.#exclusions.set(location.conversationId, path);
-        return path;
-    }
-}
-export function memoryRoot(scope) {
-    return [
-        scope.kind === "project" ? scope.projectDir : "",
-        ".lapis",
-        "agents",
-        "memory",
-    ]
-        .filter(Boolean)
-        .join("/");
-}
-export function recordDirectory(scope) {
-    return `${memoryRoot(scope)}/${scope.kind}/records`;
-}
-export function recordPath(scope, id) {
-    assertMemoryId(id);
-    return `${recordDirectory(scope)}/${id}.md`;
-}
-function revisionDirectory(scope, id) {
-    return `${memoryRoot(scope)}/revisions/${id}`;
-}
-export function serializeMemoryRecord(record) {
-    validateMemoryRecord(record);
-    const { summary, ...frontmatter } = record;
-    return `---\n${stringify(frontmatter, { lineWidth: 0 })}---\n\n${summary.trim()}\n`;
-}
-async function parseStoredRecord(path, content) {
-    if (new TextEncoder().encode(content).byteLength > MAX_MEMORY_FILE_BYTES) {
-        throw new Error("Memory record exceeds the maximum supported size");
-    }
-    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n(?:\r?\n)?([\s\S]*)$/u.exec(content);
-    if (!match)
-        throw new Error("Memory record requires YAML frontmatter");
-    const metadata = parse(match[1], { maxAliasCount: 10 });
-    const record = validateMemoryRecord({
-        ...metadata,
-        summary: match[2].trim(),
-    });
-    const expectedPath = recordPath(record.scope, record.id);
-    const isRevision = path.startsWith(`${revisionDirectory(record.scope, record.id)}/`);
-    if (path !== expectedPath && !isRevision) {
-        throw new Error("Memory record path does not match its scope and identity");
-    }
-    return { record, path, hash: await sha256Text(content), content };
-}
-export function validateMemoryRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("Memory record must be an object");
-    }
-    const record = value;
-    if (record.schemaVersion !== 1)
-        throw new Error("Unsupported memory schema");
-    assertMemoryId(record.id);
-    if (!Number.isSafeInteger(record.revision) || record.revision < 1) {
-        throw new Error("Memory revision is invalid");
-    }
-    if (!["preference", "fact", "decision", "procedure", "constraint"].includes(record.kind)) {
-        throw new Error("Memory kind is invalid");
-    }
-    validateScope(record.scope);
-    if (record.status !== "active" && record.status !== "retracted") {
-        throw new Error("Memory status is invalid");
-    }
-    if (![1, 2, 3, 4, 5].includes(record.importance)) {
-        throw new Error("Memory importance is invalid");
-    }
-    if (!Array.isArray(record.triggers) || record.triggers.some((item) => typeof item !== "string")) {
-        throw new Error("Memory triggers are invalid");
-    }
-    if (typeof record.summary !== "string" || !record.summary.trim()) {
-        throw new Error("Memory summary is required");
-    }
-    if (!Array.isArray(record.evidence))
-        throw new Error("Memory evidence is invalid");
-    for (const evidence of record.evidence)
-        validateEvidence(evidence);
-    if (record.createdBy !== "owner-ui" && record.evidence.length === 0) {
-        throw new Error("Automatically generated memory requires evidence");
-    }
-    if (!["owner-ui", "deterministic-promotion", "consolidator"].includes(record.createdBy)) {
-        throw new Error("Memory creator is invalid");
-    }
-    for (const timestamp of [record.createdAt, record.updatedAt]) {
-        if (!Number.isFinite(Date.parse(timestamp)))
-            throw new Error("Memory timestamp is invalid");
-    }
-    if (record.previousRevisionHash !== undefined &&
-        !/^[0-9a-f]{64}$/u.test(record.previousRevisionHash)) {
-        throw new Error("Memory previous revision hash is invalid");
-    }
-    return structuredClone(record);
-}
-function validateEvidence(evidence) {
-    if (!evidence ||
-        typeof evidence.conversationId !== "string" ||
-        typeof evidence.entryId !== "string" ||
-        !/^[0-9a-f]{64}$/u.test(evidence.entryHash) ||
-        !Number.isFinite(Date.parse(evidence.observedAt)) ||
-        typeof evidence.scopeDirAtObservation !== "string") {
-        throw new Error("Memory evidence reference is invalid");
-    }
-}
-function validateScope(scope) {
-    if (!scope || !["user", "workspace", "project"].includes(scope.kind)) {
-        throw new Error("Memory scope is invalid");
-    }
-    if (scope.kind === "project") {
-        let normalized;
-        try {
-            normalized = normalizeConversationScope(scope.projectDir);
-        }
-        catch {
-            throw new Error("Project memory scope is invalid");
-        }
-        if (normalized !== scope.projectDir ||
-            hasHiddenApplicationSegment(normalized)) {
-            throw new Error("Project memory scope is invalid");
-        }
-    }
-}
-function assertMemoryId(id) {
-    if (!MEMORY_ID_PATTERN.test(id))
-        throw new Error("Memory ID is invalid");
-}
-function sameScope(left, right) {
-    return scopeKey(left) === scopeKey(right);
-}
-function scopeKey(scope) {
-    return scope.kind === "project" ? `project:${scope.projectDir}` : `${scope.kind}:`;
-}
-export const __memoryRecordStoreInternals = {
-    parseStoredRecord,
-    revisionDirectory,
-    scopeKey,
-    canonicalJson,
-};

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

@@ -1,21 +1 @@
-import type { AppDatabase } from "@lapis-notes/api";
-import type { ConsolidationResult, MemoryScope, MemoryService } from "./types";
-export type MemorySchedulerOptions = {
-    ownerId?: string;
-    idleMs?: number;
-    dailyMs?: number;
-    leaseMs?: number;
-    now?: () => number;
-    onError?: (operation: "consolidate", scope: MemoryScope, error: unknown) => void;
-};
-export declare class MemoryMaintenanceScheduler {
-    #private;
-    private readonly database;
-    private readonly memory;
-    constructor(database: AppDatabase, memory: MemoryService, options?: MemorySchedulerOptions);
-    start(): void;
-    noteActivity(scope: MemoryScope): void;
-    run(scope: MemoryScope): Promise<ConsolidationResult | null>;
-    dispose(): void;
-    private runDaily;
-}
+export { MemoryMaintenanceScheduler, type MemorySchedulerOptions, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/memory-scheduler.js

@@ -1,143 +1 @@
-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();
-    }
-}
+export { MemoryMaintenanceScheduler, } from "@lapismd/ai-controller/memory/lapis";

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

@@ -1,72 +1 @@
-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 {};
+export { NativeMemoryService, __memoryServiceInternals, type NativeMemoryServiceOptions, } from "@lapismd/ai-controller/memory/lapis";