om-memory-system 3.0.0 → 3.1.0-next.4

package/dist/importer/importer.js

@@ -1,4 +1,4 @@
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { captureConversation } from "../core/capture.js";
 import { memoryClient } from "../services/client.js";
 import { extractScopeFromContainerTag } from "../services/memory-scope.js";
@@ -8,11 +8,11 @@ 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) {
+export function buildImportKey(sessionId, window, host = "pi") {
     const terminalEntryId = window.sourceEntryIds?.[window.sourceEntryIds.length - 1];
     if (!terminalEntryId)
         return null;
-    return `pi:${sessionId}:${window.userEntryId}:${terminalEntryId}`;
+    return `${host}:${sessionId}:${window.userEntryId}:${terminalEntryId}`;
 }
 /**
  * Find a stored memory by its deterministic import identity. Used to
@@ -32,6 +32,20 @@ export async function findMemoryIdByImportId(projectHash, importId) {
     }
     return null;
 }
+/**
+ * Project tag for scope filtering only. Symlinked paths (macOS /var vs
+ * /private/var) name one project, so compare through the real path.
+ */
+export function projectFilterTag(directory) {
+    let real = directory;
+    try {
+        real = realpathSync.native(directory);
+    }
+    catch {
+        // A missing directory keeps its recorded path.
+    }
+    return getTags(real).project.tag;
+}
 function resolveSessionDirectory(cwd, pathMaps) {
     if (!cwd)
         return null;
@@ -62,116 +76,52 @@ async function lookupExistingMemory(projectHash, key, options) {
         return null;
     }
 }
-export async function importPiHistory(deps, filters) {
+/** Process host-labelled work units through the shared capture and ledger pipeline. */
+export async function importHistorySource(source, host, deps, filters, report) {
     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) {
+    // A dry run only reads the ledger (peek), so it never writes its schema.
+    if (!dryRun)
         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) {
+    for await (const session of source) {
+        const { hash } = extractScopeFromContainerTag(getTags(session.directory).project.tag);
+        for (const window of session.units) {
             if (!windowWithinDateRange(window, filters))
                 continue;
-            const key = buildImportKey(session.sessionId, window);
-            if (!key)
+            if (!buildImportKey(session.sessionId, window, host))
                 continue;
-            candidates.push({ session, directory, tag: tags.project.tag, hash, window });
-            aggregate.units++;
+            candidates.push({ ...session, hash, window });
         }
     }
     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);
+        const { sessionId, directory, sourceFile, hash, window } = candidate;
+        const key = buildImportKey(sessionId, window, host);
         processed++;
         deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt));
         const unit = {
             key,
-            sessionId: session.sessionId,
+            sessionId: sessionId,
             userEntryId: window.userEntryId,
             promptPreview: preview(window.userPrompt),
             status: "would-import",
         };
-        const existing = ledgerAccessible ? await ledger.get(key) : null;
+        const existing = !ledgerAccessible
+            ? null
+            : dryRun
+                ? await ledger.peek(key)
+                : await ledger.get(key);
         const terminalHandled = existing &&
             (existing.status === "imported" || existing.status === "skipped") &&
             !filters.force;
@@ -202,14 +152,14 @@ export async function importPiHistory(deps, filters) {
         }
         await ledger.begin({
             key,
-            sessionId: session.sessionId,
-            sourceFile: session.sourceFile,
+            sessionId: sessionId,
+            sourceFile: sourceFile,
             projectHash: hash,
         });
         try {
             const result = await captureConversation({
-                host: "pi",
-                hostSessionId: session.sessionId,
+                host,
+                hostSessionId: sessionId,
                 sourceType: "history-import",
                 projectDirectory: directory,
                 userPrompt: window.userPrompt,
@@ -222,7 +172,7 @@ export async function importPiHistory(deps, filters) {
                     : window.sourceTimestamp !== undefined
                         ? { sourceTimestamp: window.sourceTimestamp }
                         : {}),
-                sourceFile: session.sourceFile,
+                sourceFile: sourceFile,
                 importId: key,
             }, deps.provider);
             if (result.status === "skipped") {
@@ -249,6 +199,111 @@ export async function importPiHistory(deps, filters) {
         }
         report.units.push(unit);
     }
+}
+export async function importPiHistory(deps, filters) {
+    const dryRun = Boolean(filters.dryRun);
+    const pathMaps = filters.pathMaps ?? [];
+    const currentTag = filters.scope === "current-project" ? projectFilterTag(filters.currentDirectory) : 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 && projectFilterTag(directory) !== 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++;
+        }
+    }
+    // One source session per Pi session, so tags resolve once rather than per window.
+    const grouped = new Map();
+    for (const { session, directory, window } of candidates) {
+        const key = `${session.sessionId}\0${session.sourceFile}`;
+        const entry = grouped.get(key);
+        if (entry) {
+            entry.units.push(window);
+        }
+        else {
+            grouped.set(key, {
+                sessionId: session.sessionId,
+                directory,
+                sourceFile: session.sourceFile,
+                units: [window],
+            });
+        }
+    }
+    const sourceSessions = [...grouped.values()];
+    if (filters.skipMemories) {
+        report.unitsTotal = candidates.length;
+    }
+    else {
+        await importHistorySource(sourceSessions, "pi", deps, filters, report);
+    }
     report.projects = [...projectAggregates.values()].map((aggregate) => ({
         tag: aggregate.tag,
         hash: aggregate.hash,
@@ -256,5 +311,14 @@ export async function importPiHistory(deps, filters) {
         sessions: aggregate.sessions.size,
         units: aggregate.units,
     }));
+    if (deps.profile) {
+        const { importProfileFromHistory } = await import("./profile-import.js");
+        report.profile = await importProfileFromHistory(sourceSessions, {
+            host: "pi",
+            dryRun,
+            model: deps.profile.model,
+            batchSize: deps.profile.batchSize,
+        });
+    }
     return report;
 }

package/dist/importer/ledger.d.ts

@@ -1,5 +1,5 @@
 /**
- * Durable ledger for the Pi historical-session import.
+ * Durable ledger for historical-session imports across hosts.
  *
  * One row per deterministic import key. Records terminal states so reruns
  * never reprocess handled work, plus in-progress states so a crash between
@@ -22,11 +22,16 @@ export interface ImportLedgerRow {
     updatedAt: number;
 }
 export declare function importLedgerDbPath(storagePath?: string): string;
-export declare class PiImportLedger {
+export declare class ImportLedger {
     private initPromise;
     private ready;
     private db;
     get(key: string): Promise<ImportLedgerRow | null>;
+    /**
+     * Read-only lookup for dry runs: never creates the table or its indexes.
+     * A ledger file without the table reads as empty.
+     */
+    peek(key: string): Promise<ImportLedgerRow | null>;
     countByStatus(): Promise<Record<string, number>>;
     /** Upsert an in-progress marker before processing a unit. */
     begin(input: {
@@ -42,3 +47,5 @@ export declare class PiImportLedger {
     /** Retryable failure: the unit is reprocessed on the next run. */
     fail(key: string, error: string): Promise<void>;
 }
+/** Backwards-compatible name for existing Pi imports. */
+export { ImportLedger as PiImportLedger };

package/dist/importer/ledger.js

@@ -2,7 +2,7 @@ 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.
+ * Durable ledger for historical-session imports across hosts.
  *
  * One row per deterministic import key. Records terminal states so reruns
  * never reprocess handled work, plus in-progress states so a crash between
@@ -28,7 +28,7 @@ function rowToEntry(row) {
         updatedAt: Number(row.updated_at),
     };
 }
-export class PiImportLedger {
+export class ImportLedger {
     initPromise = null;
     async ready() {
         if (this.initPromise)
@@ -75,6 +75,18 @@ export class PiImportLedger {
         const row = await db.get(`SELECT * FROM import_ledger WHERE key = ?`, [key]);
         return row ? rowToEntry(row) : null;
     }
+    /**
+     * Read-only lookup for dry runs: never creates the table or its indexes.
+     * A ledger file without the table reads as empty.
+     */
+    async peek(key) {
+        const db = await tursoConnectionManager.getConnection(importLedgerDbPath());
+        const table = await db.get(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'import_ledger'`);
+        if (!table)
+            return null;
+        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`);
@@ -135,3 +147,5 @@ export class PiImportLedger {
       `, [key, error, Date.now()]);
     }
 }
+/** Backwards-compatible name for existing Pi imports. */
+export { ImportLedger as PiImportLedger };

package/dist/importer/model-selection.d.ts

@@ -0,0 +1,16 @@
+import type { CaptureSummaryProvider } from "../core/host.js";
+import type { ModelPort } from "../core/profile-analysis.js";
+export interface ImportModelFlags {
+    provider?: string;
+    model?: string;
+    apiUrl?: string;
+    apiKeyEnv?: string;
+}
+export interface SelectedImportModel {
+    provider: string;
+    modelId: string;
+    capture: CaptureSummaryProvider;
+    profile: ModelPort;
+}
+/** Merge import-only model settings without changing the saved omms config. */
+export declare function selectImportModel(flags: ImportModelFlags): SelectedImportModel;

package/dist/importer/model-selection.js

@@ -0,0 +1,84 @@
+import { randomUUID } from "node:crypto";
+import { CONFIG } from "../config.js";
+import { buildBoundedSummaryPrompt } from "../core/capture-context.js";
+import { buildCaptureSystemPrompt, captureSummaryToolSchema, parseCaptureSummary, } from "../core/extraction.js";
+import { AIProviderFactory } from "../services/ai/ai-provider-factory.js";
+import { buildMemoryProviderConfig } from "../services/ai/provider-config.js";
+import { resolveSecretValue } from "../services/secret-resolver.js";
+/** Merge import-only model settings without changing the saved omms config. */
+export function selectImportModel(flags) {
+    const providerName = flags.provider ?? CONFIG.memoryProvider;
+    // The saved URL belongs to the saved provider; never send a request for another one there.
+    const providerOverridden = flags.provider !== undefined && flags.provider !== CONFIG.memoryProvider;
+    if (providerOverridden && !flags.apiUrl && providerName !== "orcarouter") {
+        throw new Error("--api-url is required when --provider differs from memoryProvider");
+    }
+    const modelId = flags.model ?? CONFIG.memoryModel;
+    const apiUrl = flags.apiUrl ?? CONFIG.memoryApiUrl;
+    const key = flags.apiKeyEnv
+        ? resolveSecretValue(`env://${flags.apiKeyEnv}`)
+        : CONFIG.memoryApiKey;
+    if (!modelId && providerName !== "orcarouter")
+        throw new Error("Missing memoryModel or --model");
+    if (!apiUrl && providerName !== "orcarouter")
+        throw new Error("Missing memoryApiUrl or --api-url");
+    if (!key)
+        throw new Error("Missing memoryApiKey or --api-key-env");
+    if (!AIProviderFactory.getSupportedProviders().includes(providerName)) {
+        throw new Error(`Unsupported import provider: ${providerName}`);
+    }
+    const provider = AIProviderFactory.createProvider(providerName, buildMemoryProviderConfig({
+        ...CONFIG,
+        memoryProvider: providerName,
+        memoryModel: modelId,
+        memoryApiUrl: apiUrl,
+        memoryApiKey: key,
+    }));
+    const capture = {
+        async summarize(request) {
+            const { detectLanguage, getLanguageName } = await import("../services/language-detector.js");
+            const target = CONFIG.autoCaptureLanguage && CONFIG.autoCaptureLanguage !== "auto"
+                ? CONFIG.autoCaptureLanguage
+                : detectLanguage(request.userPrompt);
+            const system = buildCaptureSystemPrompt(getLanguageName(target));
+            const tool = {
+                type: "function",
+                function: {
+                    name: "save_memory",
+                    description: "Save a technical memory",
+                    parameters: captureSummaryToolSchema,
+                },
+            };
+            const result = await provider.executeToolCall(system, buildBoundedSummaryPrompt(request.context, system, tool), tool, `history-capture-${randomUUID()}`);
+            if (!result.success || !result.data) {
+                throw new Error("History capture model call failed");
+            }
+            const raw = typeof result.data === "string" ? result.data : JSON.stringify(result.data);
+            const parsed = parseCaptureSummary(raw);
+            if (!parsed)
+                throw new Error("History capture returned an invalid summary");
+            return parsed;
+        },
+    };
+    const profile = {
+        provider: providerName,
+        modelId: modelId ?? "",
+        async complete(system, prompt) {
+            const { z } = await import("zod");
+            const { createUserProfileAnalysisSchema } = await import("../core/extraction.js");
+            const tool = {
+                type: "function",
+                function: {
+                    name: "update_user_profile",
+                    description: "Analyse historical user prompts",
+                    parameters: z.toJSONSchema(createUserProfileAnalysisSchema(z)),
+                },
+            };
+            const result = await provider.executeToolCall(system, prompt, tool, `history-profile-${randomUUID()}`);
+            if (!result.success || !result.data)
+                throw new Error("History profile model call failed");
+            return typeof result.data === "string" ? result.data : JSON.stringify(result.data);
+        },
+    };
+    return { provider: providerName, modelId: modelId ?? "", capture, profile };
+}

package/dist/importer/opencode-import.d.ts

@@ -0,0 +1,28 @@
+import type { CaptureSummaryProvider } from "../core/host.js";
+import type { ModelPort } from "../core/profile-analysis.js";
+import { type ImportPathMap, type ImportReport } from "./importer.js";
+import { type UnresolvedProject } from "./opencode-project.js";
+import { type ProfileImportReport } from "./profile-import.js";
+export interface OpencodeImportOptions {
+    dbPath?: string;
+    dryRun?: boolean;
+    since?: number;
+    until?: number;
+    session?: string;
+    project?: string;
+    maxSessions?: number;
+    pathMaps?: ImportPathMap[];
+    force?: boolean;
+    skipMemories?: boolean;
+    skipProfile?: boolean;
+    profileBatch?: number;
+    provider?: CaptureSummaryProvider;
+    profileModel?: ModelPort;
+}
+export interface OpencodeImportReport extends ImportReport {
+    childSessionsFolded: number;
+    unresolvedProjects: UnresolvedProject[];
+    profile?: ProfileImportReport;
+}
+/** Import resolved OpenCode history through the shared memory and profile steps. */
+export declare function importOpencodeHistory(options: OpencodeImportOptions): Promise<OpencodeImportReport>;

package/dist/importer/opencode-import.js

@@ -0,0 +1,87 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getTags } from "../services/tags.js";
+import { extractScopeFromContainerTag } from "../services/memory-scope.js";
+import { importHistorySource, projectFilterTag, } from "./importer.js";
+import { resolveOpencodeSessions } from "./opencode-project.js";
+import { readOpencodeHistory } from "./opencode-reader.js";
+import { importProfileFromHistory } from "./profile-import.js";
+/** Import resolved OpenCode history through the shared memory and profile steps. */
+export async function importOpencodeHistory(options) {
+    if (!options.dryRun && !options.skipMemories && !options.provider) {
+        throw new Error("OpenCode history import needs a capture model");
+    }
+    if (!options.dryRun && !options.skipProfile && !options.profileModel) {
+        throw new Error("OpenCode history import needs a profile model");
+    }
+    const dbPath = options.dbPath ?? join(homedir(), ".local/share/opencode/opencode.db");
+    // Resolve the filter before opening the reader: the reader only closes once iterated.
+    const projectTag = options.project ? projectFilterTag(options.project) : null;
+    const reader = readOpencodeHistory(dbPath, options);
+    const unresolved = new Map();
+    const sessions = [];
+    const projects = new Map();
+    let filtered = 0;
+    for await (const session of resolveOpencodeSessions(reader.sessions, options.pathMaps ?? [], unresolved)) {
+        const info = getTags(session.directory).project;
+        if (projectTag && projectTag !== projectFilterTag(session.directory)) {
+            filtered++;
+            continue;
+        }
+        const project = projects.get(info.tag) ?? {
+            tag: info.tag,
+            hash: extractScopeFromContainerTag(info.tag).hash,
+            directory: session.directory,
+            sessions: 0,
+            units: 0,
+            sessionIds: new Set(),
+        };
+        project.sessionIds.add(session.sessionId);
+        project.sessions = project.sessionIds.size;
+        project.units += session.units.length;
+        projects.set(info.tag, project);
+        sessions.push(session);
+    }
+    const report = {
+        dryRun: Boolean(options.dryRun),
+        root: dbPath,
+        sessionsDiscovered: reader.topLevelSessions,
+        sessionsLoaded: sessions.length,
+        sessionsFilteredOut: filtered,
+        sessionsUnrecognized: 0,
+        unresolvableSessions: [],
+        loadErrors: [],
+        unitsTotal: 0,
+        unitsImported: 0,
+        unitsWouldImport: 0,
+        unitsSkipped: 0,
+        unitsFailed: 0,
+        unitsAlreadyHandled: 0,
+        skipReasons: {},
+        units: [],
+        projects: [...projects.values()].map(({ sessionIds: _ids, ...project }) => project),
+        childSessionsFolded: reader.childSessions,
+        unresolvedProjects: [...unresolved.values()],
+    };
+    if (!options.skipMemories) {
+        await importHistorySource(sessions, "opencode", {
+            provider: options.provider ?? {
+                summarize: async () => {
+                    throw new Error("A dry-run cannot call the capture model");
+                },
+            },
+        }, options, report);
+    }
+    else {
+        report.unitsTotal = sessions.reduce((total, session) => total + session.units.length, 0);
+    }
+    if (!options.skipProfile) {
+        report.profile = await importProfileFromHistory(sessions, {
+            host: "opencode",
+            dryRun: options.dryRun,
+            batchSize: options.profileBatch,
+            model: options.profileModel,
+        });
+    }
+    return report;
+}

package/dist/importer/opencode-project.d.ts

@@ -0,0 +1,11 @@
+import type { ImportPathMap } from "./importer.js";
+import type { OpencodeSourceSession } from "./opencode-reader.js";
+/** Prefer the recorded directory, then an explicit map, then the project root. */
+export declare function resolveOpencodeProject(recordedDirectory: string, projectWorktree: string | null, maps?: ImportPathMap[]): string | null;
+export interface UnresolvedProject {
+    directory: string;
+    sessions: number;
+    units: number;
+}
+/** Resolve each session without buffering its conversation windows. */
+export declare function resolveOpencodeSessions(sessions: AsyncIterable<OpencodeSourceSession>, maps: ImportPathMap[], unresolved: Map<string, UnresolvedProject>): AsyncGenerator<OpencodeSourceSession>;

package/dist/importer/opencode-project.js

@@ -0,0 +1,38 @@
+import { statSync } from "node:fs";
+function isDirectory(path) {
+    if (!path)
+        return false;
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Prefer the recorded directory, then an explicit map, then the project root. */
+export function resolveOpencodeProject(recordedDirectory, projectWorktree, maps = []) {
+    if (isDirectory(recordedDirectory))
+        return recordedDirectory;
+    const mapped = maps.find((item) => item.from === recordedDirectory)?.to;
+    if (isDirectory(mapped))
+        return mapped;
+    return projectWorktree !== "/" && isDirectory(projectWorktree) ? projectWorktree : null;
+}
+/** Resolve each session without buffering its conversation windows. */
+export async function* resolveOpencodeSessions(sessions, maps, unresolved) {
+    for await (const session of sessions) {
+        const directory = resolveOpencodeProject(session.recordedDirectory, session.projectWorktree, maps);
+        if (directory) {
+            yield { ...session, directory };
+            continue;
+        }
+        const entry = unresolved.get(session.recordedDirectory) ?? {
+            directory: session.recordedDirectory,
+            sessions: 0,
+            units: 0,
+        };
+        entry.sessions++;
+        entry.units += session.units.length;
+        unresolved.set(entry.directory, entry);
+    }
+}