@antst/dashi 0.1.0-alpha.20 → 0.1.0-alpha.21

package/lib/rewind.js

@@ -0,0 +1,114 @@
+export function latestCompletedTurn(events) {
+    const end = events.filter((event) => event.type === 'turn/end' && event.data.reason.kind !== 'interrupted').at(-1);
+    const start = events.filter((event) => event.type === 'turn/start').at(-1);
+    return { open: start !== undefined && (end === undefined || start.seq > end.seq),
+        ...(end === undefined ? {} : { atSeq: end.seq, turn: end.data.turn }) };
+}
+/** Return only a selection that DSH recorded for the source session. */
+export function rewindModelSelection(projection) {
+    return projection?.next ?? projection?.lastUsed ?? undefined;
+}
+/** Return the text of a direct human message, excluding injected context. */
+export function humanPrompt(event) {
+    if (event.type !== 'user/message' || event.data.source.kind !== 'user')
+        return undefined;
+    const text = event.data.content
+        .filter(block => block.type === 'text')
+        .map(block => block.text).join('');
+    return text === '' ? undefined : text;
+}
+function shellInput(message) {
+    if (message.source.kind !== 'plugin' || message.source.plugin !== 'dashi'
+        || message.source.form !== 'notice')
+        return undefined;
+    const first = message.content.find(block => block.type === 'text')?.text.split(/\r?\n/u)[0];
+    return first?.startsWith('$ ') === true ? `!${first.slice(2)}` : undefined;
+}
+/** Recover one composer input from DSH's durable log. */
+export function historyInput(event) {
+    const prompt = humanPrompt(event);
+    if (prompt !== undefined)
+        return prompt;
+    if (event.type === 'command/run' && event.data.args !== undefined) {
+        return `/${event.data.name}${event.data.args}`;
+    }
+    if (event.type !== 'agent/inbox/spliced')
+        return undefined;
+    return event.data.inserted.map(shellInput).find(input => input !== undefined);
+}
+export function historyInputs(events) {
+    return events.flatMap(event => historyInput(event) ?? []);
+}
+/** Derive each recalled input and its controller-valid preceding-turn cut. */
+export function rewindBoundaries(events) {
+    const boundaries = [];
+    let previousEnd;
+    let openTurn;
+    let prompted = false;
+    for (const event of events) {
+        if (event.type === 'turn/start') {
+            openTurn = event.data.turn;
+            prompted = false;
+        }
+        else if (event.type === 'turn/end' && event.data.reason.kind !== 'interrupted') {
+            previousEnd = event;
+            openTurn = undefined;
+            prompted = false;
+        }
+        const prompt = historyInput(event);
+        if (prompt === undefined)
+            continue;
+        const human = humanPrompt(event) !== undefined;
+        boundaries.push({
+            ...(previousEnd === undefined ? {} : { atSeq: previousEnd.seq }),
+            label: `${prompt.replaceAll(/\s+/gu, ' ')}${human && prompted ? ' · mid-turn' : ''}`,
+            prompt,
+        });
+        if (human && openTurn !== undefined)
+            prompted = true;
+    }
+    return boundaries;
+}
+export function rewindOverlay(events, roller) {
+    const boundaries = rewindBoundaries(events);
+    const trailing = latestCompletedTurn(events);
+    return {
+        cursor: Math.max(0, boundaries.length - 1),
+        kind: 'list',
+        options: boundaries.map(boundary => ({
+            label: boundary.label,
+            value: {
+                kind: 'rewind-boundary', prompt: boundary.prompt, roller,
+                ...(boundary.atSeq === undefined ? {} : { atSeq: boundary.atSeq }),
+            },
+        })),
+        purpose: 'rewind',
+        title: `Rewind to a prompt${trailing.open ? ' · trailing turn open; completed boundaries only' : ''}`,
+    };
+}
+export function rewindActionOverlay(boundary) {
+    const base = {
+        prompt: boundary.prompt,
+        ...(boundary.atSeq === undefined ? {} : { atSeq: boundary.atSeq }),
+    };
+    const options = [
+        ...(boundary.roller ? [{
+                label: 'Restore code and conversation', value: { ...base, kind: 'rewind', mode: 'both' },
+            }] : []),
+        { label: 'Restore conversation', value: { ...base, kind: 'rewind', mode: 'conversation' } },
+        ...(boundary.roller ? [{
+                label: 'Restore code', value: { ...base, kind: 'rewind', mode: 'code' },
+            }] : []),
+        { label: 'Never mind', value: { kind: 'open-rewind' } },
+    ];
+    return { cursor: 0, kind: 'list', options, purpose: 'rewind-action', title: boundary.prompt };
+}
+/** Read a fork's durable source boundary without storing lineage separately. */
+export function inheritedTurn(events, inheritedCount) {
+    for (let index = Math.min(inheritedCount, events.length) - 1; index >= 0; index--) {
+        const event = events[index];
+        if (event?.type === 'turn/end')
+            return event.data.turn;
+    }
+    return undefined;
+}

package/lib/session-export.d.ts

@@ -0,0 +1,3 @@
+import type { TerminalCell } from './state.js';
+/** Format the existing terminal projection as a portable Markdown transcript. */
+export declare function markdownTranscript(sessionId: string, cwd: string, title: string | undefined, cells: readonly TerminalCell[]): string;

package/lib/session-export.js

@@ -0,0 +1,27 @@
+function heading(kind) {
+    return kind === 'user' ? 'User'
+        : kind === 'assistant' ? 'Assistant'
+            : kind === 'reasoning' ? 'Reasoning'
+                : kind[0]?.toUpperCase() + kind.slice(1);
+}
+function body(cell) {
+    const parts = [cell.text];
+    if (cell.detail !== undefined && cell.detail !== cell.text)
+        parts.push(cell.detail);
+    if (cell.tool?.body !== undefined)
+        parts.push(cell.tool.body);
+    for (const diff of cell.tool?.diffs ?? []) {
+        parts.push(`${diff.path} (+${String(diff.added)} -${String(diff.removed)})`, ...diff.lines);
+    }
+    return parts.filter(Boolean).join('\n\n');
+}
+/** Format the existing terminal projection as a portable Markdown transcript. */
+export function markdownTranscript(sessionId, cwd, title, cells) {
+    const sections = cells.filter(cell => cell.pending !== true).map(cell => `## ${heading(cell.kind)}\n\n${body(cell)}`);
+    return [
+        `# ${title ?? 'Untitled DSH session'}`,
+        `Session: \`${sessionId}\`  `,
+        `Working directory: \`${cwd}\``,
+        ...sections,
+    ].join('\n\n').trimEnd() + '\n';
+}

package/lib/session-list.d.ts

@@ -0,0 +1,15 @@
+import type { SessionSummary } from '@deepseek-ai/dsh-api-session-controller';
+export interface SessionListOptions {
+    readonly all: boolean;
+    readonly cwd?: string;
+    readonly json: boolean;
+}
+/** Parse only the profile-provided `sessions list` grammar. */
+export declare function parseSessionListArgs(args: readonly string[]): SessionListOptions | undefined;
+export declare function sessionTitle(item: SessionSummary): string | undefined;
+export declare function isSessionId(value: string): boolean;
+/** Resolve one native title exactly, then by case-insensitive substring. */
+export declare function sessionMatches(items: readonly SessionSummary[], value: string, cwd?: string): readonly SessionSummary[];
+export declare function sessionNotFound(value: string): Error;
+/** Format ordinary roots from DSH's native catalog without adding live-process facts. */
+export declare function formatSessionList(items: readonly SessionSummary[], cwd: string | undefined, json: boolean): string;

package/lib/session-list.js

@@ -0,0 +1,65 @@
+/** Parse only the profile-provided `sessions list` grammar. */
+export function parseSessionListArgs(args) {
+    if (args[0] !== 'sessions' || args[1] !== 'list')
+        return undefined;
+    let all = false;
+    let cwd;
+    let json = false;
+    for (let index = 2; index < args.length; index++) {
+        const argument = args[index];
+        if (argument === '--all' && !all && cwd === undefined)
+            all = true;
+        else if (argument === '--json' && !json)
+            json = true;
+        else if (argument === '--cwd' && cwd === undefined && !all) {
+            cwd = args[++index];
+            if (cwd === undefined || cwd === '')
+                return undefined;
+        }
+        else
+            return undefined;
+    }
+    return { all, json, ...(cwd === undefined ? {} : { cwd }) };
+}
+export function sessionTitle(item) {
+    const title = item.projections?.values.title;
+    return typeof title === 'string' && title !== '' ? title : undefined;
+}
+export function isSessionId(value) {
+    return /^session-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/iu.test(value);
+}
+/** Resolve one native title exactly, then by case-insensitive substring. */
+export function sessionMatches(items, value, cwd) {
+    const scoped = items.filter(item => item.origin === undefined && (cwd === undefined || item.cwd === cwd));
+    const exact = scoped.filter(item => sessionTitle(item) === value);
+    return exact.length > 0 ? exact : scoped.filter(item => sessionTitle(item)?.toLocaleLowerCase().includes(value.toLocaleLowerCase()));
+}
+export function sessionNotFound(value) {
+    return new Error(`no session named ${JSON.stringify(value)}`);
+}
+function terminalJson(value, space) {
+    return JSON.stringify(value, undefined, space).replace(/[\u0080-\u009f]/gu, character => `\\u${(character.codePointAt(0) ?? 0).toString(16).padStart(4, '0')}`);
+}
+function terminalField(value) {
+    return terminalJson(value).slice(1, -1);
+}
+/** Format ordinary roots from DSH's native catalog without adding live-process facts. */
+export function formatSessionList(items, cwd, json) {
+    const sessions = items
+        .filter(item => item.origin === undefined && (cwd === undefined || item.cwd === cwd))
+        .map(item => ({
+        sessionId: String(item.sessionId),
+        title: sessionTitle(item) ?? null,
+        ...(item.cwd === undefined ? {} : { cwd: item.cwd }),
+        updatedAt: new Date(item.updatedAt).toISOString(),
+    }));
+    if (json)
+        return terminalJson({ version: 1, sessions }, 2);
+    const records = sessions.map(item => [
+        terminalField(item.sessionId), terminalField(item.title ?? 'Untitled'),
+        terminalField(item.cwd ?? 'cwd unavailable'), item.updatedAt,
+    ]);
+    const headers = ['UUID', 'TITLE', 'CWD', 'UPDATED'];
+    const widths = headers.map((header, index) => Math.max(header.length, ...records.map(row => row[index]?.length ?? 0)));
+    return [headers, ...records].map(row => row.map((value, index) => index === row.length - 1 ? value : value.padEnd(widths[index] ?? 0)).join('  ')).join('\n');
+}

package/lib/session-runtime.d.ts

@@ -0,0 +1,49 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ActivatableOverlayValue, DecisionAnswer, DraftAttachment, OverlayOption, PendingDecision, RootView, SendMode, TerminalCell, UiAction } from './state.js';
+import type { TuiRoot } from './tui-root.js';
+export interface RootLaunchOptions {
+    readonly agentPreset?: string;
+    readonly continue: boolean;
+    readonly appendSystemPrompt?: string;
+    readonly cwd: string;
+    readonly effort?: string;
+    readonly forkSession: boolean;
+    readonly name?: string;
+    readonly images?: readonly string[];
+    readonly model?: string;
+    readonly permission?: string;
+    readonly prompt?: string;
+    readonly provider?: string;
+    readonly tools?: readonly string[];
+    readonly disallowedTools?: readonly string[];
+    readonly resume?: string;
+    readonly sessionId?: string;
+    readonly systemPrompt?: string;
+}
+export declare class LaunchArgumentError extends Error {
+}
+export interface SessionRuntime {
+    readonly initialAttachments: readonly DraftAttachment[];
+    readonly initialCells: readonly TerminalCell[];
+    readonly initialHasMore: boolean;
+    readonly initialPrompts: readonly string[];
+    readonly root: RootView;
+    readonly statusLine: string;
+    readonly summary: string;
+    activate(value: ActivatableOverlayValue): Promise<void>;
+    attach(path: string): Promise<DraftAttachment | undefined>;
+    complete(query: string, caret: number): Promise<readonly OverlayOption[]>;
+    cyclePermission(): Promise<void>;
+    interrupt(): void;
+    loadHistory(rootId: string): Promise<void>;
+    search(query: string, rootId: string): Promise<void>;
+    shutdown(): Promise<void>;
+    start(): void;
+    submit(text: string, mode: SendMode, attachments: readonly DraftAttachment[]): Promise<void>;
+}
+export interface DecisionBindings {
+    readonly cancel: (id: string) => void;
+    readonly request: (decision: PendingDecision) => Promise<DecisionAnswer>;
+}
+/** Create or resume the exact current root and own its replaceable terminal binding. */
+export declare function createSessionRuntime(ctx: Context, options: RootLaunchOptions, tuiRoot: TuiRoot, dispatch: (action: UiAction) => void, decisions?: DecisionBindings): Promise<SessionRuntime>;