om-memory-system 3.0.0

package/dist/importer/importer.js

@@ -0,0 +1,260 @@
+import { existsSync } from "node:fs";
+import { captureConversation } from "../core/capture.js";
+import { memoryClient } from "../services/client.js";
+import { extractScopeFromContainerTag } from "../services/memory-scope.js";
+import { getTags } from "../services/tags.js";
+import { tursoConnectionManager } from "../services/turso/connection-manager.js";
+import { tursoShardManager } from "../services/turso/shard-manager.js";
+import { extractPiConversationWindows, } from "../adapters/pi/conversation.js";
+import { discoverPiSessions } from "./discovery.js";
+import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
+export function buildImportKey(sessionId, window) {
+    const terminalEntryId = window.sourceEntryIds?.[window.sourceEntryIds.length - 1];
+    if (!terminalEntryId)
+        return null;
+    return `pi:${sessionId}:${window.userEntryId}:${terminalEntryId}`;
+}
+/**
+ * Find a stored memory by its deterministic import identity. Used to
+ * reconcile crash windows: the memory insert landed but the ledger update did
+ * not commit.
+ */
+export async function findMemoryIdByImportId(projectHash, importId) {
+    const shards = await tursoShardManager.getAllShards("project", projectHash);
+    const escaped = importId.replace(/[\\%_]/g, (char) => `\\${char}`);
+    for (const shard of shards) {
+        const db = await tursoConnectionManager.getConnection(shard.dbPath);
+        const row = await db.get(`SELECT id FROM memories WHERE metadata LIKE ? ESCAPE '\\'`, [
+            `%"importId":"${escaped}"%`,
+        ]);
+        if (row)
+            return String(row.id);
+    }
+    return null;
+}
+function resolveSessionDirectory(cwd, pathMaps) {
+    if (!cwd)
+        return null;
+    const mapped = pathMaps.find((map) => map.from === cwd)?.to;
+    const directory = mapped ?? cwd;
+    return existsSync(directory) ? directory : null;
+}
+function preview(text) {
+    const trimmed = text.trim().replace(/\s+/g, " ");
+    return trimmed.length > 60 ? `${trimmed.slice(0, 60)}...` : trimmed;
+}
+function windowWithinDateRange(window, filters) {
+    if (window.userTimestamp === undefined)
+        return true;
+    if (filters.since !== undefined && window.userTimestamp < filters.since)
+        return false;
+    if (filters.until !== undefined && window.userTimestamp > filters.until)
+        return false;
+    return true;
+}
+async function lookupExistingMemory(projectHash, key, options) {
+    if (!options.storageAccessible)
+        return null;
+    try {
+        return await findMemoryIdByImportId(projectHash, key);
+    }
+    catch {
+        return null;
+    }
+}
+export async function importPiHistory(deps, filters) {
+    const dryRun = Boolean(filters.dryRun);
+    const pathMaps = filters.pathMaps ?? [];
+    const ledger = deps.ledger ?? new PiImportLedger();
+    // Dry-run performs no ledger writes: only read state from an existing
+    // ledger file, and never create one.
+    const ledgerFileExists = existsSync(importLedgerDbPath());
+    const ledgerAccessible = !dryRun || ledgerFileExists;
+    if (ledgerAccessible) {
+        await ledger.get("__warmup__");
+    }
+    if (!dryRun) {
+        const embeddingInitError = memoryClient.getEmbeddingInitError?.();
+        if (embeddingInitError) {
+            throw new Error(`Memory system is not ready for import: ${embeddingInitError}. Start the extension and retry.`);
+        }
+    }
+    const currentTag = filters.scope === "current-project" ? getTags(filters.currentDirectory).project.tag : null;
+    const discovery = discoverPiSessions({ root: filters.root, maxSessions: filters.maxSessions });
+    const report = {
+        dryRun,
+        root: filters.root ?? "",
+        sessionsDiscovered: discovery.sessions.length,
+        sessionsLoaded: 0,
+        sessionsFilteredOut: 0,
+        sessionsUnrecognized: discovery.unrecognized.length,
+        unresolvableSessions: [],
+        loadErrors: [],
+        unitsTotal: 0,
+        unitsImported: 0,
+        unitsWouldImport: 0,
+        unitsSkipped: 0,
+        unitsFailed: 0,
+        unitsAlreadyHandled: 0,
+        skipReasons: {},
+        projects: [],
+        units: [],
+    };
+    const projectAggregates = new Map();
+    const candidates = [];
+    for (const discovered of discovery.sessions) {
+        if (filters.session) {
+            const wanted = filters.session;
+            if (discovered.sessionId !== wanted && discovered.file !== wanted) {
+                report.sessionsFilteredOut++;
+                continue;
+            }
+        }
+        let session;
+        try {
+            session = deps.loadSession(discovered.file);
+        }
+        catch (error) {
+            report.loadErrors.push({
+                file: discovered.file,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        const directory = resolveSessionDirectory(session.cwd, pathMaps);
+        if (!directory) {
+            report.unresolvableSessions.push({ file: session.sourceFile, cwd: session.cwd });
+            continue;
+        }
+        const tags = getTags(directory);
+        if (currentTag && tags.project.tag !== currentTag) {
+            report.sessionsFilteredOut++;
+            continue;
+        }
+        const { hash } = extractScopeFromContainerTag(tags.project.tag);
+        report.sessionsLoaded++;
+        let aggregate = projectAggregates.get(tags.project.tag);
+        if (!aggregate) {
+            aggregate = {
+                tag: tags.project.tag,
+                hash,
+                directory,
+                sessions: new Set(),
+                units: 0,
+            };
+            projectAggregates.set(tags.project.tag, aggregate);
+        }
+        aggregate.sessions.add(session.sessionId);
+        const windows = extractPiConversationWindows(session.branch);
+        for (const window of windows) {
+            if (!windowWithinDateRange(window, filters))
+                continue;
+            const key = buildImportKey(session.sessionId, window);
+            if (!key)
+                continue;
+            candidates.push({ session, directory, tag: tags.project.tag, hash, window });
+            aggregate.units++;
+        }
+    }
+    report.unitsTotal = candidates.length;
+    const storageAccessible = ledgerFileExists;
+    let processed = 0;
+    for (const candidate of candidates) {
+        const { session, directory, hash, window } = candidate;
+        const key = buildImportKey(session.sessionId, window);
+        processed++;
+        deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt));
+        const unit = {
+            key,
+            sessionId: session.sessionId,
+            userEntryId: window.userEntryId,
+            promptPreview: preview(window.userPrompt),
+            status: "would-import",
+        };
+        const existing = ledgerAccessible ? await ledger.get(key) : null;
+        const terminalHandled = existing &&
+            (existing.status === "imported" || existing.status === "skipped") &&
+            !filters.force;
+        if (terminalHandled) {
+            unit.status = "already-handled";
+            unit.reason = existing.status;
+            report.unitsAlreadyHandled++;
+            report.units.push(unit);
+            continue;
+        }
+        // Crash reconciliation: the memory landed but the ledger never committed.
+        const storedMemoryId = await lookupExistingMemory(hash, key, { storageAccessible });
+        if (storedMemoryId) {
+            if (!dryRun) {
+                await ledger.complete(key, storedMemoryId);
+            }
+            unit.status = "already-handled";
+            unit.reason = "reconciled";
+            unit.memoryId = storedMemoryId;
+            report.unitsAlreadyHandled++;
+            report.units.push(unit);
+            continue;
+        }
+        if (dryRun) {
+            report.unitsWouldImport++;
+            report.units.push(unit);
+            continue;
+        }
+        await ledger.begin({
+            key,
+            sessionId: session.sessionId,
+            sourceFile: session.sourceFile,
+            projectHash: hash,
+        });
+        try {
+            const result = await captureConversation({
+                host: "pi",
+                hostSessionId: session.sessionId,
+                sourceType: "history-import",
+                projectDirectory: directory,
+                userPrompt: window.userPrompt,
+                promptId: window.userEntryId,
+                textResponses: window.textResponses,
+                toolCalls: window.toolCalls,
+                sourceEntryIds: window.sourceEntryIds,
+                ...(window.userTimestamp !== undefined
+                    ? { sourceTimestamp: window.userTimestamp }
+                    : window.sourceTimestamp !== undefined
+                        ? { sourceTimestamp: window.sourceTimestamp }
+                        : {}),
+                sourceFile: session.sourceFile,
+                importId: key,
+            }, deps.provider);
+            if (result.status === "skipped") {
+                await ledger.skip(key, `extractor-skip:${result.type ?? "unknown"}`);
+                unit.status = "skipped";
+                unit.reason = `extractor-skip:${result.type ?? "unknown"}`;
+                report.unitsSkipped++;
+                const reason = unit.reason;
+                report.skipReasons[reason] = (report.skipReasons[reason] ?? 0) + 1;
+            }
+            else {
+                await ledger.complete(key, result.memoryId);
+                unit.status = "imported";
+                unit.memoryId = result.memoryId;
+                report.unitsImported++;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await ledger.fail(key, message);
+            unit.status = "failed";
+            unit.reason = message;
+            report.unitsFailed++;
+        }
+        report.units.push(unit);
+    }
+    report.projects = [...projectAggregates.values()].map((aggregate) => ({
+        tag: aggregate.tag,
+        hash: aggregate.hash,
+        directory: aggregate.directory,
+        sessions: aggregate.sessions.size,
+        units: aggregate.units,
+    }));
+    return report;
+}

package/dist/importer/ledger.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Durable ledger for the Pi historical-session import.
+ *
+ * One row per deterministic import key. Records terminal states so reruns
+ * never reprocess handled work, plus in-progress states so a crash between
+ * the memory insert and the ledger write can be reconciled against the stored
+ * import identity instead of inserting a duplicate.
+ *
+ * The ledger lives inside `storagePath` (import-ledger.db) so idempotency
+ * travels with the memory store on machine moves.
+ */
+export declare const IMPORT_LEDGER_DB_NAME = "import-ledger.db";
+export type ImportLedgerStatus = "in-progress" | "imported" | "skipped" | "failed";
+export interface ImportLedgerRow {
+    key: string;
+    sessionId: string;
+    sourceFile: string;
+    projectHash: string;
+    status: ImportLedgerStatus;
+    memoryId: string | null;
+    skipReason: string | null;
+    updatedAt: number;
+}
+export declare function importLedgerDbPath(storagePath?: string): string;
+export declare class PiImportLedger {
+    private initPromise;
+    private ready;
+    private db;
+    get(key: string): Promise<ImportLedgerRow | null>;
+    countByStatus(): Promise<Record<string, number>>;
+    /** Upsert an in-progress marker before processing a unit. */
+    begin(input: {
+        key: string;
+        sessionId: string;
+        sourceFile: string;
+        projectHash: string;
+    }): Promise<void>;
+    /** Terminal success: a memory row exists for the key. */
+    complete(key: string, memoryId: string): Promise<void>;
+    /** Terminal skip (for example deterministic extractor skip): never reprocess. */
+    skip(key: string, reason: string): Promise<void>;
+    /** Retryable failure: the unit is reprocessed on the next run. */
+    fail(key: string, error: string): Promise<void>;
+}

package/dist/importer/ledger.js

@@ -0,0 +1,137 @@
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { tursoConnectionManager } from "../services/turso/connection-manager.js";
+/**
+ * Durable ledger for the Pi historical-session import.
+ *
+ * One row per deterministic import key. Records terminal states so reruns
+ * never reprocess handled work, plus in-progress states so a crash between
+ * the memory insert and the ledger write can be reconciled against the stored
+ * import identity instead of inserting a duplicate.
+ *
+ * The ledger lives inside `storagePath` (import-ledger.db) so idempotency
+ * travels with the memory store on machine moves.
+ */
+export const IMPORT_LEDGER_DB_NAME = "import-ledger.db";
+export function importLedgerDbPath(storagePath = CONFIG.storagePath) {
+    return join(storagePath, IMPORT_LEDGER_DB_NAME);
+}
+function rowToEntry(row) {
+    return {
+        key: String(row.key),
+        sessionId: String(row.session_id),
+        sourceFile: String(row.source_file),
+        projectHash: String(row.project_hash),
+        status: row.status,
+        memoryId: row.memory_id === null || row.memory_id === undefined ? null : String(row.memory_id),
+        skipReason: row.skip_reason === null || row.skip_reason === undefined ? null : String(row.skip_reason),
+        updatedAt: Number(row.updated_at),
+    };
+}
+export class PiImportLedger {
+    initPromise = null;
+    async ready() {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            const db = await tursoConnectionManager.getConnection(importLedgerDbPath());
+            await db.batch([
+                {
+                    sql: `
+            CREATE TABLE IF NOT EXISTS import_ledger (
+              key TEXT PRIMARY KEY,
+              session_id TEXT NOT NULL,
+              source_file TEXT NOT NULL,
+              project_hash TEXT NOT NULL,
+              status TEXT NOT NULL,
+              memory_id TEXT,
+              skip_reason TEXT,
+              updated_at INTEGER NOT NULL
+            )
+          `,
+                },
+                {
+                    sql: `CREATE INDEX IF NOT EXISTS idx_import_ledger_session ON import_ledger(session_id)`,
+                },
+                {
+                    sql: `CREATE INDEX IF NOT EXISTS idx_import_ledger_status ON import_ledger(status)`,
+                },
+            ]);
+        })();
+        try {
+            await this.initPromise;
+        }
+        catch (error) {
+            this.initPromise = null;
+            throw error;
+        }
+    }
+    async db() {
+        await this.ready();
+        return tursoConnectionManager.getConnection(importLedgerDbPath());
+    }
+    async get(key) {
+        const db = await this.db();
+        const row = await db.get(`SELECT * FROM import_ledger WHERE key = ?`, [key]);
+        return row ? rowToEntry(row) : null;
+    }
+    async countByStatus() {
+        const db = await this.db();
+        const rows = await db.all(`SELECT status, COUNT(*) AS count FROM import_ledger GROUP BY status`);
+        const counts = {};
+        for (const row of rows) {
+            counts[String(row.status)] = Number(row.count);
+        }
+        return counts;
+    }
+    /** Upsert an in-progress marker before processing a unit. */
+    async begin(input) {
+        const db = await this.db();
+        await db.run(`
+        INSERT INTO import_ledger (key, session_id, source_file, project_hash, status, memory_id, skip_reason, updated_at)
+        VALUES (?, ?, ?, ?, 'in-progress', NULL, NULL, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          status = 'in-progress',
+          memory_id = NULL,
+          skip_reason = NULL,
+          updated_at = excluded.updated_at
+      `, [input.key, input.sessionId, input.sourceFile, input.projectHash, Date.now()]);
+    }
+    /** Terminal success: a memory row exists for the key. */
+    async complete(key, memoryId) {
+        const db = await this.db();
+        await db.run(`
+        INSERT INTO import_ledger (key, session_id, source_file, project_hash, status, memory_id, skip_reason, updated_at)
+        VALUES (?, '', '', '', 'imported', ?, NULL, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          status = 'imported',
+          memory_id = excluded.memory_id,
+          skip_reason = NULL,
+          updated_at = excluded.updated_at
+      `, [key, memoryId, Date.now()]);
+    }
+    /** Terminal skip (for example deterministic extractor skip): never reprocess. */
+    async skip(key, reason) {
+        const db = await this.db();
+        await db.run(`
+        INSERT INTO import_ledger (key, session_id, source_file, project_hash, status, memory_id, skip_reason, updated_at)
+        VALUES (?, '', '', '', 'skipped', NULL, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          status = 'skipped',
+          skip_reason = excluded.skip_reason,
+          updated_at = excluded.updated_at
+      `, [key, reason, Date.now()]);
+    }
+    /** Retryable failure: the unit is reprocessed on the next run. */
+    async fail(key, error) {
+        const db = await this.db();
+        await db.run(`
+        INSERT INTO import_ledger (key, session_id, source_file, project_hash, status, memory_id, skip_reason, updated_at)
+        VALUES (?, '', '', '', 'failed', NULL, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          status = 'failed',
+          skip_reason = excluded.skip_reason,
+          updated_at = excluded.updated_at
+      `, [key, error, Date.now()]);
+    }
+}

package/dist/importer/session-loader.d.ts

@@ -0,0 +1,19 @@
+import type { PiSessionEntry } from "../adapters/pi/conversation.js";
+/**
+ * Loads a Pi session file for import through Pi's own exported session model
+ * (`SessionManager.open`), which handles parsing and legacy-version migration
+ * in memory. Read-only: nothing on this code path appends or rewrites the
+ * source file.
+ *
+ * Only this module (and the import command that calls it) imports the Pi
+ * package; the importer orchestration stays host-neutral and receives loaded
+ * sessions through the loader function so tests can inject fixtures.
+ */
+export interface LoadedPiSession {
+    sessionId: string;
+    sourceFile: string;
+    cwd: string | null;
+    /** Entries of the session's active/current branch, root to leaf. */
+    branch: PiSessionEntry[];
+}
+export declare function loadPiSessionForImport(file: string): LoadedPiSession;

package/dist/importer/session-loader.js

@@ -0,0 +1,12 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+export function loadPiSessionForImport(file) {
+    const manager = SessionManager.open(file);
+    const header = manager.getHeader();
+    const branch = (manager.getBranch() ?? []);
+    return {
+        sessionId: manager.getSessionId(),
+        sourceFile: file,
+        cwd: header?.cwd ?? null,
+        branch,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { isStructuredSummaryPromptMessage } from "./adapters/opencode/user-prompt.js";
+import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle } from "./services/ai/internal-capture-sessions.js";
+export { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle };
+export { isStructuredSummaryPromptMessage };
+/**
+ * Resolve the session's active agent so compaction memory injection does not
+ * reset OpenCode to the stock "general-purpose" fallback (issue #236).
+ *
+ * Preference order:
+ * 1. session.get().agent (v2 hosts)
+ * 2. Latest non-compaction user message agent
+ * 3. Latest non-compaction / non-summary assistant mode (v1) or agent (v2)
+ */
+export declare function resolveSessionAgent(client: unknown, sessionID: string): Promise<string | undefined>;
+/** Least-privilege agent used only by internal structured-output sessions (issue #189). */
+export declare function applyStructuredOutputAgentConfig(cfg: {
+    agent?: Record<string, unknown>;
+}): void;
+export declare function configureOpencodeHostTransport(ctx: {
+    readonly client: unknown;
+    readonly serverUrl?: string | URL;
+}): Promise<void>;
+export declare const OmmsPlugin: Plugin;