om-memory-system 3.4.0-next.23 → 3.4.0-next.27

package/dist/importer/external-api-test.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { CONFIG } from "../config.js";
+import { safeHealthError } from "../services/safe-health-error.js";
+const OUTPUT_LIMIT = 64;
+const TIMEOUT_MS = 20_000;
+/** Provider-specific output caps; Anthropic-style providers read `maxTokens`. */
+function outputLimitParams(provider) {
+    if (provider === "openai-chat" || provider === "orcarouter")
+        return { max_tokens: OUTPUT_LIMIT };
+    if (provider === "openai-responses")
+        return { max_output_tokens: OUTPUT_LIMIT };
+    return {};
+}
+/**
+ * One small call to the saved external API from this process, with a small
+ * output limit. The error never contains the key.
+ */
+export async function testExternalApi(config = CONFIG, createProvider) {
+    const secrets = [config.memoryApiKey];
+    try {
+        const { buildMemoryProviderConfig } = await import("../services/ai/provider-config.js");
+        const base = buildMemoryProviderConfig(config, {
+            maxIterations: 1,
+            iterationTimeout: TIMEOUT_MS,
+        });
+        const providerConfig = {
+            ...base,
+            maxTokens: OUTPUT_LIMIT,
+            extraParams: { ...base.extraParams, ...outputLimitParams(config.memoryProvider) },
+        };
+        const create = createProvider ??
+            (await import("../services/ai/ai-provider-factory.js")).AIProviderFactory.createProvider;
+        const provider = create(config.memoryProvider, providerConfig);
+        const tool = {
+            type: "function",
+            function: {
+                name: "acknowledge",
+                description: "Confirm the connection works",
+                parameters: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"] },
+            },
+        };
+        const result = await provider.executeToolCall("You are testing a connection. Call the acknowledge tool with ok set to true.", "Acknowledge.", tool, `external-api-test-${randomUUID()}`);
+        if (!result.success)
+            throw new Error(result.error ?? "The external API call failed");
+        return { ok: true, model: `${config.memoryProvider}/${config.memoryModel ?? "default"}` };
+    }
+    catch (error) {
+        return { ok: false, error: safeHealthError(error, secrets).slice(0, 500) };
+    }
+}

package/dist/importer/external-backfill-models.d.ts

@@ -0,0 +1,15 @@
+import type { BackfillHost } from "./backfill-model.js";
+import type { SelectedImportModel } from "./model-selection.js";
+import type { HistoryImportModels } from "./run-import.js";
+interface ExternalConfig {
+    memoryProvider?: string;
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+}
+/** A backfill set to `external`: the external API, or an error naming the missing settings. */
+export declare function resolveExternalBackfillModels(host: BackfillHost, config: ExternalConfig, externalModels?: (flags: Record<string, never>) => SelectedImportModel): Promise<{
+    model: string;
+    models: HistoryImportModels;
+}>;
+export {};

package/dist/importer/external-backfill-models.js

@@ -0,0 +1,14 @@
+import { externalModelIssues } from "../services/ai/live-model-choice.js";
+/** A backfill set to `external`: the external API, or an error naming the missing settings. */
+export async function resolveExternalBackfillModels(host, config, externalModels) {
+    const issues = externalModelIssues(config);
+    const label = host === "pi" ? "Pi" : "OpenCode";
+    if (issues.length > 0)
+        throw new Error(`${label} backfill: ${issues.join("; ")}`);
+    const select = externalModels ?? (await import("./model-selection.js")).selectImportModel;
+    const external = select({});
+    return {
+        model: `${external.provider}/${external.modelId}`,
+        models: { capture: external.capture, profile: external.profile },
+    };
+}

package/dist/importer/import-path-maps.d.ts

@@ -0,0 +1,14 @@
+import type { ImportPathMap } from "./importer.js";
+/**
+ * Validate and normalise `importPathMaps` from the global config. Each entry
+ * needs absolute `from` and `to` directories after `~` expansion. Throws on
+ * the first invalid entry, like the rest of config validation.
+ */
+export declare function parseImportPathMaps(value: unknown): ImportPathMap[];
+/** Saved maps with the run's own maps on top; a run map wins for the same `from`. */
+export declare function mergeImportPathMaps(saved: readonly ImportPathMap[], run: readonly ImportPathMap[]): ImportPathMap[];
+/**
+ * The maps one import run uses: the saved `importPathMaps` with the run's
+ * maps on top, run targets resolved against `cwd`.
+ */
+export declare function runPathMaps(runMaps: readonly ImportPathMap[], cwd: string, saved?: readonly ImportPathMap[]): Promise<ImportPathMap[]>;

package/dist/importer/import-path-maps.js

@@ -0,0 +1,49 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+function expandHome(path) {
+    if (path === "~")
+        return homedir();
+    if (path.startsWith("~/") || path.startsWith("~\\"))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+/**
+ * Validate and normalise `importPathMaps` from the global config. Each entry
+ * needs absolute `from` and `to` directories after `~` expansion. Throws on
+ * the first invalid entry, like the rest of config validation.
+ */
+export function parseImportPathMaps(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("Invalid importPathMaps config: must be a list");
+    return value.map((entry, index) => {
+        const from = entry?.from;
+        const to = entry?.to;
+        if (typeof from !== "string" || typeof to !== "string" || !from.trim() || !to.trim()) {
+            throw new Error(`Invalid importPathMaps config: entry ${index} needs "from" and "to"`);
+        }
+        const expanded = { from: expandHome(from.trim()), to: expandHome(to.trim()) };
+        if (!isAbsolute(expanded.from) || !isAbsolute(expanded.to)) {
+            throw new Error(`Invalid importPathMaps config: entry ${index} needs absolute paths`);
+        }
+        return { from: resolve(expanded.from), to: resolve(expanded.to) };
+    });
+}
+/** Saved maps with the run's own maps on top; a run map wins for the same `from`. */
+export function mergeImportPathMaps(saved, run) {
+    const byFrom = new Map();
+    for (const map of saved)
+        byFrom.set(map.from, map);
+    for (const map of run)
+        byFrom.set(map.from, map);
+    return [...byFrom.values()];
+}
+/**
+ * The maps one import run uses: the saved `importPathMaps` with the run's
+ * maps on top, run targets resolved against `cwd`.
+ */
+export async function runPathMaps(runMaps, cwd, saved) {
+    const savedMaps = saved ?? (await import("../config.js")).CONFIG.importPathMaps ?? [];
+    return mergeImportPathMaps(savedMaps, runMaps.map((map) => ({ from: map.from, to: resolve(cwd, map.to) })));
+}

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

@@ -0,0 +1,27 @@
+/** One `(time, done)` reading of a running import. */
+export interface ProgressSample {
+    at: number;
+    done: number;
+}
+export declare const MAX_PROGRESS_SAMPLES = 20;
+/** Keep the most recent samples; a sample with no new units only moves the clock. */
+export declare function addProgressSample(samples: readonly ProgressSample[], sample: ProgressSample): ProgressSample[];
+export interface ProgressEstimate {
+    percent: number;
+    /** Null until the recent window has 5 samples spanning a minute and a non-zero rate. */
+    minutesLeft: number | null;
+    /** Units a minute over the recent window, or null while unknown. */
+    ratePerMinute: number | null;
+}
+/** Percentage done and minutes left from the recent sample window, not the whole run. */
+export declare function estimateProgress(total: number, done: number, samples: readonly ProgressSample[]): ProgressEstimate;
+/**
+ * Turn the importer's progress callback into finished work units. The
+ * importer reports a unit as it starts, and `alreadyHandled` (units found in
+ * the ledger, which need no model call) does not yet include that unit, so
+ * finished work is `processed - 1 - alreadyHandled`.
+ */
+export declare function workProgress(processed: number, total: number, alreadyHandled?: number, expectedTotal?: number): {
+    done: number;
+    total: number;
+};

package/dist/importer/import-progress.js

@@ -0,0 +1,38 @@
+export const MAX_PROGRESS_SAMPLES = 20;
+const MIN_SAMPLES = 5;
+const MIN_WINDOW_MS = 60_000;
+/** Keep the most recent samples; a sample with no new units only moves the clock. */
+export function addProgressSample(samples, sample) {
+    return [...samples, sample].slice(-MAX_PROGRESS_SAMPLES);
+}
+/** Percentage done and minutes left from the recent sample window, not the whole run. */
+export function estimateProgress(total, done, samples) {
+    const percent = total > 0 ? Math.min(100, Math.floor((done / total) * 100)) : 0;
+    if (samples.length < MIN_SAMPLES)
+        return { percent, minutesLeft: null, ratePerMinute: null };
+    const first = samples[0];
+    const last = samples[samples.length - 1];
+    const span = last.at - first.at;
+    if (span < MIN_WINDOW_MS || last.done <= first.done) {
+        return { percent, minutesLeft: null, ratePerMinute: null };
+    }
+    const ratePerMinute = (last.done - first.done) / (span / 60_000);
+    return {
+        percent,
+        minutesLeft: Math.max(0, Math.round((total - done) / ratePerMinute)),
+        ratePerMinute,
+    };
+}
+/**
+ * Turn the importer's progress callback into finished work units. The
+ * importer reports a unit as it starts, and `alreadyHandled` (units found in
+ * the ledger, which need no model call) does not yet include that unit, so
+ * finished work is `processed - 1 - alreadyHandled`.
+ */
+export function workProgress(processed, total, alreadyHandled = 0, expectedTotal) {
+    const workTotal = Math.max(0, expectedTotal ?? total - alreadyHandled);
+    return {
+        done: Math.min(workTotal, Math.max(0, processed - 1 - alreadyHandled)),
+        total: workTotal,
+    };
+}

package/dist/importer/import-readiness.js

@@ -24,7 +24,7 @@ export async function importReadiness(deps = {}) {
     const [state, opencode, piReader] = await Promise.all([
         externalApiState(deps.supportedProviders),
         (deps.listOpencodeModels ??
-            (async () => (await import("../services/settings-models.js")).listOpencodeSettingsModels()))(),
+            (async () => (await import("./settings-models.js")).listOpencodeSettingsModels()))(),
         (deps.loadPiSdk ?? (() => import("@earendil-works/pi-coding-agent")))().then(() => ({ available: true }), () => ({
             available: false,
             reason: "The Pi SDK (@earendil-works/pi-coding-agent) is not installed for OpenCode",

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

@@ -0,0 +1,43 @@
+import type { BackfillHost } from "./backfill-model.js";
+import { type ProgressEstimate } from "./import-progress.js";
+export type ImportSurface = "auto" | "web" | "cli" | "slash";
+export type ImportRunState = "running" | "paused" | "stopped" | "done" | "failed";
+export interface ImportRunCounts {
+    total: number;
+    done: number;
+    imported: number;
+    skipped: number;
+    failed: number;
+}
+export interface ImportRun extends ImportRunCounts, ProgressEstimate {
+    host: BackfillHost;
+    surface: ImportSurface | null;
+    state: ImportRunState | null;
+    pid: number | null;
+    startedAt: number | null;
+    updatedAt: number | null;
+    error: string | null;
+    /** The user paused this host's backfill; automatic runs wait for Resume. */
+    paused: boolean;
+}
+/** Read a host's run without creating the store; a running row whose process is gone reads as stopped. */
+export declare function readImportRun(host: BackfillHost): Promise<ImportRun | null>;
+export declare function isBackfillPaused(host: BackfillHost): Promise<boolean>;
+export declare function setBackfillPaused(host: BackfillHost, paused: boolean): Promise<void>;
+export interface ImportRunRecorder {
+    /** Feed from `onProgress`; writes at most once per interval and checks the paused flag. */
+    progress(done: number, total: number): void;
+    /** True after a progress write saw the paused flag. */
+    readonly pauseRequested: boolean;
+    finish(state: Exclude<ImportRunState, "running">, counts: Partial<ImportRunCounts>, error?: unknown): Promise<void>;
+}
+/**
+ * Start a host's run record. Only numbers, the surface, and the PID are
+ * stored; `promptPreview` and all other conversation content never are.
+ */
+export declare function startImportRun(host: BackfillHost, surface: ImportSurface, options?: {
+    now?: () => number;
+    intervalMs?: number;
+    sampleIntervalMs?: number;
+    onPause?: () => void;
+}): Promise<ImportRunRecorder>;

package/dist/importer/import-runs.js

@@ -0,0 +1,141 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG } from "../config.js";
+import { safeHealthError } from "../services/safe-health-error.js";
+import { tursoConnectionManager } from "../services/turso/connection-manager.js";
+import { isProcessAlive } from "./backfill-lock.js";
+import { addProgressSample, estimateProgress, } from "./import-progress.js";
+const dbPath = (storagePath = CONFIG.storagePath) => join(storagePath, "import-ledger.db");
+async function table(storagePath) {
+    const db = await tursoConnectionManager.getConnection(dbPath(storagePath));
+    await db.run(`CREATE TABLE IF NOT EXISTS import_runs (
+    host TEXT PRIMARY KEY, surface TEXT, state TEXT, pid INTEGER, started_at INTEGER,
+    total INTEGER NOT NULL DEFAULT 0, done INTEGER NOT NULL DEFAULT 0,
+    imported INTEGER NOT NULL DEFAULT 0, skipped INTEGER NOT NULL DEFAULT 0,
+    failed INTEGER NOT NULL DEFAULT 0, error TEXT, updated_at INTEGER,
+    samples TEXT, paused INTEGER NOT NULL DEFAULT 0
+  )`);
+    // A row per host keeps every later statement a plain UPDATE.
+    await db.run("INSERT OR IGNORE INTO import_runs (host) VALUES ('pi'), ('opencode')");
+    return db;
+}
+const count = (value) => (Number.isSafeInteger(value) && value >= 0 ? value : 0);
+/** Read a host's run without creating the store; a running row whose process is gone reads as stopped. */
+export async function readImportRun(host) {
+    if (!existsSync(dbPath()))
+        return null;
+    const db = await tursoConnectionManager.getConnection(dbPath());
+    const exists = await db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'import_runs'");
+    if (!exists)
+        return null;
+    const row = await db.get("SELECT * FROM import_runs WHERE host = ?", [
+        host,
+    ]);
+    if (!row)
+        return null;
+    const pid = row.pid === null ? null : Number(row.pid);
+    let state = (row.state ?? null);
+    if (state === "running" && (pid === null || !isProcessAlive(pid)))
+        state = "stopped";
+    const total = Number(row.total);
+    const done = Number(row.done);
+    const samples = row.samples ? JSON.parse(String(row.samples)) : [];
+    return {
+        host,
+        surface: (row.surface ?? null),
+        state,
+        pid,
+        startedAt: row.started_at === null ? null : Number(row.started_at),
+        updatedAt: row.updated_at === null ? null : Number(row.updated_at),
+        total,
+        done,
+        imported: Number(row.imported),
+        skipped: Number(row.skipped),
+        failed: Number(row.failed),
+        error: row.error === null ? null : String(row.error),
+        paused: Number(row.paused) === 1,
+        ...(state === "running"
+            ? estimateProgress(total, done, samples)
+            : {
+                percent: total > 0 ? Math.min(100, Math.floor((done / total) * 100)) : 0,
+                minutesLeft: null,
+                ratePerMinute: null,
+            }),
+    };
+}
+export async function isBackfillPaused(host) {
+    return (await readImportRun(host))?.paused ?? false;
+}
+export async function setBackfillPaused(host, paused) {
+    const db = await table();
+    await db.run("UPDATE import_runs SET paused = ?, updated_at = ? WHERE host = ?", [
+        paused ? 1 : 0,
+        Date.now(),
+        host,
+    ]);
+}
+/**
+ * Start a host's run record. Only numbers, the surface, and the PID are
+ * stored; `promptPreview` and all other conversation content never are.
+ */
+export async function startImportRun(host, surface, options = {}) {
+    const clock = options.now ?? Date.now;
+    const interval = options.intervalMs ?? 1_000;
+    const sampleInterval = options.sampleIntervalMs ?? 15_000;
+    const db = await table();
+    const startedAt = clock();
+    await db.run(`UPDATE import_runs SET surface = ?, state = 'running', pid = ?, started_at = ?, total = 0,
+       done = 0, imported = 0, skipped = 0, failed = 0, error = NULL, updated_at = ?, samples = '[]'
+     WHERE host = ?`, [surface, process.pid, startedAt, startedAt, host]);
+    let samples = [];
+    let lastWrite = Number.NEGATIVE_INFINITY;
+    let lastSample = Number.NEGATIVE_INFINITY;
+    let latest = { done: 0, total: 0 };
+    let pauseRequested = false;
+    let writing = Promise.resolve();
+    const write = () => {
+        const now = clock();
+        lastWrite = now;
+        // Sample less often than we write, so the window spans minutes, not seconds.
+        if (now - lastSample >= sampleInterval) {
+            lastSample = now;
+            samples = addProgressSample(samples, { at: now, done: latest.done });
+        }
+        const snapshot = { ...latest, samples: JSON.stringify(samples) };
+        writing = writing
+            .then(async () => {
+            await db.run("UPDATE import_runs SET total = ?, done = ?, samples = ?, updated_at = ? WHERE host = ?", [count(snapshot.total), count(snapshot.done), snapshot.samples, now, host]);
+            const row = await db.get("SELECT paused FROM import_runs WHERE host = ?", [host]);
+            if (Number(row?.paused) === 1 && !pauseRequested) {
+                pauseRequested = true;
+                options.onPause?.();
+            }
+        })
+            .catch(() => { });
+    };
+    return {
+        progress(done, total) {
+            latest = { done, total };
+            if (clock() - lastWrite >= interval)
+                write();
+        },
+        get pauseRequested() {
+            return pauseRequested;
+        },
+        async finish(state, counts, error) {
+            await writing;
+            await db.run(`UPDATE import_runs SET state = ?, total = ?, done = ?, imported = ?, skipped = ?,
+           failed = ?, error = ?, updated_at = ? WHERE host = ?`, [
+                state,
+                count(counts.total ?? latest.total),
+                count(counts.done ?? latest.done),
+                count(counts.imported ?? 0),
+                count(counts.skipped ?? 0),
+                count(counts.failed ?? 0),
+                error == null ? null : safeHealthError(error, [CONFIG.memoryApiKey]).slice(0, 500),
+                clock(),
+                host,
+            ]);
+        },
+    };
+}

package/dist/importer/import-sessions.js

@@ -65,14 +65,11 @@ export async function matchImportSessions(identity, options, snapshotMode) {
     const projectTag = options.scope === "current-project"
         ? projectFilterTag(resolve(options.cwd, options.project ?? "."))
         : null;
-    // Map targets resolve against the working directory, as `runHistoryImport` does.
-    const rows = await readRows(identity, {
-        ...options,
-        pathMaps: options.pathMaps.map((map) => ({
-            from: map.from,
-            to: resolve(options.cwd, map.to),
-        })),
-    }, snapshotMode);
+    // Saved maps plus the request's own, as `runHistoryImport` uses them.
+    // The revision hashes the same merged maps, so a saved-map change is seen as stale.
+    const { runPathMaps } = await import("./import-path-maps.js");
+    const merged = { ...options, pathMaps: await runPathMaps(options.pathMaps, options.cwd) };
+    const rows = await readRows(identity, merged, snapshotMode);
     const unresolved = rows.filter((row) => row.directory === null);
     const matching = rows
         .filter((row) => row.directory !== null)
@@ -82,7 +79,7 @@ export async function matchImportSessions(identity, options, snapshotMode) {
         identity,
         matching,
         unresolved,
-        revision: revisionOf(identity, options, projectTag, matching.map((row) => row.key)),
+        revision: revisionOf(identity, merged, projectTag, matching.map((row) => row.key)),
     };
 }
 /** Check a session-list request body from the page. */
@@ -136,6 +133,9 @@ export async function listImportSessions(request, options) {
     // A refresh takes a fresh copy of a live database; paging reuses the current one.
     const listedAt = Date.now();
     const matched = await matchImportSessions(identity, options, request.refresh ? "fresh" : "any");
+    // Feed the Directory maps list; a failure here must not break the listing.
+    const { recordUnresolvedDirectories, summarizeUnresolvedDirectories } = await import("../services/backfill-state.js");
+    await recordUnresolvedDirectories(options.host, summarizeUnresolvedDirectories(matched.unresolved.map((row) => ({ directory: row.recordedDirectory })))).catch(() => { });
     const rows = [
         ...matched.matching.map((row) => ({ ...row, selectable: true })),
         ...(options.scope === "all-projects"

package/dist/importer/importer.d.ts

@@ -87,7 +87,8 @@ export interface ImportReport {
 export interface ImporterDeps {
     loadSession: (file: string) => LoadedPiSession;
     provider: CaptureSummaryProvider;
-    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+    /** `alreadyHandled`: units found already done so far, which need no model call. */
+    onProgress?: (processed: number, total: number, promptPreview: string, alreadyHandled?: number) => void;
     signal?: AbortSignal;
     ledger?: PiImportLedger;
     profile?: {

package/dist/importer/importer.js

@@ -6,7 +6,7 @@ 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 { extractPiConversationWindows, } from "./pi-conversation.js";
 import { discoverPiSessions } from "./discovery.js";
 import { resolveImportProject } from "./import-project.js";
 import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
@@ -149,7 +149,7 @@ export async function importHistorySource(source, host, deps, filters, report) {
         const { sessionId, directory, sourceFile, hash, window } = candidate;
         const key = buildImportKey(sessionId, window, host);
         processed++;
-        deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt));
+        deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt), report.unitsAlreadyHandled);
         const unit = {
             key,
             sessionId: sessionId,

package/dist/importer/map-suggestions.d.ts

@@ -0,0 +1,39 @@
+import type { UnresolvedDirectory } from "../services/backfill-state.js";
+export interface MapSuggestionContext {
+    /** Existing project directories the user has history for; their parents are searched too. */
+    knownProjects?: readonly string[];
+    /** OpenCode's recorded project worktree for a session directory, read without writing. */
+    opencodeWorktree?: (directory: string) => string | null | undefined;
+    /** The user's home folder; the search never climbs above it. Defaults to `homedir()`. */
+    home?: string;
+    /** Folder listings already read in this request. */
+    cache?: Map<string, string[]>;
+}
+/**
+ * Suggest an existing target for a directory that no longer exists: first the
+ * main repository of a deleted worktree, by the longest leading part of the
+ * directory's name or one of its parents' names, then OpenCode's recorded
+ * project worktree. Returns null when there is no candidate.
+ */
+export declare function suggestMapTarget(missing: string, context?: MapSuggestionContext): string | null;
+export interface SuggestedDirectory extends UnresolvedDirectory {
+    suggestion: string | null;
+}
+export declare function suggestMapTargets(directories: readonly UnresolvedDirectory[], context?: MapSuggestionContext): SuggestedDirectory[];
+/**
+ * OpenCode's recorded project worktree for each session directory, through
+ * the importer's read-only reader. OpenCode's database is never written.
+ */
+export declare function readOpencodeWorktrees(dbPath: string): Promise<Map<string, string>>;
+/**
+ * The Directory maps list: saved maps and each host's unresolved directories
+ * from its latest run, with suggestions. Paths and counts only.
+ */
+export declare function directoryMapsView(options?: {
+    opencodeDbPath?: string;
+    knownProjects?: readonly string[];
+}): Promise<{
+    saved: import("./importer.js").ImportPathMap[];
+    pi: SuggestedDirectory[];
+    opencode: SuggestedDirectory[];
+}>;

package/dist/importer/map-suggestions.js

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, parse } from "node:path";
+const PROJECT_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod"];
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isProject(path) {
+    return PROJECT_MARKERS.some((marker) => existsSync(join(path, marker)));
+}
+function childDirectories(parent, cache) {
+    const cached = cache?.get(parent);
+    if (cached)
+        return cached;
+    let children;
+    try {
+        children = readdirSync(parent, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => join(parent, entry.name));
+    }
+    catch {
+        children = [];
+    }
+    cache?.set(parent, children);
+    return children;
+}
+/** `app` is a leading part of `app`, `app-feat-x`, and `app-feat-x-2`, not of `apple`. */
+function isLeadingPart(candidate, name) {
+    return name === candidate || name.startsWith(`${candidate}-`);
+}
+/**
+ * Suggest an existing target for a directory that no longer exists: first the
+ * main repository of a deleted worktree, by the longest leading part of the
+ * directory's name or one of its parents' names, then OpenCode's recorded
+ * project worktree. Returns null when there is no candidate.
+ */
+export function suggestMapTarget(missing, context = {}) {
+    const searchRoots = new Set();
+    for (const project of context.knownProjects ?? []) {
+        if (!isDirectory(project))
+            continue;
+        searchRoots.add(dirname(project));
+    }
+    // Never list the filesystem root or the folder that holds every home folder,
+    // and stop at the home folder itself: broad scans suggest unrelated folders.
+    const home = context.home ?? homedir();
+    const blocked = new Set([parse(missing).root, dirname(home)]);
+    let ancestor = missing;
+    while (dirname(ancestor) !== ancestor && ancestor !== home) {
+        const name = basename(ancestor);
+        const parents = new Set([dirname(ancestor), ...searchRoots]);
+        let best = null;
+        for (const parent of parents) {
+            if (blocked.has(parent))
+                continue;
+            for (const candidate of childDirectories(parent, context.cache)) {
+                if (candidate === ancestor || !isLeadingPart(basename(candidate), name))
+                    continue;
+                if (!isProject(candidate))
+                    continue;
+                if (!best || basename(candidate).length > basename(best).length)
+                    best = candidate;
+            }
+        }
+        if (best)
+            return best;
+        ancestor = dirname(ancestor);
+    }
+    const worktree = context.opencodeWorktree?.(missing);
+    if (worktree && worktree !== "/" && isDirectory(worktree))
+        return worktree;
+    return null;
+}
+export function suggestMapTargets(directories, context = {}) {
+    const withCache = { ...context, cache: context.cache ?? new Map() };
+    return directories.map((item) => ({
+        ...item,
+        suggestion: suggestMapTarget(item.directory, withCache),
+    }));
+}
+/**
+ * OpenCode's recorded project worktree for each session directory, through
+ * the importer's read-only reader. OpenCode's database is never written.
+ */
+export async function readOpencodeWorktrees(dbPath) {
+    const { openOpencodeHistory } = await import("./opencode-reader.js");
+    const history = await openOpencodeHistory(dbPath);
+    try {
+        const worktrees = new Map();
+        for (const session of history.sessions) {
+            if (session.recordedDirectory && session.projectWorktree) {
+                worktrees.set(session.recordedDirectory, session.projectWorktree);
+            }
+        }
+        return worktrees;
+    }
+    finally {
+        await history.close();
+    }
+}
+/**
+ * The Directory maps list: saved maps and each host's unresolved directories
+ * from its latest run, with suggestions. Paths and counts only.
+ */
+export async function directoryMapsView(options = {}) {
+    const { CONFIG } = await import("../config.js");
+    const { readUnresolvedDirectories } = await import("../services/backfill-state.js");
+    const { DEFAULT_OPENCODE_DB } = await import("./opencode-reader.js");
+    const saved = new Set(CONFIG.importPathMaps.map((map) => map.from));
+    let worktrees = new Map();
+    const dbPath = options.opencodeDbPath ?? DEFAULT_OPENCODE_DB;
+    if (existsSync(dbPath)) {
+        worktrees = await readOpencodeWorktrees(dbPath).catch(() => new Map());
+    }
+    const knownProjects = [
+        ...(options.knownProjects ?? []),
+        ...CONFIG.importPathMaps.map((map) => map.to),
+        ...worktrees.values(),
+    ];
+    const host = async (name) => {
+        const pending = (await readUnresolvedDirectories(name)).filter((item) => !saved.has(item.directory));
+        return suggestMapTargets(pending, {
+            knownProjects,
+            ...(name === "opencode" ? { opencodeWorktree: (dir) => worktrees.get(dir) } : {}),
+        });
+    };
+    return { saved: CONFIG.importPathMaps, pi: await host("pi"), opencode: await host("opencode") };
+}