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

package/lib/application.d.ts

@@ -0,0 +1,45 @@
+import { type Renderer } from './renderer.js';
+import { type ActivatableOverlayValue, type DecisionAnswer, type DraftAttachment, type PendingDecision, type OverlayOption, type UiAction, type ViewState } from './state.js';
+export interface ShellBindings {
+    readonly dispatch: (action: UiAction) => void;
+    readonly readState: () => ViewState;
+}
+export interface TerminalShellOptions {
+    readonly accessible?: boolean;
+    readonly beforeExit?: () => Promise<void>;
+    readonly activateOverlay?: (value: ActivatableOverlayValue) => Promise<void>;
+    readonly attach?: (path: string) => Promise<DraftAttachment | undefined>;
+    readonly complete?: (query: string, caret: number) => Promise<readonly OverlayOption[]>;
+    readonly createView?: (bindings: ShellBindings) => Renderer;
+    readonly cyclePermission?: () => Promise<void>;
+    readonly cwd: string;
+    readonly exit: (code: number) => void;
+    readonly externalEdit?: (text: string, cwd: string) => Promise<string>;
+    readonly initialAttachments?: readonly DraftAttachment[];
+    readonly initialCells?: ViewState['cells'];
+    readonly initialHasMore?: boolean;
+    readonly initialPrompts?: ViewState['prompts'];
+    readonly initialRoot?: ViewState['root'];
+    readonly initialToolMode?: ViewState['toolMode'];
+    readonly interrupt?: () => void;
+    readonly inline: boolean;
+    readonly loadHistory?: (rootId: string) => Promise<void>;
+    readonly onReleased?: () => void;
+    readonly pasteImage?: () => Promise<DraftAttachment>;
+    readonly search?: (query: string, rootId: string) => Promise<void>;
+    readonly statusLine?: () => string | undefined;
+    readonly submit?: (text: string, mode: 'next-turn' | 'steer', attachments: readonly DraftAttachment[]) => Promise<void> | void;
+    readonly suspend?: () => Promise<void>;
+    readonly writeError?: (message: string) => void;
+}
+export interface TerminalShell {
+    cancelDecision(id: string): void;
+    dispatch(action: UiAction): void;
+    dispose(): Promise<void>;
+    fail(error: unknown): Promise<void>;
+    readState(): ViewState;
+    requestDecision(decision: PendingDecision): Promise<DecisionAnswer>;
+    start(): void;
+    whenIdle(): Promise<void>;
+}
+export declare function createTerminalShell(options: TerminalShellOptions): TerminalShell;

package/lib/application.js

@@ -0,0 +1,273 @@
+import { createRenderer } from './renderer.js';
+import { runEditor } from './external-editor.js';
+import { initialViewState, reduce, } from './state.js';
+import { createTerminalGuard } from './terminal-guard.js';
+function suspendProcess() {
+    return new Promise((resolve, reject) => {
+        const resumed = () => { resolve(); };
+        process.once('SIGCONT', resumed);
+        try {
+            process.kill(process.pid, 'SIGTSTP');
+        }
+        catch (error) {
+            process.off('SIGCONT', resumed);
+            reject(error);
+        }
+    });
+}
+export function createTerminalShell(options) {
+    let state = initialViewState(options.cwd, options.inline, options.initialRoot, options.initialCells, options.initialPrompts, options.initialHasMore, options.initialAttachments, options.initialToolMode);
+    let accepting = true;
+    let failed = false;
+    let queue = Promise.resolve();
+    const pending = new Map();
+    const bindings = {
+        dispatch: action => { dispatch(action); },
+        readState: () => state,
+    };
+    const renderer = options.createView?.(bindings) ?? createRenderer({
+        ...bindings, ...(options.accessible === undefined ? {} : { accessible: options.accessible }), ...(options.statusLine === undefined ? {} : { statusLine: options.statusLine }), inline: options.inline,
+    });
+    const guard = createTerminalGuard(renderer);
+    const writeError = options.writeError ?? (message => { process.stderr.write(message); });
+    let exitTimer;
+    let released = false;
+    const release = async () => {
+        if (exitTimer !== undefined)
+            clearTimeout(exitTimer);
+        exitTimer = undefined;
+        await guard.dispose();
+        if (released)
+            return;
+        released = true;
+        options.onReleased?.();
+    };
+    async function run(effect) {
+        switch (effect.type) {
+            case 'activate-overlay':
+                if (effect.value.kind === 'open-file') {
+                    const path = effect.value.path;
+                    await guard.withCookedTerminal(() => runEditor(process.env.EDITOR?.trim() || 'vi', path, options.cwd)).catch(error => {
+                        dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                    });
+                }
+                else
+                    await options.activateOverlay?.(effect.value);
+                return;
+            case 'attach': {
+                try {
+                    const attachment = await options.attach?.(effect.path);
+                    if (attachment !== undefined)
+                        dispatch({
+                            type: 'attachment-added', attachment, source: effect.source, text: effect.text,
+                        });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'bell':
+                if (options.accessible !== true)
+                    renderer.bell();
+                return;
+            case 'clipboard-image': {
+                try {
+                    const attachment = await options.pasteImage?.();
+                    if (attachment !== undefined)
+                        dispatch({ type: 'attachment-added', attachment });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'complete': {
+                const items = await options.complete?.(effect.query, effect.caret) ?? [];
+                dispatch({ type: 'completion-ready', options: items, query: effect.query });
+                return;
+            }
+            case 'copy': {
+                const result = renderer.copy(effect.text);
+                if (result === 'too-large')
+                    dispatch({ type: 'runtime-error', message: 'Copy is limited to 64 KiB.' });
+                else if (result === 'unsupported')
+                    dispatch({ type: 'runtime-error', message: 'This terminal does not support OSC 52 copy.' });
+                return;
+            }
+            case 'cycle-permission':
+                await options.cyclePermission?.();
+                return;
+            case 'exit':
+                accepting = false;
+                await options.beforeExit?.();
+                await release();
+                options.exit(0);
+                return;
+            case 'exit-timer':
+                if (exitTimer !== undefined)
+                    clearTimeout(exitTimer);
+                exitTimer = effect.armed ? setTimeout(() => { dispatch({ type: 'disarm-exit' }); }, 1_500) : undefined;
+                return;
+            case 'external-edit': {
+                try {
+                    let edited;
+                    await guard.withCookedTerminal(async () => {
+                        edited = await options.externalEdit?.(effect.text, effect.cwd);
+                    });
+                    if (edited !== undefined)
+                        dispatch({ type: 'composer-set', text: edited });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'interrupt':
+                options.interrupt?.();
+                return;
+            case 'load-history':
+                await options.loadHistory?.(effect.rootId);
+                return;
+            case 'redraw':
+                renderer.render(effect.force);
+                return;
+            case 'reject-decision': {
+                const settlement = pending.get(effect.id);
+                if (settlement === undefined)
+                    return;
+                pending.delete(effect.id);
+                if (settlement.kind === 'approval') {
+                    settlement.resolve(effect.reason === 'terminal' ? 'rejected' : 'cancelled');
+                }
+                else {
+                    const error = new Error(effect.reason === 'terminal'
+                        ? 'the terminal closed before the user answered'
+                        : 'the question was withdrawn before the user answered');
+                    error.name = 'UserQuestionError';
+                    error.code = effect.reason === 'terminal' ? 'ASK_CANCELLED' : 'ASK_ABORTED';
+                    settlement.reject(error);
+                }
+                return;
+            }
+            case 'set-composer':
+                renderer.setComposer(effect.text, effect.cursor);
+                return;
+            case 'search':
+                await options.search?.(effect.query, effect.rootId);
+                return;
+            case 'settle-decision': {
+                const settlement = pending.get(effect.id);
+                if (settlement === undefined)
+                    return;
+                pending.delete(effect.id);
+                settlement.resolve(effect.answer);
+                return;
+            }
+            case 'submit':
+                await options.submit?.(effect.text, effect.mode, effect.attachments);
+                return;
+            case 'suspend':
+                await guard.withCookedTerminal(options.suspend ?? suspendProcess);
+        }
+    }
+    async function fail(error) {
+        if (failed)
+            return;
+        failed = true;
+        accepting = false;
+        renderer.discardSecretComposer();
+        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+        writeError(`dashi: terminal failure\n${detail}\n`);
+        try {
+            const [next, effects] = reduce(state, { type: 'terminal-lost' });
+            state = next;
+            for (const effect of effects)
+                await run(effect);
+            try {
+                await options.beforeExit?.();
+            }
+            catch (cleanupError) {
+                const cleanupDetail = cleanupError instanceof Error
+                    ? cleanupError.stack ?? cleanupError.message
+                    : String(cleanupError);
+                writeError(`dashi: cleanup failure\n${cleanupDetail}\n`);
+            }
+            await release();
+        }
+        finally {
+            options.exit(1);
+        }
+    }
+    function dispatch(action) {
+        if (!accepting)
+            return;
+        const question = state.decisions[0]?.kind === 'question' ? state.decisions[0].questions[state.decisions[0].index] : undefined;
+        if (question?.secret === true && ['decision-submit', 'decision-cancel', 'decision-withdrawn', 'escape', 'terminal-lost'].includes(action.type))
+            renderer.discardSecretComposer();
+        const [next, effects] = reduce(state, action);
+        state = next;
+        if (effects.length === 0)
+            return;
+        queue = queue.then(async () => {
+            for (const effect of effects)
+                await run(effect);
+        }).catch(fail);
+    }
+    async function whenIdle() {
+        for (;;) {
+            const observed = queue;
+            await observed;
+            if (queue === observed)
+                return;
+        }
+    }
+    return {
+        cancelDecision(id) {
+            dispatch({ type: 'decision-withdrawn', id });
+        },
+        dispatch,
+        async dispose() {
+            renderer.discardSecretComposer();
+            const [next, effects] = reduce(state, { type: 'terminal-lost' });
+            state = next;
+            for (const effect of effects)
+                await run(effect);
+            accepting = false;
+            await queue;
+            try {
+                await options.beforeExit?.();
+            }
+            finally {
+                await release();
+            }
+        },
+        fail,
+        readState: () => state,
+        requestDecision(decision) {
+            if (!accepting)
+                return Promise.reject(new Error('dashi terminal is closing'));
+            if (pending.has(decision.id))
+                return Promise.reject(new Error(`duplicate decision ${decision.id}`));
+            let resolve;
+            let reject;
+            const promise = new Promise((accept, decline) => {
+                resolve = accept;
+                reject = decline;
+            });
+            pending.set(decision.id, { kind: decision.kind, reject, resolve });
+            dispatch({ type: 'decision-enqueued', decision });
+            return promise;
+        },
+        start() {
+            try {
+                guard.start();
+                renderer.render(true);
+            }
+            catch (error) {
+                void fail(error);
+            }
+        },
+        whenIdle,
+    };
+}

package/lib/at-trigger.d.ts

@@ -0,0 +1,8 @@
+export interface AtTrigger {
+    readonly end: number;
+    readonly query: string;
+    readonly quoted: boolean;
+    readonly start: number;
+}
+/** Terminal copy of the @ branch in DSH ui-input-trigger core/detect. */
+export declare function detectAtTrigger(draft: string, caret: number): AtTrigger | undefined;

package/lib/at-trigger.js

@@ -0,0 +1,13 @@
+import { activeAtToken } from '@deepseek-ai/dsh-file-reference/grammar';
+/** Terminal copy of the @ branch in DSH ui-input-trigger core/detect. */
+export function detectAtTrigger(draft, caret) {
+    const token = activeAtToken(draft, caret);
+    if (token === undefined)
+        return undefined;
+    return {
+        end: caret,
+        query: token.query,
+        quoted: token.quoted,
+        start: caret - token.prefix.length,
+    };
+}

package/lib/catalogs.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets';
+import type { ModelCatalog, ModelSelection, SessionSummary } from '@deepseek-ai/dsh-api-session-controller';
+import type { SessionSearchHit } from '@deepseek-ai/dsh-session-query';
+import type { Overlay, OverlayOption, RootView } from './state.js';
+/** Build command and skill completion rows for one exact root. */
+export declare function completionOptions(ctx: Context, agent: Agent, input: string, caret?: number, signal?: AbortSignal): Promise<readonly OverlayOption[]>;
+/** Build a filtered view of the skills resolved for one live session. */
+export declare function skillOverlay(ctx: Context, agent: Agent, filter: string, signal?: AbortSignal): Promise<Overlay>;
+/** Build the cold session picker without adopting any candidate. */
+export declare function sessionOverlay(items: readonly SessionSummary[], currentId: string, cwd?: string): Overlay;
+/** Flatten DSH's provider/model/effort catalog into one terminal picker. */
+export declare function modelOverlay(catalog: ModelCatalog, selected?: ModelSelection): Overlay;
+/** Build the preset picker from the native preset service. */
+export declare function permissionOverlay(ctx: Context, agent: Agent): Overlay;
+export declare function sessionStatusLine(ctx: Context, agent: Agent, root: RootView, repo?: string): string;
+/** Read DSH-owned root facts for /status in one projection cut. */
+export declare function statusOverlay(ctx: Context, agent: Agent, root: RootView): Overlay;
+/** Show DSH's heuristic next-request composition without treating it as an exact total. */
+export declare function contextOverlay(ctx: Context, agent: Agent): Overlay;
+/** Read DSH's whole-log token and timing projections without folding session history. */
+export declare function usageOverlay(ctx: Context, agent: Agent): Overlay;
+/** Build the native agent-preset picker; broken presets are visible elsewhere, not selectable here. */
+export declare function agentPresetOverlay(presets: readonly AgentPreset[], current: string, blank: boolean): Overlay;
+/** Build bounded same-cwd prompt-search rows from DSH query hits. */
+export declare function searchOverlay(items: readonly SessionSearchHit[], rootId: string): Overlay;
+export declare function currentModel(ctx: Context, agent: Agent): ModelSelection | undefined;