@alsdd/t3-import 0.0.0-stage → 0.1.1-alsd.1

package/dist/tui.d.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import type { ConversationReplacePreview, ConversationSyncPreview, ReplaceSelection, SourceName, TargetPaths } from "./core/types.js";
+import { type DestinationOptions } from "./target/destination.js";
+export type Screen = "preflight" | "blocked" | "source" | "workspace" | "provider" | "threads" | "destination" | "review" | "running" | "result" | "launching" | "launch-error" | "error";
+export interface TuiDestinationChoice {
+    label: string;
+    options?: DestinationOptions;
+}
+export declare function sourceLabel(source: SourceName): string;
+/** Only offer destinations that the importer's canonical policy accepts. */
+export declare function discoverTuiDestinations(paths: TargetPaths, workspace: string): TuiDestinationChoice[];
+export declare function escapeDestination(screen: Screen, history: Screen[]): Screen | undefined;
+interface TuiProps {
+    paths: TargetPaths;
+    initialSource?: SourceName;
+    initialWorkspace?: string;
+    initialProvider?: string;
+    mode?: "auto" | "sync" | "replace";
+    resetCache?: boolean;
+}
+export declare function helpTextForScreen(screen: Screen, searching?: boolean): string | undefined;
+export declare function selectionMarker(isSelected: boolean, isDisabled: boolean): string;
+export declare function StartT3Prompt({ index }: {
+    index: number;
+}): React.JSX.Element;
+export declare function ReplacementReview({ workspace, selections, previews, counts, resetCache, }: {
+    workspace: string | undefined;
+    selections: ReplaceSelection[];
+    previews: Map<string, ConversationReplacePreview>;
+    counts: {
+        tasks: number;
+        turns: number;
+        events: number;
+        attachments: number;
+    };
+    resetCache: boolean;
+}): React.JSX.Element;
+export declare function conversationStatusText(preview: ConversationSyncPreview | undefined, checking: boolean): string;
+export declare function replacementStatusText(preview: ConversationReplacePreview | undefined, checking: boolean): string;
+export declare function ConversationStatusDetails({ preview, replacement, checking, error, mode, review }: {
+    preview?: ConversationSyncPreview | undefined;
+    replacement?: ConversationReplacePreview | undefined;
+    checking: boolean;
+    error?: string | undefined;
+    mode?: "auto" | "sync" | "replace";
+    review?: boolean;
+}): React.JSX.Element;
+export declare function ImportTui({ paths, initialSource, initialWorkspace, initialProvider, mode, resetCache }: TuiProps): React.JSX.Element;
+export {};

package/dist/tui.js

@@ -0,0 +1,560 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import Database from "better-sqlite3";
+import { Box, Text, useApp, useInput } from "ink";
+import { sourceAdapter } from "./sources/index.js";
+import { compactThreadForImport, importConversations } from "./target/importer.js";
+import { inspectConversationSync, syncConversations } from "./target/sync.js";
+import { listProviderInstances } from "./target/config.js";
+import { inspectRuntime } from "./target/schema.js";
+import { launchT3Code } from "./target/launch.js";
+import { resetT3RebuildableCache } from "./target/cache.js";
+import { inspectConversationReplacement, replaceConversations } from "./target/replace.js";
+import { importDestination } from "./target/destination.js";
+import { sourceNames } from "./core/providers.js";
+import { canonicalPath } from "./core/util.js";
+export function sourceLabel(source) {
+    if (source === "codex")
+        return "Codex";
+    if (source === "claude")
+        return "Claude Code";
+    return "OpenCode";
+}
+/** Only offer destinations that the importer's canonical policy accepts. */
+export function discoverTuiDestinations(paths, workspace) {
+    const db = new Database(paths.dbPath, { readonly: true, fileMustExist: true });
+    try {
+        const rows = db.prepare("SELECT project_id projectId, title, workspace_root workspaceRoot FROM projection_projects WHERE deleted_at IS NULL ORDER BY title COLLATE NOCASE, project_id").all();
+        const matching = rows.filter((row) => canonicalPath(row.workspaceRoot) === canonicalPath(workspace));
+        const choices = [{ label: matching.length ? "Use the matching workspace project (default)" : "Create or use the workspace project (default)" }];
+        for (const row of matching) {
+            try {
+                importDestination(db, paths, workspace, { targetProject: row.projectId });
+                choices.push({ label: `${row.title} · ${row.workspaceRoot}`, options: { targetProject: row.projectId } });
+            }
+            catch {
+                // A project that fails the importer's destination invariant is not selectable.
+            }
+        }
+        try {
+            importDestination(db, paths, workspace, { noProject: true });
+            choices.push({ label: "No project (T3 scratch)", options: { noProject: true } });
+        }
+        catch {
+            // Native scratch is only offered when the canonical policy permits it.
+        }
+        return choices;
+    }
+    finally {
+        db.close();
+    }
+}
+export function escapeDestination(screen, history) {
+    if (["source", "blocked", "result", "launch-error", "error"].includes(screen))
+        return undefined;
+    return history.at(-1);
+}
+export function helpTextForScreen(screen, searching = false) {
+    if (searching)
+        return "Type to search  Backspace delete  Enter apply  Esc cancel";
+    if (screen === "threads")
+        return "↑/↓ or j/k move  Space select  a all  / search  Enter continue  Esc back/quit  q quit";
+    if (screen === "source" || screen === "workspace" || screen === "provider" || screen === "destination")
+        return "↑/↓ or j/k move  Enter choose  Esc back/quit  q quit";
+    if (screen === "review")
+        return "Enter confirm  Esc back  q quit";
+    if (screen === "result")
+        return "↑/↓ or j/k move  Enter confirm  q quit";
+    return undefined;
+}
+function Help({ screen, searching }) {
+    const text = helpTextForScreen(screen, searching);
+    return text ? _jsx(Text, { dimColor: true, children: text }) : null;
+}
+export function selectionMarker(isSelected, isDisabled) {
+    if (isDisabled)
+        return "⊘";
+    return isSelected ? "◉" : "○";
+}
+function Menu({ items, index, selected, disabled }) {
+    return _jsx(Box, { flexDirection: "column", children: items.map((item, itemIndex) => {
+            const isDisabled = disabled?.has(itemIndex) ?? false;
+            return _jsxs(Text, { dimColor: isDisabled, ...(itemIndex === index && !isDisabled ? { color: "cyan" } : {}), children: [itemIndex === index ? "›" : " ", " ", selected ? selectionMarker(selected.has(itemIndex), isDisabled) : "", " ", item] }, `${itemIndex}:${item}`);
+        }) });
+}
+export function StartT3Prompt({ index }) {
+    return _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Start T3 Code now?" }), _jsx(Menu, { items: ["Yes", "No"], index: index }), _jsx(Text, { dimColor: true, children: "Press Enter to confirm." })] });
+}
+export function ReplacementReview({ workspace, selections, previews, counts, resetCache, }) {
+    const taskWord = counts.tasks === 1 ? "task" : "tasks";
+    return _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Review replacement" }), _jsxs(Text, { children: ["Workspace: ", workspace] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: selections.map((selection) => {
+                    const preview = previews.get(selection.conversation.summary.id);
+                    return _jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: selection.conversation.summary.title }), _jsxs(Text, { children: ["Old T3 task: ", preview?.oldThreadId] }), _jsxs(Text, { children: ["New T3 task: ", preview?.newThreadId] })] }, `replacement-review:${selection.conversation.summary.id}`);
+                }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["The new ", taskWord, " will contain:"] }), _jsxs(Text, { children: ["  ", counts.turns, " turns \u00B7 ", counts.events, " events \u00B7 ", counts.attachments, " attachments"] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: ["The provider, model, and resume connection will transfer to the new ", taskWord, "."] }), _jsxs(Text, { children: ["The old ", taskWord, " will disappear from T3 but remain in its event history."] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { children: "When you confirm, t3-import will automatically:" }), _jsx(Text, { children: "  \u2022 Create a verified backup of the T3 database" }), _jsxs(Text, { children: ["  ", resetCache ? "• Back up and reset T3's UI cache" : "• Keep T3's existing UI cache (--no-cache-reset)"] })] }), _jsx(Text, { color: "yellow", children: "T3 must remain closed." }), _jsx(Text, { bold: true, children: "Press Enter to replace, or Escape to cancel." })] });
+}
+export function conversationStatusText(preview, checking) {
+    if (!preview)
+        return checking ? "checking…" : "unavailable";
+    if (preview.status === "new")
+        return "new";
+    if (preview.status === "active-only")
+        return "active turn only";
+    if (preview.status === "syncable") {
+        const added = `${preview.newTurns} new turn${preview.newTurns === 1 ? "" : "s"}`;
+        const statuses = [];
+        if (preview.newInterruptedTurns)
+            statuses.push(preview.newTurns === 1 ? "interrupted" : `${preview.newInterruptedTurns} interrupted`);
+        if (preview.newFailedTurns)
+            statuses.push(preview.newTurns === 1 ? "failed" : `${preview.newFailedTurns} failed`);
+        const detail = statuses.length ? ` · ${statuses.join(", ")}` : "";
+        return preview.adoptedTurns ? `${added}${detail}, ${preview.adoptedTurns} adopted` : `${added}${detail}`;
+    }
+    if (preview.status === "up-to-date")
+        return `up to date${preview.ignoredActiveTurns ? ` · ${preview.ignoredActiveTurns} active turn${preview.ignoredActiveTurns === 1 ? "" : "s"} ignored` : ""}`;
+    if (preview.status === "history-diverged")
+        return "history changed";
+    if (preview.status === "branch-sync-unsupported")
+        return "branch sync unsupported";
+    return "target missing";
+}
+export function replacementStatusText(preview, checking) {
+    if (!preview)
+        return checking ? "checking…" : "unavailable";
+    if (preview.status === "replaceable")
+        return "replace available";
+    if (preview.status === "already-current")
+        return "already current";
+    if (preview.status === "active-source")
+        return "active source";
+    if (preview.status === "branch-replace-unsupported")
+        return "branch replacement unsupported";
+    if (preview.status === "not-imported")
+        return "not imported";
+    return "target missing";
+}
+export function ConversationStatusDetails({ preview, replacement, checking, error, mode = "auto", review = false }) {
+    let action;
+    if (error)
+        action = "Unavailable: inspection failed. Resolve the error and reopen this workspace.";
+    else if (mode === "replace")
+        action = replacement?.selectable
+            ? "Select to review replacement. Existing history will be replaced only after confirmation."
+            : checking && !replacement ? "Checking replacement eligibility…" : "Replacement is unavailable for this conversation.";
+    else if (!preview)
+        action = checking ? "Checking source history and target identity…" : "No reconciliation preview is available.";
+    else if (preview.status === "new")
+        action = mode === "sync"
+            ? "No eligible sync target was found. Use import to review a new conversation."
+            : "Select to import a new conversation. No eligible existing target was found.";
+    else if (preview.status === "syncable")
+        action = "Select to append the settled missing turns. Existing messages and local titles are preserved.";
+    else if (preview.status === "up-to-date")
+        action = "No settled messages need importing.";
+    else if (preview.status === "active-only")
+        action = "Wait for the source turn to finish, then reopen this workspace to check again.";
+    else if (preview.status === "history-diverged")
+        action = replacement?.selectable && mode === "auto"
+            ? "Conflict: select to review replacement. Histories will not be merged automatically."
+            : "Conflict: inspect the differing histories before choosing replacement.";
+    else if (preview.status === "branch-sync-unsupported")
+        action = "Conflict: branches require separate inspection; automatic sync is unavailable.";
+    else
+        action = "The previous target is missing. Inspect or restore it before retrying.";
+    if (review && preview?.status === "new")
+        action = "Will import a new conversation after confirmation.";
+    if (review && preview?.status === "syncable")
+        action = `Will append ${preview.newTurns} settled turn(s) after confirmation. Existing messages and local titles are preserved.`;
+    const warnings = [...new Set([...(preview?.warnings ?? []), ...(replacement?.warnings ?? [])])];
+    return _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { children: action }), preview?.ignoredActiveTurns ? _jsxs(Text, { color: "yellow", children: [preview.ignoredActiveTurns, " unfinished source turn(s) excluded; only settled history is eligible."] }) : null, error ? _jsxs(Text, { color: "yellow", children: ["Reason: ", error] }) : null, warnings.map((warning) => _jsxs(Text, { color: "yellow", children: ["Reason: ", warning] }, warning))] });
+}
+export function ImportTui({ paths, initialSource, initialWorkspace, initialProvider, mode = "auto", resetCache = false }) {
+    const app = useApp();
+    const [screen, setScreen] = useState("preflight");
+    const [screenHistory, setScreenHistory] = useState([]);
+    const [runtime, setRuntime] = useState();
+    const [source, setSource] = useState(initialSource ?? "codex");
+    const [summaries, setSummaries] = useState([]);
+    const [workspace, setWorkspace] = useState();
+    const [provider, setProvider] = useState(initialProvider);
+    const [destinationChoices, setDestinationChoices] = useState([]);
+    const [destinationError, setDestinationError] = useState();
+    const [destinationOptions, setDestinationOptions] = useState({});
+    const [index, setIndex] = useState(0);
+    const [selected, setSelected] = useState(new Set());
+    const [conversations, setConversations] = useState(new Map());
+    const [syncPreviews, setSyncPreviews] = useState(new Map());
+    const [replacePreviews, setReplacePreviews] = useState(new Map());
+    const [pendingStatuses, setPendingStatuses] = useState(0);
+    const [inspectionErrors, setInspectionErrors] = useState(new Map());
+    const [preparedImports, setPreparedImports] = useState([]);
+    const [preparedSync, setPreparedSync] = useState([]);
+    const [preparedReplacements, setPreparedReplacements] = useState([]);
+    const [searching, setSearching] = useState(false);
+    const [query, setQuery] = useState("");
+    const [result, setResult] = useState();
+    const [syncResult, setSyncResult] = useState();
+    const [replaceResult, setReplaceResult] = useState();
+    const [error, setError] = useState();
+    const [launchError, setLaunchError] = useState();
+    const [cacheWarning, setCacheWarning] = useState();
+    const checkingStatuses = pendingStatuses > 0;
+    const navigate = useCallback((next) => {
+        setScreenHistory((history) => [...history, screen]);
+        setScreen(next);
+        setIndex(0);
+    }, [screen]);
+    const workspaces = useMemo(() => [...new Map(summaries.map((summary) => [summary.workspace.toLowerCase(), summary.workspace])).values()], [summaries]);
+    const providers = useMemo(() => listProviderInstances(paths, source), [paths, source]);
+    const visibleThreads = useMemo(() => summaries
+        .filter((summary) => !workspace || summary.workspace.toLowerCase() === workspace.toLowerCase())
+        .filter((summary) => mode !== "replace" || !replacePreviews.has(summary.id) || replacePreviews.get(summary.id)?.previouslyImported)
+        .filter((summary) => !query || summary.title.toLowerCase().includes(query.toLowerCase()) || summary.id.includes(query)), [mode, query, replacePreviews, summaries, workspace]);
+    const operationFor = useCallback((summary) => {
+        const preview = syncPreviews.get(summary.id);
+        const replacement = replacePreviews.get(summary.id);
+        if (mode === "replace")
+            return replacement?.selectable ? "replace" : undefined;
+        if (mode === "sync")
+            return preview?.status === "syncable" ? "regular" : undefined;
+        if (replacement?.selectable && preview?.status === "history-diverged")
+            return "replace";
+        return preview?.selectable ? "regular" : undefined;
+    }, [mode, replacePreviews, syncPreviews]);
+    const canSelect = useCallback((summary) => {
+        const operation = operationFor(summary);
+        if (!operation)
+            return false;
+        const selectedOperation = [...selected].map((id) => summaries.find((item) => item.id === id)).filter((item) => Boolean(item)).map(operationFor).find(Boolean);
+        return !selectedOperation || selectedOperation === operation;
+    }, [operationFor, selected, summaries]);
+    const selectedVisible = useMemo(() => new Set(visibleThreads.flatMap((summary, itemIndex) => selected.has(summary.id) ? [itemIndex] : [])), [selected, visibleThreads]);
+    const disabledVisible = useMemo(() => new Set(visibleThreads.flatMap((summary, itemIndex) => canSelect(summary) ? [] : [itemIndex])), [canSelect, visibleThreads]);
+    const statusCounts = useMemo(() => {
+        const counts = { new: 0, syncable: 0, current: 0, active: 0, conflicts: 0, unavailable: 0 };
+        for (const summary of visibleThreads) {
+            if (inspectionErrors.has(summary.id)) {
+                counts.unavailable += 1;
+                continue;
+            }
+            const status = syncPreviews.get(summary.id)?.status;
+            if (status === "new")
+                counts.new += 1;
+            else if (status === "syncable")
+                counts.syncable += 1;
+            else if (status === "up-to-date")
+                counts.current += 1;
+            else if (status === "active-only")
+                counts.active += 1;
+            else if (status)
+                counts.conflicts += 1;
+        }
+        return counts;
+    }, [visibleThreads, syncPreviews, inspectionErrors]);
+    const importPreview = useMemo(() => preparedImports.reduce((counts, selection) => {
+        for (const sourceThread of selection.conversation.threads) {
+            const thread = compactThreadForImport(sourceThread);
+            counts.tasks += 1;
+            counts.turns += thread.turns.length;
+            counts.messages += thread.turns.reduce((sum, turn) => sum + 1 + turn.assistant.length, 0);
+            counts.activities += thread.turns.reduce((sum, turn) => sum + turn.activities.length, 0) + (thread.currentBranch ? 0 : 1);
+            counts.attachments += thread.turns.reduce((sum, turn) => sum + turn.user.attachments.length, 0);
+        }
+        return counts;
+    }, { tasks: 0, turns: 0, messages: 0, activities: 0, attachments: 0 }), [preparedImports]);
+    const syncPreview = useMemo(() => preparedSync.reduce((counts, selection) => {
+        const preview = syncPreviews.get(selection.conversation.summary.id);
+        counts.tasks += 1;
+        counts.turns += preview?.newTurns ?? 0;
+        counts.adopted += preview?.adoptedTurns ?? 0;
+        counts.titles += preview?.titleChanged ? 1 : 0;
+        return counts;
+    }, { tasks: 0, turns: 0, adopted: 0, titles: 0 }), [preparedSync, syncPreviews]);
+    const replacementPreview = useMemo(() => preparedReplacements.reduce((counts, selection) => {
+        const preview = replacePreviews.get(selection.conversation.summary.id);
+        counts.tasks += 1;
+        counts.turns += preview?.turns ?? 0;
+        counts.events += preview?.events ?? 0;
+        counts.attachments += preview?.attachments ?? 0;
+        return counts;
+    }, { tasks: 0, turns: 0, events: 0, attachments: 0 }), [preparedReplacements, replacePreviews]);
+    const checkRuntime = useCallback(() => {
+        setScreenHistory([]);
+        setScreen("preflight");
+        inspectRuntime(paths)
+            .then((state) => {
+            setRuntime(state);
+            setScreen(state.live ? "blocked" : initialSource ? "workspace" : "source");
+        })
+            .catch((cause) => {
+            setError(`Unable to check T3 runtime: ${cause instanceof Error ? cause.message : String(cause)}`);
+            setScreen("error");
+        });
+    }, [initialSource, paths]);
+    useEffect(() => { checkRuntime(); }, [checkRuntime]);
+    useEffect(() => {
+        if (screen !== "workspace")
+            return;
+        let cancelled = false;
+        setIndex(0);
+        sourceAdapter(source).discover({}).then((items) => {
+            if (cancelled)
+                return;
+            setSummaries(items);
+            const selectedWorkspace = initialWorkspace
+                ? items.find((item) => item.workspace.toLowerCase() === initialWorkspace.toLowerCase())?.workspace
+                : undefined;
+            if (selectedWorkspace) {
+                setWorkspace(selectedWorkspace);
+                setProvider(initialProvider ?? providers[0]);
+                // An explicit --workspace bypasses the chooser and its navigation history.
+                setScreen("threads");
+            }
+        }).catch((cause) => { if (!cancelled) {
+            setError(cause instanceof Error ? cause.message : String(cause));
+            setScreen("error");
+        } });
+        return () => { cancelled = true; };
+    }, [screen, source]);
+    useEffect(() => {
+        if (screen !== "threads" || !workspace)
+            return;
+        let cancelled = false;
+        const items = summaries.filter((summary) => summary.workspace.toLowerCase() === workspace.toLowerCase());
+        const queue = [...items];
+        setPendingStatuses(items.length);
+        setSelected(new Set());
+        setConversations(new Map());
+        setSyncPreviews(new Map());
+        setReplacePreviews(new Map());
+        setInspectionErrors(new Map());
+        const worker = async () => {
+            while (!cancelled) {
+                const summary = queue.shift();
+                if (!summary)
+                    return;
+                try {
+                    const conversation = await sourceAdapter(source).load(summary, { workspace });
+                    const preview = mode === "replace" ? undefined : await inspectConversationSync(conversation, paths);
+                    const replacement = mode === "replace" || preview?.status === "history-diverged"
+                        ? await inspectConversationReplacement(conversation, paths)
+                        : undefined;
+                    if (cancelled)
+                        return;
+                    setConversations((current) => new Map(current).set(summary.id, conversation));
+                    if (preview)
+                        setSyncPreviews((current) => new Map(current).set(summary.id, preview));
+                    if (replacement)
+                        setReplacePreviews((current) => new Map(current).set(summary.id, replacement));
+                    setSummaries((current) => current.map((item) => item.id === summary.id
+                        ? { ...item, title: conversation.summary.title, updatedAt: conversation.summary.updatedAt, status: conversation.summary.status }
+                        : item));
+                }
+                catch (cause) {
+                    if (!cancelled)
+                        setInspectionErrors((current) => new Map(current).set(summary.id, cause instanceof Error ? cause.message : String(cause)));
+                }
+                finally {
+                    if (!cancelled)
+                        setPendingStatuses((count) => Math.max(0, count - 1));
+                }
+            }
+        };
+        void Promise.all(Array.from({ length: Math.min(3, items.length) }, () => worker()));
+        return () => { cancelled = true; };
+    }, [mode, paths, screen, source, workspace]);
+    useEffect(() => {
+        if (screen !== "destination" || !workspace)
+            return;
+        try {
+            setDestinationChoices(discoverTuiDestinations(paths, workspace));
+            setDestinationError(undefined);
+            setDestinationOptions({});
+            setIndex(0);
+        }
+        catch (cause) {
+            setDestinationError(cause instanceof Error ? cause.message : String(cause));
+            setDestinationChoices([]);
+        }
+    }, [paths, screen, workspace]);
+    const move = (delta, length) => setIndex((current) => length === 0 ? 0 : (current + delta + length) % length);
+    useInput((input, key) => {
+        if (screen === "running")
+            return;
+        if (searching) {
+            if (key.escape || key.return)
+                setSearching(false);
+            else if (key.backspace || key.delete)
+                setQuery((value) => value.slice(0, -1));
+            else if (!key.ctrl && !key.meta && input)
+                setQuery((value) => value + input);
+            return;
+        }
+        if (input === "q") {
+            app.exit();
+            return;
+        }
+        if (screen === "blocked" && (input === "r" || key.return)) {
+            checkRuntime();
+            return;
+        }
+        if (key.upArrow || input === "k") {
+            move(-1, screen === "source" ? sourceNames.length : screen === "result" ? 2 : screen === "workspace" ? workspaces.length : screen === "provider" ? providers.length : screen === "destination" ? destinationChoices.length : visibleThreads.length);
+            return;
+        }
+        if (key.downArrow || input === "j") {
+            move(1, screen === "source" ? sourceNames.length : screen === "result" ? 2 : screen === "workspace" ? workspaces.length : screen === "provider" ? providers.length : screen === "destination" ? destinationChoices.length : visibleThreads.length);
+            return;
+        }
+        if (key.escape) {
+            const previous = escapeDestination(screen, screenHistory);
+            if (!previous) {
+                app.exit();
+                return;
+            }
+            if (screen === "provider" && previous === "threads") {
+                setPreparedImports([]);
+                setPreparedSync([]);
+                setPreparedReplacements([]);
+            }
+            setScreenHistory((history) => history.slice(0, -1));
+            setScreen(previous);
+            setIndex(0);
+            return;
+        }
+        if (screen === "source" && key.return) {
+            setSource(sourceNames[index]);
+            setSelected(new Set());
+            setPreparedImports([]);
+            setPreparedSync([]);
+            setPreparedReplacements([]);
+            navigate("workspace");
+            return;
+        }
+        if (screen === "workspace" && key.return && workspaces[index]) {
+            setWorkspace(workspaces[index]);
+            setProvider(initialProvider ?? providers[0]);
+            navigate("threads");
+            return;
+        }
+        if (screen === "provider" && key.return && providers[index]) {
+            setProvider(providers[index]);
+            navigate(preparedImports.length ? "destination" : "threads");
+            return;
+        }
+        if (screen === "destination" && key.return && destinationChoices[index]) {
+            setDestinationOptions(destinationChoices[index].options ?? {});
+            navigate("review");
+            return;
+        }
+        if (screen === "threads") {
+            if (input === "/") {
+                setSearching(true);
+                return;
+            }
+            if (input === "a") {
+                const currentOperation = visibleThreads[index] ? operationFor(visibleThreads[index]) : undefined;
+                const operation = currentOperation ?? visibleThreads.map(operationFor).find(Boolean);
+                const selectable = visibleThreads.filter((summary) => canSelect(summary) && operationFor(summary) === operation);
+                setSelected((value) => selectable.every((summary) => value.has(summary.id))
+                    ? new Set([...value].filter((id) => !selectable.some((summary) => summary.id === id)))
+                    : new Set([...value, ...selectable.map((summary) => summary.id)]));
+                return;
+            }
+            if (input === " " && visibleThreads[index] && canSelect(visibleThreads[index])) {
+                const id = visibleThreads[index].id;
+                setSelected((value) => { const next = new Set(value); if (next.has(id))
+                    next.delete(id);
+                else
+                    next.add(id); return next; });
+                return;
+            }
+            if (key.return && selected.size > 0) {
+                const chosen = summaries.filter((summary) => selected.has(summary.id));
+                const imports = [];
+                const syncs = [];
+                const replacements = [];
+                for (const summary of chosen) {
+                    const conversation = conversations.get(summary.id);
+                    const preview = syncPreviews.get(summary.id);
+                    if (!conversation)
+                        continue;
+                    if (operationFor(summary) === "replace")
+                        replacements.push({ conversation });
+                    else if (preview?.status === "new" && mode === "auto")
+                        imports.push({ conversation, resume: true });
+                    else if (preview?.status === "syncable")
+                        syncs.push({ conversation });
+                }
+                setPreparedImports(imports);
+                setPreparedSync(syncs);
+                setPreparedReplacements(replacements);
+                if (imports.length > 0) {
+                    setDestinationOptions({});
+                    navigate(!initialProvider && providers.length > 1 ? "provider" : "destination");
+                }
+                else
+                    navigate("review");
+                return;
+            }
+        }
+        if (screen === "review" && key.return) {
+            setScreen("running");
+            const run = async () => {
+                const imported = preparedImports.length
+                    ? await importConversations(preparedImports, paths, { dryRun: false, resume: true, ...(provider ? { providerInstance: provider } : {}), ...destinationOptions })
+                    : undefined;
+                const synced = preparedSync.length
+                    ? await syncConversations(preparedSync, paths, { dryRun: false, allowProjectionBacklog: Boolean(imported?.results.some((item) => item.status === "imported")) })
+                    : undefined;
+                const replaced = preparedReplacements.length
+                    ? await replaceConversations(preparedReplacements, paths, { dryRun: false })
+                    : undefined;
+                const changed = Boolean(imported?.results.some((item) => item.status === "imported")) || Boolean(synced?.results.some((item) => item.status === "synced")) || Boolean(replaced?.results.some((item) => item.status === "replaced"));
+                if (resetCache && changed) {
+                    try {
+                        const cache = await resetT3RebuildableCache(paths);
+                        const holder = replaced ?? synced ?? imported;
+                        if (holder) {
+                            holder.cache = cache;
+                            holder.warnings.push(...cache.warnings);
+                        }
+                    }
+                    catch (cause) {
+                        setCacheWarning(`T3 data was updated, but its IndexedDB cache could not be reset: ${cause instanceof Error ? cause.message : String(cause)}`);
+                    }
+                }
+                setResult(imported);
+                setSyncResult(synced);
+                setReplaceResult(replaced);
+                setIndex(0);
+                setScreen("result");
+            };
+            run().catch((cause) => { setError(cause instanceof Error ? cause.message : String(cause)); setScreen("error"); });
+        }
+        if (screen === "result" && key.return) {
+            if (index === 1) {
+                app.exit();
+                return;
+            }
+            setScreen("launching");
+            launchT3Code().then(() => app.exit()).catch((cause) => {
+                setLaunchError(cause instanceof Error ? cause.message : String(cause));
+                setScreen("launch-error");
+            });
+            return;
+        }
+        if ((screen === "launch-error" || screen === "error") && key.return)
+            app.exit();
+    });
+    return _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "t3-import" }), _jsxs(Text, { dimColor: true, children: ["Target: ", paths.dbPath] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [screen === "preflight" && _jsx(Text, { children: "Checking whether T3 is running\u2026" }), screen === "blocked" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: "red", children: "T3 is running" }), _jsxs(Text, { children: ["Close T3 before importing, syncing, or replacing", runtime?.pid ? ` (detected PID ${runtime.pid})` : "", "."] }), runtime?.origin ? _jsxs(Text, { dimColor: true, children: ["Runtime: ", runtime.origin] }) : null, _jsx(Text, { children: "Press r or Enter to check again, or q to quit." })] }), screen === "source" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Choose a source" }), _jsx(Menu, { items: sourceNames.map(sourceLabel), index: index })] }), screen === "workspace" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Choose a workspace" }), summaries.length === 0 ? _jsxs(Text, { children: ["Discovering ", source, " conversations\u2026"] }) : _jsx(Menu, { items: workspaces, index: index })] }), screen === "provider" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Choose a T3 provider instance" }), _jsx(Menu, { items: providers, index: index })] }), screen === "destination" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Choose a T3 destination for new imports" }), _jsx(Text, { dimColor: true, children: "Available choices preserve the source working directory." }), destinationError ? _jsx(Text, { color: "red", children: destinationError }) : destinationChoices.length ? _jsx(Menu, { items: destinationChoices.map((choice) => choice.label), index: index }) : _jsx(Text, { children: "Checking available destinations\u2026" })] }), screen === "threads" && _jsxs(_Fragment, { children: [_jsxs(Text, { bold: true, children: [mode === "sync" ? "Select conversations to sync" : mode === "replace" ? "Select conversations to replace" : "Select conversations", " \u2014 ", workspace] }), searching || query ? _jsxs(Text, { color: "yellow", children: ["Search: ", query, _jsx(Text, { dimColor: true, children: "_" })] }) : null, _jsx(Menu, { items: visibleThreads.map((item) => {
+                                    const syncText = conversationStatusText(syncPreviews.get(item.id), checkingStatuses);
+                                    const replacement = replacePreviews.get(item.id);
+                                    const status = mode === "replace"
+                                        ? replacementStatusText(replacement, checkingStatuses)
+                                        : syncPreviews.get(item.id)?.status === "history-diverged" && replacement?.selectable
+                                            ? "history changed · replace available"
+                                            : syncText;
+                                    return `${item.title}  ${status}`;
+                                }), index: index, selected: selectedVisible, disabled: disabledVisible }), mode !== "replace" ? _jsxs(Text, { dimColor: true, children: ["New: ", statusCounts.new, " · To sync: ", statusCounts.syncable, " · Current: ", statusCounts.current, " · Active only: ", statusCounts.active, " · Conflicts: ", statusCounts.conflicts, " · Unavailable: ", statusCounts.unavailable] }) : null, visibleThreads[index] ? _jsx(ConversationStatusDetails, { preview: syncPreviews.get(visibleThreads[index].id), replacement: replacePreviews.get(visibleThreads[index].id), checking: checkingStatuses, error: inspectionErrors.get(visibleThreads[index].id), mode: mode }) : null, pendingStatuses > 0 ? _jsxs(Text, { dimColor: true, children: ["Checking ", pendingStatuses, " conversation", pendingStatuses === 1 ? "" : "s", "\u2026"] }) : null, visibleThreads.length === 0 && _jsx(Text, { color: "yellow", children: "No matching conversations." })] }), screen === "review" && _jsx(_Fragment, { children: preparedReplacements.length ? _jsx(_Fragment, { children: _jsx(ReplacementReview, { workspace: workspace, selections: preparedReplacements, previews: replacePreviews, counts: replacementPreview, resetCache: resetCache }) }) : _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, children: "Review changes" }), _jsxs(Text, { children: ["Source: ", source, " \u00B7 Workspace: ", workspace] }), preparedImports.length ? _jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Source working directory: ", workspace] }), _jsxs(Text, { children: ["Effective T3 working directory: ", workspace] }), _jsxs(Text, { children: ["Destination: ", destinationChoices.find((choice) => JSON.stringify(choice.options ?? {}) === JSON.stringify(destinationOptions))?.label ?? "Use workspace project automatically"] })] }) : null, _jsxs(Text, { children: ["New tasks: ", importPreview.tasks, " \u00B7 synchronized tasks: ", syncPreview.tasks] }), _jsxs(Text, { children: ["Imported turns: ", importPreview.turns, " \u00B7 added turns: ", syncPreview.turns, " \u00B7 adopted turns: ", syncPreview.adopted] }), _jsxs(Text, { children: ["Messages: ", importPreview.messages, " \u00B7 activities: ", importPreview.activities, " \u00B7 attachments: ", importPreview.attachments] }), _jsxs(Text, { children: ["Title updates: ", syncPreview.titles] }), [...preparedImports, ...preparedSync].map((selection) => _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: selection.conversation.summary.title }), _jsx(ConversationStatusDetails, { preview: syncPreviews.get(selection.conversation.summary.id), checking: false, mode: mode, review: true })] }, selection.conversation.summary.id)), preparedImports.length ? _jsxs(Text, { children: ["Provider for new tasks: ", provider] }) : null, resetCache ? _jsx(Text, { children: "T3 IndexedDB cache: back up and reset after successful changes" }) : _jsx(Text, { children: "T3 IndexedDB cache: keep existing cache" }), _jsx(Text, { color: "yellow", children: "T3 must remain closed. A verified backup will be created before database changes." }), _jsx(Text, { bold: true, children: "Press Enter to continue, Escape to go back." })] }) }), screen === "running" && _jsx(Text, { children: "Backing up and reconciling conversations\u2026" }), screen === "result" && (result || syncResult || replaceResult) && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: "green", children: "Complete" }), result ? _jsxs(Text, { children: ["Import backup: ", result.backup ?? "not needed"] }) : null, result?.results.map((item) => _jsxs(Text, { children: [item.status === "imported" ? "✓" : "•", " ", item.title, " \u2014 ", item.status, ", ", item.turns, " turns, ", item.events, " events"] }, `import:${item.threadId}`)), syncResult ? _jsxs(Text, { children: ["Sync backup: ", syncResult.backup ?? "not needed"] }) : null, syncResult?.results.map((item) => _jsxs(Text, { children: [item.status === "synced" ? "✓" : "•", " ", item.title, " \u2014 ", item.status, ", ", item.turnsAdded, " added, ", item.turnsAdopted, " adopted, ", item.events, " events"] }, `sync:${item.sourceKey}`)), replaceResult ? _jsxs(Text, { children: ["Replacement backup: ", replaceResult.backup ?? "not needed"] }) : null, replaceResult?.results.map((item) => _jsxs(Text, { children: [item.status === "replaced" ? "✓" : "•", " ", item.title, " \u2014 ", item.status, item.oldThreadId ? `, old ${item.oldThreadId}` : "", item.newThreadId ? `, new ${item.newThreadId}` : "", ", ", item.turns, " turns, ", item.events, " events"] }, `replace:${item.sourceKey}`)), (replaceResult?.cache ?? syncResult?.cache ?? result?.cache) ? _jsxs(Text, { children: ["Cache backup: ", (replaceResult?.cache ?? syncResult?.cache ?? result?.cache)?.backup ?? "cache not found"] }) : null, cacheWarning ? _jsx(Text, { color: "yellow", children: cacheWarning }) : null, _jsx(StartT3Prompt, { index: index })] }), screen === "launching" && _jsx(Text, { children: "Starting T3 Code\u2026" }), screen === "launch-error" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: "red", children: "Could not start T3 Code" }), _jsx(Text, { children: launchError }), _jsx(Text, { dimColor: true, children: "Press Enter to exit and start it manually." })] }), screen === "error" && _jsxs(_Fragment, { children: [_jsx(Text, { bold: true, color: "red", children: "Operation failed" }), _jsx(Text, { children: error }), _jsx(Text, { dimColor: true, children: "Press Enter to exit." })] })] }), helpTextForScreen(screen, searching) ? _jsx(Box, { marginTop: 1, children: _jsx(Help, { screen: screen, searching: searching }) }) : null] });
+}
+//# sourceMappingURL=tui.js.map