@deepseek-harness-tui/dsh-tui 0.11.1 → 0.12.0

package/lib/types/dsh-adapter/migrate/import-one.js

@@ -0,0 +1,133 @@
+/**
+ * Import ONE foreign conversation through the host's persistence service —
+ * the session screen's "select to start" path (the CLI batch keeps
+ * importSessions, which mounts its own backend).
+ *
+ * Order is chosen so a failure never leaves a half-written log that the
+ * next click would take for "already imported":
+ *   1. the deterministic id already exists → open it, nothing is written;
+ *   2. the working directory must exist (resuming into a missing cwd fails
+ *      later and less clearly);
+ *   3. the whole conversation is parsed and sessionized in memory;
+ *   4. only then create → append → flush → close; a write failure removes
+ *      what was written, best effort — except a create that lost to a
+ *      concurrent writer of the same deterministic id: that log is the
+ *      winner's, and the import simply opens it.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/import-one
+ */
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { existsSync } from 'node:fs';
+import { deleteSessionLog } from '../compat/index.js';
+import { sessionize } from './sessionize.js';
+import { migrationUuid } from './uuid.js';
+/** Deterministic DSH session id of one foreign conversation (same as /migrate). */
+export function foreignSessionId(agentId, sourceId) {
+    return SessionId(migrationUuid(`${agentId}:${sourceId}`));
+}
+/**
+ * Write one sessionized conversation (the CLI batch path; the single import
+ * phases create/append itself so a create race stays out of its cleanup).
+ * Both paths produce byte-identical logs: sessionize is deterministic in
+ * the id and the events.
+ */
+export async function writeImportedSession(persistence, id, agentId, session) {
+    const { header, events } = sessionize(id, agentId, session);
+    const handle = await persistence.create(header);
+    try {
+        await handle.append(events);
+        await handle.flush();
+    }
+    finally {
+        // A close failure must not mask an append/flush error, nor (on the
+        // single-import path) turn a completed write into a cleanup candidate.
+        await handle.close().catch(() => { });
+    }
+}
+async function exists(persistence, id) {
+    if (persistence.stat !== undefined)
+        return (await persistence.stat(id)) !== undefined;
+    return (await persistence.list()).some(entry => entry.header.id === id);
+}
+/**
+ * Import one conversation unless it is already present.
+ * @returns ready (with whether it was written now), cwd-missing, or failed.
+ */
+export async function importForeignSession(persistence, adapter, request, deps = {}) {
+    const cwdExists = deps.cwdExists ?? existsSync;
+    let id = foreignSessionId(adapter.id, request.sessionKey);
+    if (await exists(persistence, id))
+        return { kind: 'ready', sessionId: id, created: false };
+    if (request.cwd !== '' && !cwdExists(request.cwd))
+        return { kind: 'cwd-missing', cwd: request.cwd };
+    if (adapter.load === undefined)
+        return { kind: 'failed', reason: 'not-a-session' };
+    const loaded = await adapter.load(request.ref);
+    if ('skip' in loaded)
+        return { kind: 'failed', reason: loaded.skip };
+    if (!cwdExists(loaded.cwd))
+        return { kind: 'cwd-missing', cwd: loaded.cwd };
+    // The artifact may have changed identity since it was listed; the id always
+    // follows what is actually imported, exactly as /migrate derives it.
+    if (loaded.sourceId !== request.sessionKey) {
+        id = foreignSessionId(adapter.id, loaded.sourceId);
+        if (await exists(persistence, id))
+            return { kind: 'ready', sessionId: id, created: false };
+    }
+    // create is its own phase: losing the race for the deterministic id to a
+    // concurrent writer (the /migrate batch, another TUI) means the log that is
+    // already there is theirs — complete or becoming complete — and never this
+    // failure's to delete. Any other create failure wrote nothing at all.
+    const { header, events } = sessionize(id, adapter.id, loaded);
+    let handle;
+    try {
+        handle = await persistence.create(header);
+    }
+    catch (error) {
+        if (await exists(persistence, id))
+            return { kind: 'ready', sessionId: id, created: false };
+        return { kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) };
+    }
+    try {
+        await handle.append(events);
+        await handle.flush();
+    }
+    catch (error) {
+        await handle.close().catch(() => { });
+        (deps.discard ?? deleteSessionLog)(id);
+        return { kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) };
+    }
+    await handle.close().catch(() => { });
+    return { kind: 'ready', sessionId: id, created: true };
+}
+/**
+ * One importer per host: a second request for a conversation already being
+ * imported joins the running one instead of starting another write.
+ *
+ * Requests are keyed by the conversation's IDENTITY (the id it will be written
+ * under), not by its locator: two artifacts of one source can carry the same
+ * source id (a Claude session continued in another project directory), and
+ * two concurrent writes to one id would have the loser's cleanup delete the
+ * winner's log. The locator is the key only when the identity is not known yet.
+ */
+export function createForeignImporter(persistence, deps = {}) {
+    const inFlight = new Map();
+    return {
+        import(adapter, request) {
+            const key = request.sessionKey !== ''
+                ? `id:${foreignSessionId(adapter.id, request.sessionKey)}`
+                : `ref:${adapter.id}|${request.ref}`;
+            const running = inFlight.get(key);
+            if (running !== undefined)
+                return running;
+            const service = persistence();
+            if (service === undefined)
+                return Promise.resolve({ kind: 'failed', reason: 'write-failed', detail: 'session persistence unavailable' });
+            const started = importForeignSession(service, adapter, request, deps)
+                .catch((error) => ({ kind: 'failed', reason: 'write-failed', detail: error instanceof Error ? error.message : String(error) }))
+                .finally(() => inFlight.delete(key));
+            inFlight.set(key, started);
+            return started;
+        },
+    };
+}

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

@@ -0,0 +1,35 @@
+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, resolved exactly
+ * like the persistence backend's root (cordis.patch.yml): an explicit
+ * `DSH_TUI_SESSION_ROOT` first, then `$DSH_HOME/sessions`, then
+ * `~/.dsh/sessions`. Resolving it any other way would let the CLI import into
+ * a store the TUI (and the source tabs) never read.
+ */
+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;AAEpE,eAAO,MAAM,kBAAkB,EAAE,SAAS,gBAAgB,EAMzD,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAK3C;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,CAkCpB"}

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

@@ -0,0 +1,107 @@
+/**
+ * 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 @deepseek-harness-tui/dsh-tui/migrate
+ */
+import { Context } from '@deepseek-ai/cordis';
+import JsonlSessionPersistence from '@deepseek-ai/dsh-session-persistence-jsonl';
+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 { foreignSessionId, writeImportedSession } from './import-one.js';
+export const MIGRATION_ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    ompAdapter,
+    zcodeAdapter,
+    grokBuildAdapter,
+];
+/**
+ * The default import target: the shared DSH session store, resolved exactly
+ * like the persistence backend's root (cordis.patch.yml): an explicit
+ * `DSH_TUI_SESSION_ROOT` first, then `$DSH_HOME/sessions`, then
+ * `~/.dsh/sessions`. Resolving it any other way would let the CLI import into
+ * a store the TUI (and the source tabs) never read.
+ */
+export function defaultSessionRoot() {
+    const override = process.env.DSH_TUI_SESSION_ROOT?.trim();
+    if (override)
+        return override;
+    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 foreignSessionId(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 {
+                await writeImportedSession(persistence, id, adapter.id, session);
+                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/parse/injection.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Harness-injection recognition and user-text unwrapping.
+ *
+ * Every foreign agent writes machine text into its user role: environment
+ * blocks, instruction files, reminders, slash-command echoes. None of it is
+ * the human's words, so it must never open a turn or become a title. The
+ * other half is wrappers the harness puts AROUND real words (`<user_query>`,
+ * pasted-content envelopes, interrupt notices): those keep the words and
+ * drop the frame.
+ *
+ * Every scan here is linear: tag bodies are located with indexOf, never a
+ * lazy `[\s\S]*?` regex, whose per-unclosed-tag rescans a hostile single
+ * line can turn quadratic (deep-review m1 on the first claude adapter).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/injection
+ */
+/**
+ * Line-start markers of injected blocks, matched case-insensitively after
+ * trimming. A user text that STARTS with one of these is harness output.
+ */
+export declare const INJECTED_PREFIXES: readonly string[];
+/** Whether a user text is harness injection rather than the human's words. */
+export declare function isInjectedText(text: string): boolean;
+/** Strip inline `<system-reminder>` blocks (Claude Code puts them anywhere). */
+export declare function stripSystemReminders(text: string): string;
+/** Whether a user text is an interrupt notice (the previous turn was cut short). */
+export declare function isInterruptNotice(text: string): boolean;
+/**
+ * Reduce a user text to the human's own words.
+ *
+ * - `<user_query>` wrappers keep only their bodies — this also covers the
+ *   interrupt / "sent a message while you were working" notices, whose
+ *   human part is always inside a `<user_query>`;
+ * - a notice without a `<user_query>` keeps what follows the notice line;
+ * - pasted-content envelopes lose their tags but keep the pasted text.
+ *
+ * @returns The unwrapped, trimmed text ('' when nothing human remains).
+ */
+export declare function unwrapUserText(text: string): string;
+//# sourceMappingURL=injection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injection.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/injection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAa9C,CAAA;AAID,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGpD;AAsBD,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGzD;AAyBD,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAYnD"}

package/lib/types/dsh-adapter/migrate/parse/injection.js

@@ -0,0 +1,127 @@
+/**
+ * Harness-injection recognition and user-text unwrapping.
+ *
+ * Every foreign agent writes machine text into its user role: environment
+ * blocks, instruction files, reminders, slash-command echoes. None of it is
+ * the human's words, so it must never open a turn or become a title. The
+ * other half is wrappers the harness puts AROUND real words (`<user_query>`,
+ * pasted-content envelopes, interrupt notices): those keep the words and
+ * drop the frame.
+ *
+ * Every scan here is linear: tag bodies are located with indexOf, never a
+ * lazy `[\s\S]*?` regex, whose per-unclosed-tag rescans a hostile single
+ * line can turn quadratic (deep-review m1 on the first claude adapter).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/injection
+ */
+/**
+ * Line-start markers of injected blocks, matched case-insensitively after
+ * trimming. A user text that STARTS with one of these is harness output.
+ */
+export const INJECTED_PREFIXES = [
+    '<environment_context>',
+    '<system-reminder>',
+    '<user_instructions>',
+    '<local-command-caveat>',
+    '<local-command-stdout>',
+    '<command-name>',
+    '<command-message>',
+    '<task-notification>',
+    '<permissions>',
+    '<user_info>',
+    '# AGENTS.md instructions',
+    '# Context from my IDE setup:',
+];
+const LOWER_PREFIXES = INJECTED_PREFIXES.map(prefix => prefix.toLowerCase());
+/** Whether a user text is harness injection rather than the human's words. */
+export function isInjectedText(text) {
+    const head = text.trimStart().slice(0, 64).toLowerCase();
+    return LOWER_PREFIXES.some(prefix => head.startsWith(prefix));
+}
+/**
+ * Remove every `<tag>…</tag>` span. An opening tag with no closing tag
+ * swallows the rest of the text (the block was cut off, nothing after it is
+ * the user's).
+ */
+function removeTagSpans(text, tag) {
+    const open = `<${tag}>`;
+    const close = `</${tag}>`;
+    let out = '';
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf(open, from);
+        if (start === -1)
+            return out + text.slice(from);
+        out += text.slice(from, start);
+        const end = text.indexOf(close, start + open.length);
+        if (end === -1)
+            return out;
+        from = end + close.length;
+    }
+}
+/** Strip inline `<system-reminder>` blocks (Claude Code puts them anywhere). */
+export function stripSystemReminders(text) {
+    if (!text.includes('<system-reminder>'))
+        return text.trim();
+    return removeTagSpans(text, 'system-reminder').trim();
+}
+/** Bodies of every `<user_query>` block; an unclosed tag runs to the end. */
+function userQueryBodies(text) {
+    const open = '<user_query>';
+    const close = '</user_query>';
+    const bodies = [];
+    let from = 0;
+    for (;;) {
+        const start = text.indexOf(open, from);
+        if (start === -1)
+            return bodies;
+        const bodyStart = start + open.length;
+        const end = text.indexOf(close, bodyStart);
+        bodies.push(text.slice(bodyStart, end === -1 ? undefined : end).trim());
+        if (end === -1)
+            return bodies;
+        from = end + close.length;
+    }
+}
+/** Notices a harness prepends when the user speaks over a running turn. */
+const INTERJECTION_PREFIXES = [
+    'The user interrupted the previous turn:',
+    'The user sent a message while you were working:',
+];
+/** Whether a user text is an interrupt notice (the previous turn was cut short). */
+export function isInterruptNotice(text) {
+    return text.trimStart().startsWith(INTERJECTION_PREFIXES[0]);
+}
+/** Drop `<pasted_content …>` / `</pasted_content …>` tags, keeping the pasted body. */
+function stripPastedTags(text) {
+    if (!text.includes('pasted_content'))
+        return text;
+    return text.replace(/<\/?pasted_content(?:\s[^<>]*)?>/gu, ' ').replace(/[ \t]{2,}/gu, ' ');
+}
+/**
+ * Reduce a user text to the human's own words.
+ *
+ * - `<user_query>` wrappers keep only their bodies — this also covers the
+ *   interrupt / "sent a message while you were working" notices, whose
+ *   human part is always inside a `<user_query>`;
+ * - a notice without a `<user_query>` keeps what follows the notice line;
+ * - pasted-content envelopes lose their tags but keep the pasted text.
+ *
+ * @returns The unwrapped, trimmed text ('' when nothing human remains).
+ */
+export function unwrapUserText(text) {
+    const lead = text.trimStart();
+    if (!text.includes('<') && !lead.startsWith('The user '))
+        return text.trim();
+    let body = text;
+    const queries = userQueryBodies(body);
+    if (queries.length > 0) {
+        body = queries.join('\n\n');
+    }
+    else {
+        const notice = INTERJECTION_PREFIXES.find(prefix => lead.startsWith(prefix));
+        if (notice !== undefined)
+            body = lead.slice(notice.length);
+    }
+    return stripPastedTags(body).trim();
+}

package/lib/types/dsh-adapter/migrate/parse/jsonl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Line-delimited JSON reading shared by every migration source.
+ *
+ * Foreign stores are read defensively: a malformed line costs that line,
+ * never the file. Legal JSON that is not a record (`null`, scalars, arrays)
+ * is skipped silently — it is well-formed, just not a row — while text that
+ * fails to parse is COUNTED, so a truncated or corrupted source shows up in
+ * the import stats instead of vanishing quietly.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/jsonl
+ */
+/** A decoded JSON object row. */
+export type JsonRecord = Record<string, unknown>;
+/** Narrow an unknown JSON value to an object record (rejects `null` and arrays). */
+export declare function isRecord(value: unknown): value is JsonRecord;
+/** Parsed rows of one JSONL document. */
+export interface JsonlRows {
+    readonly records: readonly JsonRecord[];
+    /** Non-empty lines that were not valid JSON. */
+    readonly badLines: number;
+}
+/**
+ * Split and decode a JSONL document.
+ * @param raw - Whole file text; `\n` and `\r\n` line ends are both accepted.
+ * @returns Every object row in file order plus the count of unparseable lines.
+ */
+export declare function parseJsonl(raw: string): JsonlRows;
+//# sourceMappingURL=jsonl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/jsonl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,iCAAiC;AACjC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEhD,oFAAoF;AACpF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAE5D;AAED,yCAAyC;AACzC,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;IACvC,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAgBjD"}

package/lib/types/dsh-adapter/migrate/parse/jsonl.js

@@ -0,0 +1,40 @@
+/**
+ * Line-delimited JSON reading shared by every migration source.
+ *
+ * Foreign stores are read defensively: a malformed line costs that line,
+ * never the file. Legal JSON that is not a record (`null`, scalars, arrays)
+ * is skipped silently — it is well-formed, just not a row — while text that
+ * fails to parse is COUNTED, so a truncated or corrupted source shows up in
+ * the import stats instead of vanishing quietly.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/jsonl
+ */
+/** Narrow an unknown JSON value to an object record (rejects `null` and arrays). */
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Split and decode a JSONL document.
+ * @param raw - Whole file text; `\n` and `\r\n` line ends are both accepted.
+ * @returns Every object row in file order plus the count of unparseable lines.
+ */
+export function parseJsonl(raw) {
+    const records = [];
+    let badLines = 0;
+    for (const line of raw.split('\n')) {
+        const text = line.endsWith('\r') ? line.slice(0, -1) : line;
+        if (text.trim() === '')
+            continue;
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            badLines += 1;
+            continue;
+        }
+        if (isRecord(value))
+            records.push(value);
+    }
+    return { records, badLines };
+}

package/lib/types/dsh-adapter/migrate/parse/role-turns.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Flat role list → imported turns, plus the shared size measure.
+ *
+ * The first migration adapters normalized every source into an alternating
+ * user/assistant list. {@link fromRoleTurns} folds that list into the turn
+ * model mechanically — a user message opens a turn, every assistant message
+ * after it is one step — so an adapter that still produces the list imports
+ * exactly as it did before the turn model existed.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/role-turns
+ */
+import type { ImportStats, ImportTurn, MigrationSession, MigrationTurn } from '../types.js';
+/** Counters for a source that reports nothing it left out. */
+export declare function emptyStats(): ImportStats;
+/**
+ * Fold a role list into turns.
+ *
+ * A list that starts with an assistant message opens a turn with no prompt
+ * (the source lost its head); a trailing user message is a step-less turn.
+ */
+export declare function fromRoleTurns(list: readonly MigrationTurn[]): ImportTurn[];
+/**
+ * How many conversation messages an imported session carries: prompts,
+ * mid-turn inputs and assistant steps (tool results are not counted). For a
+ * role-list source this equals the list length.
+ */
+export declare function messageCount(session: Pick<MigrationSession, 'turns'>): number;
+//# sourceMappingURL=role-turns.d.ts.map

package/lib/types/dsh-adapter/migrate/parse/role-turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role-turns.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/role-turns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAe,WAAW,EAAE,UAAU,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGxG,8DAA8D;AAC9D,wBAAgB,UAAU,IAAI,WAAW,CAExC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,UAAU,EAAE,CAqB1E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,OAAO,CAAC,GAAG,MAAM,CAO7E"}

package/lib/types/dsh-adapter/migrate/parse/role-turns.js

@@ -0,0 +1,50 @@
+import { newStep } from './tools.js';
+/** Counters for a source that reports nothing it left out. */
+export function emptyStats() {
+    return { badLines: 0, droppedToolResults: 0, filtered: 0, meta: 0 };
+}
+/**
+ * Fold a role list into turns.
+ *
+ * A list that starts with an assistant message opens a turn with no prompt
+ * (the source lost its head); a trailing user message is a step-less turn.
+ */
+export function fromRoleTurns(list) {
+    const turns = [];
+    let current;
+    for (const message of list) {
+        if (message.role === 'user') {
+            current = { prompt: message.text, steps: [] };
+            turns.push(current);
+            continue;
+        }
+        if (current === undefined) {
+            current = { prompt: '', steps: [] };
+            turns.push(current);
+        }
+        const step = newStep(message.model);
+        const blocks = [];
+        if (message.reasoning !== undefined && message.reasoning !== '')
+            blocks.push({ type: 'reasoning', text: message.reasoning });
+        if (message.text !== '')
+            blocks.push({ type: 'text', text: message.text });
+        step.blocks = blocks;
+        current.steps.push(step);
+    }
+    return turns;
+}
+/**
+ * How many conversation messages an imported session carries: prompts,
+ * mid-turn inputs and assistant steps (tool results are not counted). For a
+ * role-list source this equals the list length.
+ */
+export function messageCount(session) {
+    let count = 0;
+    for (const turn of session.turns) {
+        if (turn.prompt !== '')
+            count += 1;
+        for (const step of turn.steps)
+            count += 1 + step.inputs.length;
+    }
+    return count;
+}

package/lib/types/dsh-adapter/migrate/parse/title.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Title normalization shared by every migration source.
+ *
+ * One rule for all sources, so the same conversation shows the same title
+ * whichever entry imported it: trim, collapse inner whitespace (a title is
+ * one line), cap at {@link TITLE_MAX_CHARS} code points with a trailing `…`.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/title
+ */
+/** Longest normalized title, in code points (the ellipsis included). */
+export declare const TITLE_MAX_CHARS = 80;
+/**
+ * Normalize a candidate title.
+ * @param text - Raw title or first prompt.
+ * @returns The one-line title, or '' when the input is blank.
+ */
+export declare function normalizeTitle(text: string | undefined): string;
+//# sourceMappingURL=title.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"title.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/parse/title.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wEAAwE;AACxE,eAAO,MAAM,eAAe,KAAK,CAAA;AAIjC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQ/D"}

package/lib/types/dsh-adapter/migrate/parse/title.js

@@ -0,0 +1,29 @@
+/**
+ * Title normalization shared by every migration source.
+ *
+ * One rule for all sources, so the same conversation shows the same title
+ * whichever entry imported it: trim, collapse inner whitespace (a title is
+ * one line), cap at {@link TITLE_MAX_CHARS} code points with a trailing `…`.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/parse/title
+ */
+/** Longest normalized title, in code points (the ellipsis included). */
+export const TITLE_MAX_CHARS = 80;
+const ELLIPSIS = '…';
+/**
+ * Normalize a candidate title.
+ * @param text - Raw title or first prompt.
+ * @returns The one-line title, or '' when the input is blank.
+ */
+export function normalizeTitle(text) {
+    if (text === undefined)
+        return '';
+    const flat = text.trim().replace(/\s+/gu, ' ');
+    if (flat === '')
+        return '';
+    // Code points, not UTF-16 units: a cut must never split a surrogate pair.
+    const points = Array.from(flat);
+    if (points.length <= TITLE_MAX_CHARS)
+        return flat;
+    return `${points.slice(0, TITLE_MAX_CHARS - ELLIPSIS.length).join('').trimEnd()}${ELLIPSIS}`;
+}