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

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

@@ -0,0 +1,102 @@
+/**
+ * Codex adapter: `~/.codex/sessions/YYYY/MM/DD/rollout-<id>.jsonl`. File
+ * discovery lives here; the rollout format is parsed by the pure
+ * codex.parse.ts. The browse scan runs the same parser over the rollout's
+ * head: the first session_meta, the first real prompt and the sub-agent
+ * marker all sit there.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/codex
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { parseCodexRollout } from './codex.parse.js';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, runScan, walkFiles, withHead } from './scan-fs.js';
+const isRollout = (name) => name.startsWith('rollout-') && name.endsWith('.jsonl');
+const WALK = { maxDepth: 5, match: isRollout };
+/** The rollout's stable source id: the uuid in its file name. */
+function sourceIdOf(path) {
+    const match = /rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/u.exec(path);
+    // Fallback is the bare file name, never the whole path: the id is the dedupe
+    // key, so an absolute path would make it depend on where the store lives.
+    return match?.[1] ?? basename(path);
+}
+function readOne(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    return parseCodexRollout({ raw, sourceId: sourceIdOf(path) });
+}
+async function summarize({ ref, fp }) {
+    const session = await withHead(ref, fp.size, raw => parseCodexRollout({ raw, sourceId: sourceIdOf(ref) }));
+    if (session === undefined)
+        return null;
+    return {
+        agentId: 'codex',
+        sessionKey: session.sourceId,
+        ref,
+        title: session.title ?? '',
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+export const codexAdapter = {
+    id: 'codex',
+    label: 'Codex',
+    roots: () => [join(homedir(), '.codex', 'sessions')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 5)
+                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() && isRollout(entry.name)) {
+                    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: WALK.maxDepth, fileMatch: WALK.match });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.path, fingerprintOf, options, summarize);
+    },
+    async load(ref) {
+        const raw = await loadText(ref);
+        if (typeof raw !== 'string')
+            return raw;
+        return parseCodexRollout({ raw, sourceId: sourceIdOf(ref) }) ?? { skip: 'not-a-session' };
+    },
+};

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

@@ -0,0 +1,16 @@
+import type { MigrationSession } from '../types.js';
+/** What the adapter knows about a rollout besides its text. */
+export interface CodexRolloutInput {
+    readonly raw: string;
+    /** The rollout's stable source id (the uuid in its file name). */
+    readonly sourceId: string;
+}
+/**
+ * Parse one Codex rollout.
+ * @returns The session, or undefined when it records no cwd or no prompt, or
+ *   is a sub-agent thread (`thread_source: 'subagent'` / `source.subagent`):
+ *   those are spawned by a main session and are not conversations of their
+ *   own. Forks (`forked_from_id` without the sub-agent marker) are kept.
+ */
+export declare function parseCodexRollout(input: CodexRolloutInput): MigrationSession | undefined;
+//# sourceMappingURL=codex.parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/codex.parse.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAA4C,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE7F,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AA4ED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAkKxF"}

package/lib/types/dsh-adapter/migrate/adapters/codex.parse.js

@@ -0,0 +1,289 @@
+/**
+ * Codex rollout parsing (pure): one `rollout-*.jsonl` → one
+ * {@link MigrationSession}.
+ *
+ * Rows are `{ timestamp, type, payload }` envelopes. `session_meta` and
+ * `turn_context` carry metadata (cwd, the model in effect); `response_item`
+ * rows are the model-visible history (OpenAI Responses items); `event_msg`
+ * rows are UI housekeeping that repeats response items and is skipped.
+ *
+ * Codex writes its harness context as user-role blocks: `<environment_context>`,
+ * `<user_instructions>` and other `<…>` blocks, and the
+ * `# AGENTS.md instructions` block that opens most rollouts. Those blocks are
+ * dropped; a user message made only of them opens no turn and never titles
+ * the session.
+ *
+ * Tool traffic: `function_call` / `custom_tool_call` items are tool calls of
+ * the step in progress; their `*_output` items pair back by `call_id`. A
+ * step is one model call: an output ends it, and the next model-produced
+ * item opens the next one. `agent_message` items (a sub-agent's report to
+ * this thread) are inputs of the next model call.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/codex.parse
+ */
+import { isRecord, parseJsonl } from '../parse/jsonl.js';
+import { isInjectedText, unwrapUserText } from '../parse/injection.js';
+import { emptyStats } from '../parse/role-turns.js';
+import { normalizeTitle } from '../parse/title.js';
+import { CallIndex, IMAGE_PLACEHOLDER, closeToolPairs, newStep } from '../parse/tools.js';
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+/** Text of the blocks of one kind (`input_text` / `output_text`). */
+function blocksText(content, want) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (isRecord(block) && block.type === want && typeof block.text === 'string' && block.text !== '')
+            parts.push(block.text);
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Codex-only frames around or beside the human's words: the text blocks that
+ * wrap an attached image, the aborted-turn marker, and shell-command echoes.
+ * Matched as prefixes like the shared table — a user text that merely starts
+ * with `<` (an HTML or XML question) is the human's and must stay.
+ */
+const CODEX_FRAME_PREFIXES = ['<image name=', '</image>', '<turn_aborted>', '<user_shell_command>'];
+function isCodexFrame(text) {
+    const head = text.trimStart();
+    return CODEX_FRAME_PREFIXES.some(prefix => head.startsWith(prefix));
+}
+/** The human part of a user message: harness blocks dropped, images kept as
+ *  placeholders. Returns the text and how many blocks were dropped. */
+function userPrompt(content) {
+    if (!Array.isArray(content))
+        return { text: '', dropped: 0 };
+    const parts = [];
+    let dropped = 0;
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === 'input_image') {
+            parts.push(IMAGE_PLACEHOLDER);
+        }
+        else if (block.type === 'input_text' && typeof block.text === 'string' && block.text.trim() !== '') {
+            if (isCodexFrame(block.text) || isInjectedText(block.text))
+                dropped += 1;
+            else
+                parts.push(block.text);
+        }
+    }
+    return { text: parts.join('\n\n').trim(), dropped };
+}
+/**
+ * Model-facing text of a tool output. Codex writes three shapes: a plain
+ * string, a JSON string `{"output": "...", "metadata": …}` (the inner output
+ * is what the model saw), and an array of `input_text` / `input_image`
+ * blocks (the most common shape in current rollouts).
+ */
+function toolOutputText(output) {
+    if (Array.isArray(output)) {
+        const parts = [];
+        for (const block of output) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === 'input_text' && typeof block.text === 'string')
+                parts.push(block.text);
+            else if (block.type === 'input_image')
+                parts.push(IMAGE_PLACEHOLDER);
+        }
+        return parts.join('\n');
+    }
+    if (isRecord(output))
+        return typeof output.output === 'string' ? output.output : JSON.stringify(output);
+    if (typeof output !== 'string')
+        return '';
+    if (output.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(output);
+            if (isRecord(parsed) && typeof parsed.output === 'string')
+                return parsed.output;
+        }
+        catch {
+            // Plain text that happens to start with a brace.
+        }
+    }
+    return output;
+}
+/**
+ * Parse one Codex rollout.
+ * @returns The session, or undefined when it records no cwd or no prompt, or
+ *   is a sub-agent thread (`thread_source: 'subagent'` / `source.subagent`):
+ *   those are spawned by a main session and are not conversations of their
+ *   own. Forks (`forked_from_id` without the sub-agent marker) are kept.
+ */
+export function parseCodexRollout(input) {
+    const { records, badLines } = parseJsonl(input.raw);
+    const stats = { ...emptyStats(), badLines };
+    let turns = [];
+    let current;
+    let cwd;
+    let startedAt = 0;
+    let model;
+    const calls = new CallIndex();
+    /** The model call in progress; a tool output ends it (see modelStep). */
+    let step;
+    let sawOutput = false;
+    let unnamedCalls = 0;
+    let sawMeta = false;
+    /** Messages from sub-agents waiting for the next model call. */
+    let pendingInputs = [];
+    let subagent = false;
+    /** A compaction summary waiting for the turn that follows the boundary. */
+    let pendingCompaction;
+    const openTurn = (prompt) => {
+        // Sub-agent messages no model call consumed before a new prompt are stale.
+        if (prompt !== '') {
+            stats.filtered += pendingInputs.length;
+            pendingInputs = [];
+        }
+        current = pendingCompaction === undefined ? { prompt, steps: [] } : { prompt, compaction: pendingCompaction, steps: [] };
+        pendingCompaction = undefined;
+        turns.push(current);
+        step = undefined;
+    };
+    /**
+     * The step a model-produced item belongs to. One model call returns its
+     * reasoning, message and tool calls together, then the harness appends the
+     * tool outputs; so the first model item AFTER an output starts the next
+     * call.
+     */
+    const modelStep = () => {
+        if (current === undefined)
+            openTurn('');
+        if (step === undefined || sawOutput) {
+            step = newStep(model);
+            step.inputs = pendingInputs;
+            pendingInputs = [];
+            current.steps.push(step);
+            sawOutput = false;
+        }
+        return step;
+    };
+    const acceptItem = (payload) => {
+        switch (payload.type) {
+            case 'message': {
+                if (payload.role === 'user') {
+                    const { text: prompt, dropped } = userPrompt(payload.content);
+                    stats.filtered += dropped;
+                    if (prompt === '')
+                        return;
+                    openTurn(prompt);
+                }
+                else if (payload.role === 'assistant') {
+                    const text = blocksText(payload.content, 'output_text');
+                    if (text !== '')
+                        modelStep().blocks.push({ type: 'text', text });
+                }
+                return;
+            }
+            case 'agent_message': {
+                // A sub-agent's report delivered to this thread: model-visible input
+                // of the next model call, not a turn of its own.
+                const text = blocksText(payload.content, 'input_text');
+                if (text === '')
+                    return;
+                pendingInputs.push(text);
+                stats.meta += 1;
+                sawOutput = true;
+                return;
+            }
+            case 'reasoning': {
+                // The readable part is the summary; `encrypted_content` is opaque
+                // provider state and is never copied.
+                const text = Array.isArray(payload.summary)
+                    ? payload.summary.filter(isRecord).map(part => part.text).filter((part) => typeof part === 'string' && part.trim() !== '').join('\n\n')
+                    : '';
+                if (text !== '')
+                    modelStep().blocks.push({ type: 'reasoning', text });
+                return;
+            }
+            case 'function_call':
+            case 'custom_tool_call': {
+                const id = typeof payload.call_id === 'string' && payload.call_id !== '' ? payload.call_id : `codex-call-${++unnamedCalls}`;
+                const name = typeof payload.name === 'string' && payload.name !== '' ? payload.name : 'unknown';
+                // function_call arguments are the model's JSON text; a custom tool's
+                // input is free-form (a patch, a JS snippet), kept as one JSON field.
+                const args = payload.type === 'function_call'
+                    ? (typeof payload.arguments === 'string' ? payload.arguments : JSON.stringify(payload.arguments ?? {}))
+                    : JSON.stringify({ input: payload.input ?? '' });
+                const target = modelStep();
+                target.blocks.push({ type: 'tool-call', id, name, arguments: args });
+                calls.register(target);
+                return;
+            }
+            case 'function_call_output':
+            case 'custom_tool_call_output': {
+                if (typeof payload.call_id === 'string')
+                    calls.attach(payload.call_id, toolOutputText(payload.output), false);
+                else
+                    calls.orphans += 1;
+                sawOutput = true;
+            }
+        }
+    };
+    for (const record of records) {
+        const payload = record.payload;
+        if (!isRecord(payload))
+            continue;
+        const time = toMillis(record.timestamp);
+        if (record.type === 'session_meta') {
+            // Only the FIRST meta describes this rollout: a forked or spawned
+            // thread repeats its parent's meta after its own, with the inherited
+            // history.
+            if (!sawMeta) {
+                sawMeta = true;
+                if (typeof payload.cwd === 'string' && payload.cwd !== '')
+                    cwd = payload.cwd;
+                startedAt ||= toMillis(payload.timestamp) || time;
+                subagent = payload.thread_source === 'subagent' || (isRecord(payload.source) && payload.source.subagent !== undefined);
+            }
+            continue;
+        }
+        // Codex records the active model per turn; it applies to the steps after it.
+        // Compaction boundary: Codex folded the window before it into a handoff
+        // summary and kept writing the same rollout. The summary becomes a
+        // native checkpoint in front of the next turn; a turn cut in half by the
+        // boundary continues as a prompt-less turn after it.
+        if (record.type === 'compacted') {
+            const summary = typeof payload.message === 'string' ? payload.message.trim() : '';
+            if (summary !== '') {
+                pendingCompaction = model === undefined ? { summary } : { summary, model };
+                current = undefined;
+                step = undefined;
+            }
+            continue;
+        }
+        // The only event_msg that carries meaning the response items lack: the
+        // turn was interrupted (the recorded reason is always a coarse
+        // 'interrupted').
+        if (record.type === 'event_msg' && payload.type === 'turn_aborted') {
+            if (current !== undefined)
+                current.aborted = true;
+            continue;
+        }
+        if (record.type === 'turn_context') {
+            if (typeof payload.model === 'string' && payload.model !== '')
+                model = payload.model;
+            continue;
+        }
+        if (record.type !== 'response_item')
+            continue;
+        startedAt ||= time;
+        acceptItem(payload);
+    }
+    stats.filtered += pendingInputs.length;
+    if (pendingCompaction !== undefined)
+        turns.push({ prompt: '', compaction: pendingCompaction, steps: [] });
+    turns = turns.filter(turn => turn.prompt !== '' || turn.steps.length > 0 || turn.compaction !== undefined);
+    stats.droppedToolResults = calls.orphans + closeToolPairs(turns);
+    if (subagent || cwd === undefined || !turns.some(turn => turn.prompt !== ''))
+        return undefined;
+    // Codex keeps no title of its own: the first real prompt is the fallback.
+    const firstPrompt = turns.find(turn => turn.prompt !== '')?.prompt;
+    const title = normalizeTitle(firstPrompt === undefined ? undefined : unwrapUserText(firstPrompt));
+    return { sourceId: input.sourceId, cwd, ...(title === '' ? {} : { title }), titleExplicit: false, startedAt, turns, stats };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/grok-build.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAgD,gBAAgB,EAA+D,MAAM,aAAa,CAAA;AA+C9J,eAAO,MAAM,gBAAgB,EAAE,gBAkD9B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/grok-build.js

@@ -0,0 +1,117 @@
+/**
+ * grok-build adapter: `~/.grok/sessions/<encoded-cwd>/<uuid>/` — each session
+ * directory holds a `summary.json` and a `chat_history.jsonl`. Discovery and
+ * the `GROK_HOME` override live here; both files are parsed by the pure
+ * grok-build.parse.ts. A session directory is one browse entry: its
+ * fingerprint combines both files, and its summary comes from the whole
+ * summary.json plus the head of the history.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/grok-build
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parseGrokSession } from './grok-build.parse.js';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, runScan, walkFiles, withHead } from './scan-fs.js';
+const HISTORY_FILE = 'chat_history.jsonl';
+const SUMMARY_FILE = 'summary.json';
+const WALK = { maxDepth: 2, match: name => name === HISTORY_FILE };
+/** One change token for both files of a session directory. */
+async function directoryFingerprint(dir) {
+    const history = await fingerprintOf(join(dir, HISTORY_FILE));
+    const summary = await fingerprintOf(join(dir, SUMMARY_FILE));
+    if (history === undefined || summary === undefined)
+        return undefined;
+    return { mtimeMs: Math.max(history.mtimeMs, summary.mtimeMs), size: history.size + summary.size };
+}
+async function summarize({ ref, fp }) {
+    const summaryJson = await loadText(join(ref, SUMMARY_FILE));
+    const history = await fingerprintOf(join(ref, HISTORY_FILE));
+    if (typeof summaryJson !== 'string' || history === undefined)
+        return null;
+    const session = await withHead(join(ref, HISTORY_FILE), history.size, chatHistory => parseGrokSession({ summaryJson, chatHistory }));
+    if (session === undefined)
+        return null;
+    return {
+        agentId: 'grok-build',
+        sessionKey: session.sourceId,
+        ref,
+        title: session.title ?? '',
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+function readOne(dir) {
+    let summaryJson;
+    let chatHistory;
+    try {
+        summaryJson = readFileSync(join(dir, 'summary.json'), 'utf8');
+        chatHistory = readFileSync(join(dir, 'chat_history.jsonl'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    return parseGrokSession({ summaryJson, chatHistory });
+}
+export const grokBuildAdapter = {
+    id: 'grok-build',
+    label: 'Grok Build',
+    roots() {
+        const grokHome = process.env.GROK_HOME?.trim();
+        return [join(grokHome !== undefined && grokHome !== '' ? grokHome : join(homedir(), '.grok'), 'sessions')];
+    },
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 2)
+                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 === 'chat_history.jsonl') {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(dir);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: WALK.maxDepth, fileMatch: WALK.match });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.dir, directoryFingerprint, options, summarize);
+    },
+    async load(ref) {
+        const summaryJson = await loadText(join(ref, SUMMARY_FILE));
+        if (typeof summaryJson !== 'string')
+            return summaryJson;
+        const chatHistory = await loadText(join(ref, HISTORY_FILE));
+        if (typeof chatHistory !== 'string')
+            return chatHistory;
+        return parseGrokSession({ summaryJson, chatHistory }) ?? { skip: 'not-a-session' };
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/grok-build.parse.d.ts

@@ -0,0 +1,13 @@
+import type { MigrationSession } from '../types.js';
+/** One session directory's two files, as text. */
+export interface GrokSessionInput {
+    readonly summaryJson: string;
+    readonly chatHistory: string;
+}
+/**
+ * Parse one Grok Build session.
+ * @returns The session, or undefined when the summary lacks an id or cwd,
+ *   or the history holds no prompt.
+ */
+export declare function parseGrokSession(input: GrokSessionInput): MigrationSession | undefined;
+//# sourceMappingURL=grok-build.parse.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/grok-build.parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/grok-build.parse.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAgC,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAMjF,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AA2BD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,SAAS,CAwGtF"}