spiracha 1.4.0 → 2.0.0

package/src/lib/cursor-exporter.ts

@@ -1,266 +0,0 @@
-import path from 'node:path';
-import {
-    findCursorWorkspaceGroups,
-    listCursorThreadsForGroup,
-    listCursorWorkspaceGroups,
-    readCursorThreadHead,
-    readCursorThreadTranscriptWithAgentFiles,
-} from './cursor-db';
-import {
-    type CursorCliOptions,
-    type CursorExportedFile,
-    type CursorExportRunResult,
-    type CursorThreadSummary,
-    type CursorWorkspaceGroup,
-    getCursorGlobalDbPath,
-    resolveCursorUserDir,
-} from './cursor-exporter-types';
-import { renderCursorTranscript } from './cursor-transcript';
-import { CliUsageError, type ExportFormat, expandHome, writeExportFile } from './shared';
-
-export const DEFAULT_CURSOR_OUTPUT_DIR = path.join(process.cwd(), 'exports', 'cursor');
-
-const resolveSingleGroup = (groups: CursorWorkspaceGroup[], query: string): CursorWorkspaceGroup => {
-    const matched = findCursorWorkspaceGroups(groups, query);
-    if (matched.length === 0) {
-        throw new Error(`No Cursor workspace matched query: ${query}`);
-    }
-
-    if (matched.length > 1) {
-        const keys = matched.map((group) => `  - ${group.key}`).join('\n');
-        throw new Error(
-            `Query "${query}" matched multiple Cursor workspaces. Refine it to a folder path or .code-workspace file:\n${keys}`,
-        );
-    }
-
-    return matched[0]!;
-};
-
-const collectThreadsToExport = async (
-    options: CursorCliOptions,
-): Promise<{ threads: CursorThreadSummary[]; missingThreadIds: string[] }> => {
-    if (options.threadIds.length > 0) {
-        return collectThreadsById(options);
-    }
-
-    if (!options.workspaceQuery) {
-        throw new CliUsageError('Provide a workspace (--workspace) or one or more --thread ids to export.');
-    }
-
-    const groups = await listCursorWorkspaceGroups(options.userDir);
-    const group = resolveSingleGroup(groups, options.workspaceQuery);
-    const threads = await listCursorThreadsForGroup(group, options.userDir);
-    return { missingThreadIds: [], threads: threads.filter((thread) => thread.bubbleCount > 0) };
-};
-
-// Export by id reads the global head record directly so we avoid scanning every workspace bucket.
-const collectThreadsById = async (
-    options: CursorCliOptions,
-): Promise<{ threads: CursorThreadSummary[]; missingThreadIds: string[] }> => {
-    const globalDbPath = getCursorGlobalDbPath(options.userDir);
-    const threads: CursorThreadSummary[] = [];
-    const missingThreadIds: string[] = [];
-
-    for (const threadId of options.threadIds) {
-        const head = readCursorThreadHead(globalDbPath, threadId);
-        if (!head) {
-            missingThreadIds.push(threadId);
-            continue;
-        }
-
-        threads.push({
-            bubbleBytes: 0,
-            bubbleCount: head.orderedBubbleIds.length,
-            bucketId: null,
-            composerId: head.composerId,
-            createdAtMs: head.createdAtMs,
-            lastUpdatedAtMs: head.lastUpdatedAtMs,
-            mode: head.mode,
-            name: head.name ?? '(untitled)',
-            transcriptDirs: [],
-            workspaceKey: '',
-            workspaceLabel: '',
-        });
-    }
-
-    return { missingThreadIds, threads };
-};
-
-export const runCursorExport = async (options: CursorCliOptions): Promise<CursorExportRunResult> => {
-    const globalDbPath = getCursorGlobalDbPath(options.userDir);
-    const outputDir = options.outputDir ?? DEFAULT_CURSOR_OUTPUT_DIR;
-    const { threads, missingThreadIds } = await collectThreadsToExport(options);
-    const files: CursorExportedFile[] = [];
-
-    for (const thread of threads) {
-        const exported = await exportSingleThread(thread, globalDbPath, outputDir, options);
-        if (exported) {
-            files.push(exported);
-        } else {
-            missingThreadIds.push(thread.composerId);
-        }
-    }
-
-    return {
-        exportedCount: files.length,
-        files,
-        missingThreadIds,
-        outputDir,
-    };
-};
-
-const exportSingleThread = async (
-    thread: CursorThreadSummary,
-    globalDbPath: string,
-    outputDir: string,
-    options: CursorCliOptions,
-): Promise<CursorExportedFile | null> => {
-    const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, thread.composerId, options.userDir);
-    if (!transcript) {
-        return null;
-    }
-
-    const content = renderCursorTranscript(transcript, options);
-    if (!content) {
-        return null;
-    }
-
-    const outputPath = path.join(outputDir, `${thread.composerId}.${options.outputFormat}`);
-    await writeExportFile(outputPath, content);
-
-    return { composerId: thread.composerId, outputPath };
-};
-
-const parseExportFormat = (value: string): ExportFormat => {
-    if (value === 'md' || value === 'txt') {
-        return value;
-    }
-
-    throw new CliUsageError(`Unsupported output format: ${value}`);
-};
-
-const requireValue = (value: string | undefined, flag: string): string => {
-    if (!value || (value.startsWith('-') && value !== '-')) {
-        throw new CliUsageError(`Missing value for ${flag}`);
-    }
-
-    return value;
-};
-
-export const parseCursorCliArgs = (argv: string[]): CursorCliOptions => {
-    const state: CursorCliOptions = {
-        includeCommentary: false,
-        includeMetadata: true,
-        includeTools: false,
-        outputDir: null,
-        outputFormat: 'md',
-        threadIds: [],
-        userDir: resolveCursorUserDir(),
-        workspaceQuery: null,
-    };
-
-    for (let index = 0; index < argv.length; index += 1) {
-        index = applyCursorCliArg(argv, index, state);
-    }
-
-    return state;
-};
-
-const applyCursorCliArg = (argv: string[], index: number, state: CursorCliOptions): number => {
-    const arg = argv[index] as string;
-    const flagIndex = applyCursorFlag(arg, state);
-    if (flagIndex) {
-        return index;
-    }
-
-    return applyCursorValueArg(argv, index, arg, state);
-};
-
-const applyCursorFlag = (arg: string, state: CursorCliOptions): boolean => {
-    if (arg === '--tools') {
-        state.includeTools = true;
-        return true;
-    }
-
-    if (arg === '--commentary' || arg === '--reasoning') {
-        state.includeCommentary = true;
-        return true;
-    }
-
-    if (arg === '--no-metadata') {
-        state.includeMetadata = false;
-        return true;
-    }
-
-    return false;
-};
-
-const applyCursorValueArg = (argv: string[], index: number, arg: string, state: CursorCliOptions): number => {
-    if (arg === '--workspace' || arg === '-w') {
-        state.workspaceQuery = expandHome(requireValue(argv[index + 1], arg));
-        return index + 1;
-    }
-
-    if (arg === '--thread' || arg === '-t') {
-        state.threadIds.push(requireValue(argv[index + 1], arg));
-        return index + 1;
-    }
-
-    if (arg === '--output' || arg === '-o') {
-        state.outputDir = expandHome(requireValue(argv[index + 1], arg));
-        return index + 1;
-    }
-
-    if (arg === '--user-dir') {
-        state.userDir = expandHome(requireValue(argv[index + 1], arg));
-        return index + 1;
-    }
-
-    if (arg.startsWith('--output-format=')) {
-        state.outputFormat = parseExportFormat(arg.slice('--output-format='.length));
-        return index;
-    }
-
-    if (arg === '--output-format') {
-        state.outputFormat = parseExportFormat(requireValue(argv[index + 1], '--output-format'));
-        return index + 1;
-    }
-
-    if (!arg.startsWith('-') && !state.workspaceQuery && state.threadIds.length === 0) {
-        state.workspaceQuery = expandHome(arg);
-        return index;
-    }
-
-    throw new CliUsageError(`Unknown argument: ${arg}`);
-};
-
-export const getCursorHelpText = (): string => {
-    return [
-        'Export, recover, and prune local Cursor Agent/Composer threads.',
-        '',
-        'Usage:',
-        '  spiracha cursor list [query]',
-        '  spiracha cursor export --workspace NAME [options]',
-        '  spiracha cursor export --thread COMPOSER_ID [--thread ...] [options]',
-        '  spiracha cursor recover <workspace> [--apply]',
-        '  spiracha cursor prune --workspace NAME [--thread ID ...] [--apply]',
-        '',
-        'Export options:',
-        '  --workspace, -w   Workspace folder name, path, or .code-workspace file',
-        '  --thread, -t      Composer/thread id (repeatable)',
-        '  --output, -o      Output directory (default: ./exports/cursor)',
-        '  --output-format   md or txt (default: md)',
-        '  --tools           Include tool calls and their results',
-        '  --commentary      Include assistant reasoning blocks',
-        '  --no-metadata     Omit the metadata header block',
-        '  --user-dir        Override the Cursor User data directory',
-        '',
-        'Recover/prune:',
-        '  --apply           Perform writes (default is a dry run). Quit Cursor first.',
-        '',
-        'Examples:',
-        '  spiracha cursor list',
-        '  spiracha cursor export --workspace gun-twizzle --tools --commentary',
-        '  spiracha cursor recover gun-twizzle --apply',
-    ].join('\n');
-};

package/src/lib/interactive-cli.ts

@@ -1,433 +0,0 @@
-import { access, lstat } from 'node:fs/promises';
-import path from 'node:path';
-import { stdin as input, stdout as output } from 'node:process';
-import { createInterface, type Interface } from 'node:readline/promises';
-import { checkbox } from '@inquirer/prompts';
-import { type ClaudeCliOptions, runClaudeExport } from './claude-exporter';
-import { resolveCodexThreadDbPath, withReadonlyDb } from './codex-browser-db';
-import { type CodexCliOptions, runCodexExport } from './codex-exporter';
-import { DEFAULT_INPUT_DIR } from './codex-exporter-types';
-import { type ExportFormat, expandHome, getPortablePathBasename } from './shared';
-
-type InteractiveTargetKind =
-    | 'codex_threads'
-    | 'codex_project'
-    | 'codex_projects_multi'
-    | 'codex_cwd'
-    | 'claude_path'
-    | 'unknown';
-
-type InteractiveInference = {
-    kind: InteractiveTargetKind;
-    value: string | null;
-};
-
-export type InteractiveExportResult =
-    | {
-          mode: 'codex';
-          outputDir: string;
-          exportedCount: number;
-          missingThreadIds: string[];
-          files: { sourcePath: string; outputPath: string; threadId: string | null }[];
-      }
-    | {
-          mode: 'claude';
-          outputPath: string;
-          sourcePath: string;
-      };
-
-export const runInteractiveExport = async (): Promise<InteractiveExportResult> => {
-    const rl = createPromptInterface();
-
-    try {
-        output.write('Interactive export mode\n\n');
-
-        const initial = (
-            await rl.question(
-                'Paste a Codex deeplink/thread id, project name, cwd path, or Claude export path.\nLeave blank to pick from a menu.\n> ',
-            )
-        ).trim();
-
-        const inferred = await inferInteractiveTarget(initial);
-        const selection = inferred.kind === 'unknown' ? await promptForTargetKind(rl) : inferred.kind;
-
-        switch (selection) {
-            case 'codex_threads':
-                return await runInteractiveCodexThreads(rl, inferred);
-            case 'codex_project':
-                return await runInteractiveCodexProject(rl, inferred);
-            case 'codex_projects_multi':
-                return await runInteractiveCodexProjectsMulti(rl);
-            case 'codex_cwd':
-                return await runInteractiveCodexCwd(rl, inferred);
-            case 'claude_path':
-                return await runInteractiveClaude(rl, inferred);
-            default:
-                throw new Error('Unsupported interactive selection');
-        }
-    } finally {
-        rl.close();
-    }
-};
-
-export const inferInteractiveTarget = async (value: string): Promise<InteractiveInference> => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return { kind: 'unknown', value: null };
-    }
-
-    const expanded = expandHome(trimmed);
-    const pathStats = await lstat(expanded).catch(() => null);
-
-    if (pathStats) {
-        return await inferInteractiveTargetFromPath(expanded, pathStats);
-    }
-
-    return inferInteractiveTargetFromText(trimmed, expanded);
-};
-
-const inferInteractiveTargetFromPath = async (
-    expanded: string,
-    pathStats: Awaited<ReturnType<typeof lstat>>,
-): Promise<InteractiveInference> => {
-    if (pathStats.isDirectory()) {
-        const metadataExists = await access(path.join(expanded, 'metadata.json'))
-            .then(() => true)
-            .catch(() => false);
-        return {
-            kind: metadataExists ? 'claude_path' : 'codex_cwd',
-            value: expanded,
-        };
-    }
-
-    if (pathStats.isFile()) {
-        return {
-            kind: expanded.endsWith('.jsonl') ? 'claude_path' : 'unknown',
-            value: expanded,
-        };
-    }
-
-    return { kind: 'unknown', value: expanded };
-};
-
-const inferInteractiveTargetFromText = (trimmed: string, expanded: string): InteractiveInference => {
-    if (trimmed.startsWith('codex://threads/') || isRawThreadId(trimmed)) {
-        return { kind: 'codex_threads', value: trimmed };
-    }
-
-    if (trimmed.includes(path.sep) || trimmed.startsWith('~')) {
-        return { kind: 'codex_cwd', value: expanded };
-    }
-
-    return { kind: 'codex_project', value: trimmed };
-};
-
-const promptForTargetKind = async (rl: Interface): Promise<Exclude<InteractiveTargetKind, 'unknown'>> => {
-    output.write(
-        [
-            '',
-            'What do you want to export?',
-            '1. Specific Codex thread(s)',
-            '2. Codex project name',
-            '3. Exact Codex cwd path',
-            '4. Claude transcript file or export directory',
-            '5. Select one or more Codex projects',
-            '',
-        ].join('\n'),
-    );
-
-    while (true) {
-        const choice = (await rl.question('Choose 1-5: ')).trim();
-        if (choice === '1') {
-            return 'codex_threads';
-        }
-        if (choice === '2') {
-            return 'codex_project';
-        }
-        if (choice === '3') {
-            return 'codex_cwd';
-        }
-        if (choice === '4') {
-            return 'claude_path';
-        }
-        if (choice === '5') {
-            return 'codex_projects_multi';
-        }
-
-        output.write('Please enter 1, 2, 3, 4, or 5.\n');
-    }
-};
-
-const runInteractiveCodexThreads = async (
-    rl: Interface,
-    inferred: InteractiveInference,
-): Promise<InteractiveExportResult> => {
-    const dbPath = resolveInteractiveDbPath();
-    const raw =
-        inferred.kind === 'codex_threads' && inferred.value
-            ? inferred.value
-            : (
-                  await rl.question(
-                      'Enter one or more Codex deeplinks or raw thread ids, separated by commas or spaces:\n> ',
-                  )
-              ).trim();
-
-    const threadIds = normalizeInteractiveThreadSelections(raw);
-    if (threadIds.length === 0) {
-        throw new Error('At least one Codex thread id or deeplink is required.');
-    }
-
-    const options = await promptForCommonCodexOptions(rl, dbPath, {
-        cwdFilter: null,
-        projectFilter: null,
-        threadIds,
-    });
-    const result = await runCodexExport(options);
-    return { mode: 'codex', ...result };
-};
-
-const runInteractiveCodexProject = async (
-    rl: Interface,
-    inferred: InteractiveInference,
-): Promise<InteractiveExportResult> => {
-    const dbPath = resolveInteractiveDbPath();
-    const project = (
-        inferred.kind === 'codex_project' && inferred.value
-            ? inferred.value
-            : (await rl.question('Enter the Codex project name (cwd basename):\n> ')).trim()
-    ).trim();
-
-    if (!project) {
-        throw new Error('A project name is required.');
-    }
-
-    const options = await promptForCommonCodexOptions(rl, dbPath, {
-        cwdFilter: null,
-        projectFilter: project,
-        threadIds: [],
-    });
-    const result = await runCodexExport(options);
-    return { mode: 'codex', ...result };
-};
-
-const runInteractiveCodexProjectsMulti = async (rl: Interface): Promise<InteractiveExportResult> => {
-    const dbPath = resolveInteractiveDbPath();
-    const projects = listCodexProjects(dbPath);
-    if (projects.length === 0) {
-        throw new Error(`No Codex projects found in ${dbPath}.`);
-    }
-
-    output.write('Use Space to toggle projects, and Enter to confirm.\n');
-    // Inquirer manages the TTY directly; reopen readline afterwards for follow-up prompts.
-    rl.close();
-    const selectedProjects = await checkbox({
-        choices: projects.map((project) => ({ name: project, value: project })),
-        message: 'Select Codex project(s) to export:',
-        pageSize: 15,
-    });
-
-    if (selectedProjects.length === 0) {
-        throw new Error('At least one project must be selected.');
-    }
-
-    const threadIds = listThreadIdsForProjects(dbPath, selectedProjects);
-    if (threadIds.length === 0) {
-        throw new Error('No threads found for the selected projects.');
-    }
-
-    const followupRl = createPromptInterface();
-    try {
-        const options = await promptForCommonCodexOptions(followupRl, dbPath, {
-            cwdFilter: null,
-            projectFilter: null,
-            threadIds,
-        });
-        const result = await runCodexExport(options);
-        return { mode: 'codex', ...result };
-    } finally {
-        followupRl.close();
-    }
-};
-
-const runInteractiveCodexCwd = async (
-    rl: Interface,
-    inferred: InteractiveInference,
-): Promise<InteractiveExportResult> => {
-    const dbPath = resolveInteractiveDbPath();
-    const cwdInput =
-        inferred.kind === 'codex_cwd' && inferred.value
-            ? inferred.value
-            : (await rl.question('Enter the exact Codex cwd path:\n> ')).trim();
-    const cwdFilter = expandHome(cwdInput);
-
-    if (!cwdFilter) {
-        throw new Error('A cwd path is required.');
-    }
-
-    const options = await promptForCommonCodexOptions(rl, dbPath, {
-        cwdFilter,
-        projectFilter: null,
-        threadIds: [],
-    });
-    const result = await runCodexExport(options);
-    return { mode: 'codex', ...result };
-};
-
-const runInteractiveClaude = async (
-    rl: Interface,
-    inferred: InteractiveInference,
-): Promise<InteractiveExportResult> => {
-    const inputPath = expandHome(
-        inferred.kind === 'claude_path' && inferred.value
-            ? inferred.value
-            : (await rl.question('Enter the Claude transcript .jsonl file or export directory:\n> ')).trim(),
-    );
-
-    if (!inputPath) {
-        throw new Error('A Claude transcript path is required.');
-    }
-
-    const outputFormat = await promptForOutputFormat(rl);
-    const includeTools = await promptYesNo(rl, 'Include tool output? [y/N]: ', false);
-    const outputPath = await promptOptionalPath(rl, 'Optional output path or directory (leave blank for default):\n> ');
-
-    const result = await runClaudeExport({
-        includeTools,
-        inputPath,
-        outputFormat,
-        outputPath,
-    } satisfies ClaudeCliOptions);
-
-    return { mode: 'claude', ...result };
-};
-
-const promptForCommonCodexOptions = async (
-    rl: Interface,
-    dbPath: string,
-    target: Pick<CodexCliOptions, 'threadIds' | 'cwdFilter' | 'projectFilter'>,
-): Promise<CodexCliOptions> => {
-    const outputFormat = await promptForOutputFormat(rl);
-    const includeMetadata = await promptYesNo(rl, 'Include metadata? [Y/n]: ', true);
-    const includeCommentary = await promptYesNo(rl, 'Include commentary messages? [y/N]: ', false);
-    const includeTools = await promptYesNo(rl, 'Include tool logs? [y/N]: ', false);
-    const flat = await promptYesNo(rl, 'Write to a flat output folder? [y/N]: ', false);
-    const outputDir = await promptOptionalPath(rl, 'Optional output directory (leave blank for default):\n> ');
-
-    return {
-        cwdFilter: target.cwdFilter,
-        dbPath,
-        flat,
-        includeCommentary,
-        includeMetadata,
-        includeTools,
-        inputDir: DEFAULT_INPUT_DIR,
-        outputDir: outputDir ?? resolveInteractiveOutputDir(target.cwdFilter),
-        outputFormat,
-        projectFilter: target.projectFilter,
-        threadIds: target.threadIds,
-    };
-};
-
-const resolveInteractiveOutputDir = (cwdFilter: string | null) => {
-    if (cwdFilter) {
-        const basename = getPortablePathBasename(cwdFilter);
-        if (basename) {
-            return path.join(process.cwd(), basename);
-        }
-    }
-
-    return path.join(process.cwd(), 'exports');
-};
-
-const promptForOutputFormat = async (rl: Interface): Promise<ExportFormat> => {
-    output.write(['', 'Output format:', '1. Markdown (.md)', '2. Plain text (.txt)', ''].join('\n'));
-
-    while (true) {
-        const choice = (await rl.question('Choose 1-2 [1]: ')).trim();
-        if (!choice || choice === '1') {
-            return 'md';
-        }
-        if (choice === '2') {
-            return 'txt';
-        }
-
-        output.write('Please enter 1 or 2.\n');
-    }
-};
-
-const promptYesNo = async (rl: Interface, prompt: string, defaultValue: boolean): Promise<boolean> => {
-    while (true) {
-        const answer = (await rl.question(prompt)).trim().toLowerCase();
-        if (!answer) {
-            return defaultValue;
-        }
-        if (answer === 'y' || answer === 'yes') {
-            return true;
-        }
-        if (answer === 'n' || answer === 'no') {
-            return false;
-        }
-
-        output.write('Please answer y or n.\n');
-    }
-};
-
-const promptOptionalPath = async (rl: Interface, prompt: string): Promise<string | null> => {
-    const answer = (await rl.question(prompt)).trim();
-    return answer ? expandHome(answer) : null;
-};
-
-const normalizeInteractiveThreadSelections = (value: string): string[] => {
-    const rawTokens = value
-        .split(/[,\s]+/)
-        .map((token) => token.trim())
-        .filter(Boolean);
-
-    const threadIds = rawTokens.map((token) => {
-        if (token.startsWith('codex://threads/')) {
-            return token.replace(/^codex:\/\/threads\//u, '');
-        }
-        if (isRawThreadId(token)) {
-            return token;
-        }
-
-        throw new Error(`Unsupported thread selection: ${token}`);
-    });
-
-    return [...new Set(threadIds)];
-};
-
-const listCodexProjects = (dbPath: string): string[] => {
-    return withReadonlyDb(dbPath, (db) => {
-        const rows = db.query("SELECT DISTINCT cwd FROM threads WHERE cwd IS NOT NULL AND cwd != ''").all() as Array<{
-            cwd: string;
-        }>;
-        return [...new Set(rows.map((row) => getPortablePathBasename(row.cwd)).filter(Boolean))].sort();
-    });
-};
-
-const resolveInteractiveDbPath = (): string => {
-    return resolveCodexThreadDbPath();
-};
-
-const listThreadIdsForProjects = (dbPath: string, projectNames: string[]): string[] => {
-    if (projectNames.length === 0) {
-        return [];
-    }
-
-    return withReadonlyDb(dbPath, (db) => {
-        const projectNameSet = new Set(projectNames);
-        const rows = db
-            .query("SELECT id, cwd FROM threads WHERE cwd IS NOT NULL AND cwd != '' ORDER BY updated_at DESC")
-            .all() as Array<{ id: string; cwd: string }>;
-        return rows.filter((row) => projectNameSet.has(getPortablePathBasename(row.cwd))).map((row) => row.id);
-    });
-};
-
-const createPromptInterface = (): Interface => {
-    return createInterface({ input, output });
-};
-
-const isRawThreadId = (value: string): boolean => {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu.test(value);
-};