@askdkc/dsh-cli 0.11.3

package/lib/types/dsh-adapter/migrate/adapters/scan.js

@@ -0,0 +1,38 @@
+/**
+ * Shared lightweight counting for the migration adapters.
+ *
+ * Bare `dsh-tui migrate` (and the TUI's `/migrate`) only prints a per-agent
+ * count, but discover() parses EVERY file into memory (real-world scale:
+ * ~9600 files / 5.5GB → 49s and ~880MB just to print five numbers —
+ * deep-review M3). countSessions() walks the same trees matching only
+ * directory-entry NAMES: no file is opened, no line is parsed.
+ *
+ * @module dsh-cli/migrate/adapters/scan
+ */
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/** Walk-mode file/directory counter shared by every adapter's fast count. */
+export function countEntries(roots, options) {
+    let count = 0;
+    const walk = (dir, depth) => {
+        if (depth > options.maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(path, depth + 1);
+            else if (entry.isFile() && options.fileMatch(entry.name))
+                count += 1;
+        }
+    };
+    for (const root of roots)
+        walk(root, 0);
+    return count;
+}

package/lib/types/dsh-adapter/migrate/adapters/zcode.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const zcodeAdapter: MigrationAdapter;
+//# sourceMappingURL=zcode.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/zcode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zcode.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/zcode.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAiDxG,eAAO,MAAM,YAAY,EAAE,gBAmC1B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/zcode.js

@@ -0,0 +1,107 @@
+/**
+ * zcode adapter: `~/.zcode/v2/sessions/<dir>/<taskId>.json` — one JSON
+ * object per conversation (`{ meta, messages }`), the simplest of the
+ * foreign stores: plain-string contents and epoch-millisecond timestamps.
+ *
+ * @module dsh-cli/migrate/adapters/zcode
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { countEntries } from './scan.js';
+function readOne(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    let doc;
+    try {
+        doc = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    // A legal `null` (or scalar) document is not a conversation; member
+    // access on it would throw and kill the whole scan.
+    if (!doc || typeof doc !== 'object')
+        return undefined;
+    const meta = doc.meta;
+    const messages = doc.messages;
+    // !x also rejects JSON null (typeof null === 'object').
+    if (!meta || typeof meta !== 'object' || !Array.isArray(messages))
+        return undefined;
+    const taskId = meta.taskId;
+    const cwd = meta.workspacePath;
+    const title = meta.title;
+    const createdAt = meta.createdAt;
+    if (typeof taskId !== 'string' || taskId === '')
+        return undefined;
+    if (typeof cwd !== 'string' || cwd === '')
+        return undefined;
+    const turns = [];
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        if (message.role !== 'user' && message.role !== 'assistant')
+            continue;
+        if (typeof message.content !== 'string' || message.content === '')
+            continue;
+        const time = typeof message.timestamp === 'number' ? message.timestamp : 0;
+        turns.push({ role: message.role, text: message.content, time });
+    }
+    if (turns.length === 0)
+        return undefined;
+    return {
+        sourceId: taskId,
+        cwd,
+        title: typeof title === 'string' && title !== '' ? title : undefined,
+        startedAt: typeof createdAt === 'number' ? createdAt : turns[0].time,
+        turns,
+    };
+}
+export const zcodeAdapter = {
+    id: 'zcode',
+    label: 'zcode',
+    roots: () => [join(homedir(), '.zcode', 'v2', 'sessions')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 3)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name.endsWith('.json')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: 3, fileMatch: name => name.endsWith('.json') });
+    },
+};

package/lib/types/dsh-adapter/migrate/bin-path.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve `bin/dsh-tui.js` for the package that contains `fromDir`, or
+ * undefined when no ancestor within the probe bound carries it.
+ */
+export declare function resolveOwnBin(fromDir: string): string | undefined;
+//# sourceMappingURL=bin-path.d.ts.map

package/lib/types/dsh-adapter/migrate/bin-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-path.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/bin-path.ts"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMjE"}

package/lib/types/dsh-adapter/migrate/bin-path.js

@@ -0,0 +1,30 @@
+/**
+ * Locate this package's `bin/dsh-tui.js` from a module directory inside it.
+ *
+ * The TUI's `/migrate` spawns the CLI through the package bin so the import
+ * runs in a child process. Callers live at DIFFERENT depths per layout:
+ * `src/screens/` at dev time (three levels), `lib/types/screens/` when
+ * installed (four levels) — a fixed dirname count lands inside the tree and
+ * the spawn fails on every real install (the regression the probe-up walk
+ * below replaces; found by the independent test session on a real profile).
+ * Probing upward for `bin/dsh-tui.js` matches both layouts without knowing
+ * which one we are in — the same spirit as src/update.ts's manifest walk.
+ *
+ * @module dsh-cli/migrate/bin-path
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/** Upward probe bounds: covers src/screens and lib/types/screens layouts. */
+const PROBE_UP = ['..', '../..', '../../..', '../../../..'];
+/**
+ * Resolve `bin/dsh-tui.js` for the package that contains `fromDir`, or
+ * undefined when no ancestor within the probe bound carries it.
+ */
+export function resolveOwnBin(fromDir) {
+    for (const up of PROBE_UP) {
+        const candidate = join(fromDir, up, 'bin', 'dsh-tui.js');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}

package/lib/types/dsh-adapter/migrate/cli.d.ts

@@ -0,0 +1,9 @@
+/** Exit code for "nothing to do / unknown agent". */
+export declare const MIGRATE_CLI_USAGE_EXIT = 2;
+/**
+ * Run one migration CLI invocation.
+ * @param argv - Arguments after the `migrate` word.
+ * @returns Process exit code.
+ */
+export declare function cliMigrate(argv: readonly string[]): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/lib/types/dsh-adapter/migrate/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/cli.ts"],"names":[],"mappings":"AAuBA,qDAAqD;AACrD,eAAO,MAAM,sBAAsB,IAAI,CAAA;AAQvC;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAUzE"}

package/lib/types/dsh-adapter/migrate/cli.js

@@ -0,0 +1,105 @@
+/**
+ * CLI surface for migration, reached via `dsh-tui migrate ...` (the bin
+ * launcher delegates here exactly like it delegates `update`; the TUI's
+ * `/migrate` command spawns this same CLI in a child process).
+ *
+ * Usage:
+ *   dsh-tui migrate                     # list agents and discoverable counts (writes nothing)
+ *   dsh-tui migrate <agent>             # import every conversation found from that agent
+ *   dsh-tui migrate <agent> --dry-run   # show what would land, write nothing
+ *
+ * One agent per run, and `--dry-run` always names one: both are usage errors
+ * rather than silent fallbacks, matching the TUI's `/migrate` entry points.
+ *
+ * Every string that originated OUTSIDE this machine (source ids, cwds, error
+ * text embedding them) passes through cleanRenderText before printing: a
+ * hostile session file must not be able to drive terminal escape sequences
+ * through the preview/report paths (deep-review M2).
+ *
+ * @module dsh-cli/migrate/cli
+ */
+import { cleanRenderText } from '../sanitize.js';
+import { MIGRATION_ADAPTERS, defaultSessionRoot, importSessions } from './index.js';
+/** Exit code for "nothing to do / unknown agent". */
+export const MIGRATE_CLI_USAGE_EXIT = 2;
+/** Bound for one cleaned external string in CLI output (display cells). */
+const RENDER_CELL_BUDGET = 200;
+/** One external-origin string, sanitized to display-safe text. */
+const safe = (value) => cleanRenderText(value, RENDER_CELL_BUDGET);
+/**
+ * Run one migration CLI invocation.
+ * @param argv - Arguments after the `migrate` word.
+ * @returns Process exit code.
+ */
+export async function cliMigrate(argv) {
+    try {
+        return await cliMigrateInner(argv);
+    }
+    catch (error) {
+        // A top-level failure (e.g. persistence never becomes ready because the
+        // target root is unwritable) must land as one CLI-style summary line,
+        // not a bare Node stack trace (deep-review i1).
+        process.stderr.write(`dsh-tui migrate: ${error instanceof Error ? safe(error.message) : String(error)}\n`);
+        return 1;
+    }
+}
+async function cliMigrateInner(argv) {
+    const dryRun = argv.includes('--dry-run');
+    const words = argv.filter(word => word !== '--dry-run');
+    if (words.length > 1) {
+        process.stderr.write('usage: dsh-tui migrate [<agent>] [--dry-run]\n');
+        return MIGRATE_CLI_USAGE_EXIT;
+    }
+    const wanted = words[0];
+    if (wanted === undefined) {
+        // `--dry-run` previews ONE source, so it needs one named: without this the
+        // flag fell through to the listing below and was silently ignored (the
+        // TUI's `/migrate --dry-run` says the same thing).
+        if (dryRun) {
+            process.stderr.write('usage: dsh-tui migrate <agent> --dry-run\n');
+            return MIGRATE_CLI_USAGE_EXIT;
+        }
+        // Bare `migrate` only reports; importing requires an explicit agent.
+        for (const adapter of MIGRATION_ADAPTERS) {
+            // Name-only count when the adapter offers one: list mode must not pay
+            // a full parse of every foreign file (deep-review M3). The count is
+            // scan candidates; import filters unreadable/empty ones, so it may
+            // land slightly above the imported total.
+            const available = adapter.count !== undefined ? adapter.count() : adapter.discover().sessions.length;
+            console.log(`[${adapter.id}] ${available} session file(s) to scan (run \`dsh-tui migrate ${adapter.id}\` to import)`);
+        }
+        return 0;
+    }
+    const agent = MIGRATION_ADAPTERS.find(adapter => adapter.id === wanted);
+    if (agent === undefined) {
+        process.stderr.write(`dsh-tui migrate: unknown agent "${safe(wanted)}"; known: ${MIGRATION_ADAPTERS.map(adapter => adapter.id).join(', ')}\n`);
+        return MIGRATE_CLI_USAGE_EXIT;
+    }
+    const found = agent.discover();
+    if (found.sessions.length === 0) {
+        console.log(`[${agent.id}] no conversations found`);
+        return 0;
+    }
+    if (dryRun) {
+        console.log(`[${agent.id}] ${found.sessions.length} conversation(s) would be imported into ${defaultSessionRoot()} (dry run)`);
+        for (const session of found.sessions.slice(0, 5)) {
+            console.log(`  · ${safe(session.sourceId)}  (${session.turns.length} messages · cwd ${safe(session.cwd)})`);
+        }
+        if (found.sessions.length > 5)
+            console.log(`  … and ${found.sessions.length - 5} more`);
+        return 0;
+    }
+    console.log(`[${agent.id}] importing ${found.sessions.length} conversation(s) into ${defaultSessionRoot()}`);
+    const run = await importSessions(agent, defaultSessionRoot(), found.sessions);
+    const parts = [`imported ${run.imported}`];
+    if (run.existing > 0)
+        parts.push(`already present ${run.existing}`);
+    if (run.failed > 0)
+        parts.push(`failed ${run.failed}`);
+    console.log(`[${agent.id}] ${parts.join(' · ')}`);
+    for (const failure of run.failures.slice(0, 10))
+        console.log(`  ✗ ${safe(failure)}`);
+    if (run.failures.length > 10)
+        console.log(`  … and ${run.failures.length - 10} more`);
+    return run.failed > 0 ? 1 : 0;
+}

package/lib/types/dsh-adapter/migrate/index.d.ts

@@ -0,0 +1,29 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import type { MigrationAdapter, MigrationSession } from './types.js';
+export declare const MIGRATION_ADAPTERS: readonly MigrationAdapter[];
+/** The default import target: the shared DSH session store. */
+export declare function defaultSessionRoot(): string;
+/** Deterministic session id for one foreign conversation. */
+export declare function migrationSessionId(adapter: MigrationAdapter, session: MigrationSession): SessionId;
+export interface ImportRun {
+    readonly imported: number;
+    readonly existing: number;
+    readonly failed: number;
+    /** One-line cause per failed conversation, for the CLI summary. */
+    readonly failures: readonly string[];
+}
+/**
+ * Import every discovered conversation of one adapter into the DSH store.
+ *
+ * The persistence backend is mounted ONCE per run (one Context, one plugin
+ * lifecycle) and disposed after the loop; sessions already present (same
+ * deterministic id) are skipped, and a failed conversation never aborts the
+ * batch — both properties the retired-store migration established first.
+ *
+ * @param adapter - the foreign agent to import from.
+ * @param root - the DSH session root to write into.
+ * @param sessions - the conversations to import (usually adapter.discover()).
+ * @returns the per-run counters.
+ */
+export declare function importSessions(adapter: MigrationAdapter, root: string, sessions: readonly MigrationSession[]): Promise<ImportRun>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/dsh-adapter/migrate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AASpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAGpE,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAMzD,CAAA;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,IAAI,MAAM,CAG3C;AAED,6DAA6D;AAC7D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAElG;AAuBD,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,gBAAgB,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,OAAO,CAAC,SAAS,CAAC,CAyCpB"}

package/lib/types/dsh-adapter/migrate/index.js

@@ -0,0 +1,108 @@
+/**
+ * Cross-agent conversation migration: orchestration over the official
+ * persistence backend.
+ *
+ * Discovery is read-only against foreign stores (adapters never write their
+ * source). Import goes EXCLUSIVELY through `JsonlSessionPersistence` — the
+ * same plugin the retired-store migration (scripts/migrate-sessions-to-jsonl.mts)
+ * writes through — so physical encoding, `projectKey`/directory layout, zstd
+ * frames, atomic writes and Windows path handling are upstream's, not ours.
+ * Re-importing the same source conversation deterministically lands on the
+ * same session id and is skipped when already present: repeats neither stack
+ * duplicates nor rewrite existing logs.
+ *
+ * @module dsh-cli/migrate
+ */
+import { Context } from '@deepseek-ai/cordis';
+import JsonlSessionPersistence from '@deepseek-ai/dsh-session-persistence-jsonl';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { claudeCodeAdapter } from './adapters/claude-code.js';
+import { codexAdapter } from './adapters/codex.js';
+import { ompAdapter } from './adapters/omp.js';
+import { grokBuildAdapter } from './adapters/grok-build.js';
+import { zcodeAdapter } from './adapters/zcode.js';
+import { sessionize } from './sessionize.js';
+import { migrationUuid } from './uuid.js';
+export const MIGRATION_ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    ompAdapter,
+    zcodeAdapter,
+    grokBuildAdapter,
+];
+/** The default import target: the shared DSH session store. */
+export function defaultSessionRoot() {
+    const dshHome = process.env.DSH_HOME?.trim();
+    return join(dshHome ? dshHome : join(homedir(), '.dsh'), 'sessions');
+}
+/** Deterministic session id for one foreign conversation. */
+export function migrationSessionId(adapter, session) {
+    return SessionId(migrationUuid(`${adapter.id}:${session.sourceId}`));
+}
+/** Wait until the plugin's service is published on the context. */
+async function awaitPersistence(ctx) {
+    for (let i = 0; i < 200; i++) {
+        const service = ctx.get('sessionPersistence');
+        if (service !== undefined)
+            return service;
+        await new Promise(resolve => setTimeout(resolve, 25));
+    }
+    throw new Error('session persistence service did not become ready');
+}
+/**
+ * Import every discovered conversation of one adapter into the DSH store.
+ *
+ * The persistence backend is mounted ONCE per run (one Context, one plugin
+ * lifecycle) and disposed after the loop; sessions already present (same
+ * deterministic id) are skipped, and a failed conversation never aborts the
+ * batch — both properties the retired-store migration established first.
+ *
+ * @param adapter - the foreign agent to import from.
+ * @param root - the DSH session root to write into.
+ * @param sessions - the conversations to import (usually adapter.discover()).
+ * @returns the per-run counters.
+ */
+export async function importSessions(adapter, root, sessions) {
+    const ctx = new Context();
+    const fiber = ctx.plugin(JsonlSessionPersistence, { root });
+    let imported = 0;
+    let existing = 0;
+    let failed = 0;
+    const failures = [];
+    try {
+        const persistence = await awaitPersistence(ctx);
+        const present = new Set((await persistence.list()).map(entry => entry.header.id));
+        for (const session of sessions) {
+            const id = migrationSessionId(adapter, session);
+            if (present.has(id)) {
+                existing += 1;
+                continue;
+            }
+            try {
+                const { header, events } = sessionize(id, adapter.id, session);
+                const handle = await persistence.create(header);
+                try {
+                    await handle.append(events);
+                    await handle.flush();
+                }
+                finally {
+                    await handle.close();
+                }
+                present.add(id);
+                imported += 1;
+            }
+            catch (error) {
+                failed += 1;
+                failures.push(`${session.sourceId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    finally {
+        // The mounted plugin fiber owns the backend's file handles; dispose it
+        // so a CLI process with nothing left to do can exit promptly.
+        await Promise.resolve(fiber.dispose()).catch(() => { });
+    }
+    return { imported, existing, failed, failures };
+}

package/lib/types/dsh-adapter/migrate/picker.d.ts

@@ -0,0 +1,64 @@
+import { type AdapterScanSpec } from './recent-agents.js';
+/** One selectable picker row (rendered by components/MigratePicker.tsx). */
+export interface MigratePickerRow {
+    readonly agentId: string;
+    readonly label: string;
+    readonly count: number;
+    /** Minutes since the newest source activity, when inside the window. */
+    readonly minutesAgo?: number;
+}
+/** Each adapter's name-only scan shape, shared by count() callers and the activity hint. */
+export declare const MIGRATE_SCAN_SPECS: Readonly<Record<string, AdapterScanSpec>>;
+/**
+ * Collect picker rows for every registered adapter: scan count plus a
+ * recent-activity badge when the source was used inside the window. Recent
+ * sources sort first (newest activity at top), cold sources keep registry
+ * order. Sub-second at real-world scale, but still meant for a background
+ * pass — never the render path.
+ */
+export declare function collectMigratePickerRows(nowMs: number): MigratePickerRow[];
+/** One source's import outcome, parsed from the CLI child's stdout. */
+export interface ImportSummary {
+    readonly agentId: string;
+    readonly imported: number;
+    readonly existing: number;
+}
+/**
+ * Parse per-source import counters out of the CLI's report lines
+ * (`[<agentId>] imported 12 · already present 3`). Pure string work so the
+ * TUI's completion notification can carry real numbers (PRD #3) without
+ * re-running any scan.
+ */
+export declare function parseImportSummary(stdout: string): ImportSummary[];
+/**
+ * Classify one `/migrate` command line (the text AFTER the command word) into
+ * the action Chat must take. Pure and registry-driven on purpose: whether a
+ * command is valid must never depend on the picker having been opened first
+ * (`migrateRows` is empty on a fresh mount, which used to make every
+ * `/migrate <agent>` report an unknown source), and the CLI keeps the same
+ * one-source rule (`dsh-tui migrate a b` is a usage error there too).
+ *
+ * @param rawInput - arguments after `/migrate`, e.g. `" claude-code --dry-run"`.
+ * @param knownAgentIds - the adapter registry's ids (see MIGRATION_ADAPTERS).
+ */
+export declare function resolveMigrateCommand(rawInput: string, knownAgentIds: readonly string[]): MigrateCommand;
+/** What one `/migrate` line asks for. */
+export type MigrateCommand = {
+    readonly kind: 'picker';
+} | {
+    readonly kind: 'import';
+    readonly agentId: string;
+    readonly dryRun: boolean;
+} | {
+    readonly kind: 'unknown';
+    readonly agentId: string;
+}
+/** More than one source named: rejected, like the CLI's usage error. */
+ | {
+    readonly kind: 'usage';
+}
+/** `--dry-run` with no source: previewing needs to know what to preview. */
+ | {
+    readonly kind: 'dry-run-needs-source';
+};
+//# sourceMappingURL=picker.d.ts.map

package/lib/types/dsh-adapter/migrate/picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/picker.ts"],"names":[],"mappings":"AAWA,OAAO,EAA4C,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEnG,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,wEAAwE;IACxE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,4FAA4F;AAC5F,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAMxE,CAAA;AAID;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAc1E;AAED,uEAAuE;AACvE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAUlE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CAWxG;AAED,yCAAyC;AACzC,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACxD,wEAAwE;GACtE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE;AAC5B,4EAA4E;GAC1E;IAAE,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAAA"}

package/lib/types/dsh-adapter/migrate/picker.js

@@ -0,0 +1,86 @@
+/**
+ * Data collection for the `/migrate` source picker, plus the command
+ * classifier and the child-report parser.
+ *
+ * Combines the name-only scan count (list mode's fast path) with the
+ * recent-activity detector into the row shape the picker renders. Pure data:
+ * no React, no Cordis — Chat imports these helpers and owns all UI.
+ *
+ * @module dsh-cli/migrate/picker
+ */
+import { MIGRATION_ADAPTERS } from './index.js';
+import { collectActivitySamples, recentAgentsFrom } from './recent-agents.js';
+/** Each adapter's name-only scan shape, shared by count() callers and the activity hint. */
+export const MIGRATE_SCAN_SPECS = {
+    'claude-code': { maxDepth: 3, fileMatch: name => name.endsWith('.jsonl') },
+    codex: { maxDepth: 5, fileMatch: name => name.startsWith('rollout-') && name.endsWith('.jsonl') },
+    omp: { maxDepth: 3, fileMatch: name => name.endsWith('.jsonl') },
+    zcode: { maxDepth: 3, fileMatch: name => name.endsWith('.json') },
+    'grok-build': { maxDepth: 2, fileMatch: name => name === 'chat_history.jsonl' },
+};
+const scanOf = (agentId) => MIGRATE_SCAN_SPECS[agentId];
+/**
+ * Collect picker rows for every registered adapter: scan count plus a
+ * recent-activity badge when the source was used inside the window. Recent
+ * sources sort first (newest activity at top), cold sources keep registry
+ * order. Sub-second at real-world scale, but still meant for a background
+ * pass — never the render path.
+ */
+export function collectMigratePickerRows(nowMs) {
+    const samples = collectActivitySamples(MIGRATION_ADAPTERS, adapter => scanOf(adapter.id));
+    const recent = new Map(recentAgentsFrom(samples, nowMs).map(agent => [agent.agentId, agent.minutesAgo]));
+    const rows = MIGRATION_ADAPTERS.map(adapter => ({
+        agentId: adapter.id,
+        label: adapter.label,
+        count: adapter.count !== undefined ? adapter.count() : adapter.discover().sessions.length,
+        minutesAgo: recent.get(adapter.id),
+    }));
+    return rows.sort((a, b) => {
+        const aRecent = a.minutesAgo ?? Number.MAX_SAFE_INTEGER;
+        const bRecent = b.minutesAgo ?? Number.MAX_SAFE_INTEGER;
+        return aRecent - bRecent;
+    });
+}
+/**
+ * Parse per-source import counters out of the CLI's report lines
+ * (`[<agentId>] imported 12 · already present 3`). Pure string work so the
+ * TUI's completion notification can carry real numbers (PRD #3) without
+ * re-running any scan.
+ */
+export function parseImportSummary(stdout) {
+    const summaries = [];
+    for (const match of stdout.matchAll(/\[([a-z0-9-]+)\] imported (\d+)(?: · already present (\d+))?/gu)) {
+        summaries.push({
+            agentId: match[1],
+            imported: Number(match[2]),
+            existing: match[3] === undefined ? 0 : Number(match[3]),
+        });
+    }
+    return summaries;
+}
+/**
+ * Classify one `/migrate` command line (the text AFTER the command word) into
+ * the action Chat must take. Pure and registry-driven on purpose: whether a
+ * command is valid must never depend on the picker having been opened first
+ * (`migrateRows` is empty on a fresh mount, which used to make every
+ * `/migrate <agent>` report an unknown source), and the CLI keeps the same
+ * one-source rule (`dsh-tui migrate a b` is a usage error there too).
+ *
+ * @param rawInput - arguments after `/migrate`, e.g. `" claude-code --dry-run"`.
+ * @param knownAgentIds - the adapter registry's ids (see MIGRATION_ADAPTERS).
+ */
+export function resolveMigrateCommand(rawInput, knownAgentIds) {
+    const words = rawInput.trim().split(/\s+/u).filter(Boolean);
+    const dryRun = words.includes('--dry-run');
+    const agents = words.filter(word => word !== '--dry-run');
+    // One source per invocation: the CLI rejects a second word, and silently
+    // importing only the first would hide which selection the user asked for.
+    if (agents.length > 1)
+        return { kind: 'usage' };
+    const wanted = agents[0];
+    if (wanted === undefined)
+        return dryRun ? { kind: 'dry-run-needs-source' } : { kind: 'picker' };
+    if (!knownAgentIds.includes(wanted))
+        return { kind: 'unknown', agentId: wanted };
+    return { kind: 'import', agentId: wanted, dryRun };
+}

package/lib/types/dsh-adapter/migrate/recent-agents.d.ts

@@ -0,0 +1,40 @@
+import type { MigrationAdapter } from './types.js';
+/** How recent the newest source activity must be to earn a hint. */
+export declare const RECENT_ACTIVITY_WINDOW_MS: number;
+/** One source's last-activity sample. `newestMtimeMs: null` = no data. */
+export interface ActivitySample {
+    readonly agentId: string;
+    readonly label: string;
+    readonly newestMtimeMs: number | null;
+}
+/** A source that was active inside the window. */
+export interface RecentAgent {
+    readonly agentId: string;
+    readonly label: string;
+    /** Minutes since the newest activity, rounded down (≥ 0). */
+    readonly minutesAgo: number;
+}
+/**
+ * Pure judgment: which samples count as recent, newest first.
+ * @param samples - one per source, `null` mtime = no data (never recent).
+ * @param nowMs - the current epoch milliseconds (injected for testability).
+ * @param windowMs - activity window, default 20 minutes.
+ */
+export declare function recentAgentsFrom(samples: readonly ActivitySample[], nowMs: number, windowMs?: number): RecentAgent[];
+/**
+ * Newest file mtime under one set of roots, name-matched only (the counter's
+ * walk shape — no parsing). Returns null when nothing matches or IO fails;
+ * failures must read as "no data", never as "long ago".
+ */
+export declare function collectNewestMtime(roots: readonly string[], fileMatch: (name: string) => boolean, maxDepth: number): number | null;
+/** The file-name matcher and walk depth an adapter's count() uses. */
+export interface AdapterScanSpec {
+    readonly maxDepth: number;
+    readonly fileMatch: (name: string) => boolean;
+}
+/**
+ * Collect one sample per adapter that can describe its scan; adapters
+ * without count() (no name-only scan shape) are skipped, not guessed.
+ */
+export declare function collectActivitySamples(adapters: readonly MigrationAdapter[], scanOf: (adapter: MigrationAdapter) => AdapterScanSpec | undefined): ActivitySample[];
+//# sourceMappingURL=recent-agents.d.ts.map

package/lib/types/dsh-adapter/migrate/recent-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recent-agents.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/recent-agents.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,oEAAoE;AACpE,eAAO,MAAM,yBAAyB,QAAiB,CAAA;AAEvD,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CACtC;AAED,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAAkC,GAC3C,WAAW,EAAE,CAUf;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EACpC,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,IAAI,CA4Bf;AAED,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAC9C;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,MAAM,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,eAAe,GAAG,SAAS,GACjE,cAAc,EAAE,CAYlB"}