@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/skills.mjs

@@ -0,0 +1,119 @@
+/**
+ * User-invocable skill watch for the `/` completion menu: the in-process
+ * equivalent of the web ui-skill trigger source. Skills are NOT commands —
+ * picking one lands the literal `/name ` text in the input, and submitting
+ * it as a normal prompt lets the host's tool-skill pre-step inject the body
+ * (the only entry point for model-disabled skills). Command descriptors win
+ * on a name collision; see the runner's dispatch.
+ *
+ * @module @deepseek-ai/dsh-code/skills
+ */
+import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+function toRows(skills) {
+    return skills
+        .filter(skill => isUserInvocable(skill))
+        .map(skill => ({
+        name: skill.name,
+        description: skill.description,
+        modelInvocable: skill.invocation.modelInvocable === true,
+    }))
+        .sort((left, right) => left.name < right.name ? -1 : 1);
+}
+/**
+ * Watch the user-invocable skill catalog for one agent's workspace. The first
+ * load starts when the owning agent is known (`setAgent`); `skills/change`
+ * and agent retargets re-read. Read failures keep the last good rows (the
+ * next change notification is the retry surface) — a missing `skills`
+ * service leaves the view permanently empty.
+ * @param ctx - context carrying the `skills` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export function watchSkills(ctx, fallbackCwd) {
+    const skills = ctx.get('skills');
+    let agent;
+    let rows = [];
+    let error;
+    // The agent whose workspace the current rows were last successfully read
+    // from: a failure for an agent that never loaded must clear the rows, not
+    // keep another workspace's catalog answerable in this session.
+    let loadedFor;
+    const listeners = new Set();
+    const reload = () => {
+        const target = agent;
+        if (skills === undefined)
+            return;
+        Promise.resolve().then(() => skills.list(target === undefined
+            // No session exists yet (a bare launch keeps the agent unset until the
+            // first message): read the global skill layer for the working directory.
+            // The upstream contract makes `scope` optional — omitted reads the
+            // global layer alone — so the menu offers skills before a session does.
+            ? { cwd: fallbackCwd }
+            : {
+                cwd: target.session.header.cwd ?? fallbackCwd,
+                scope: target,
+            })).then((summaries) => {
+            // A retarget landed while this catalog was loading: the rows belong to
+            // another agent's workspace and must never overwrite the current view.
+            if (agent !== target)
+                return;
+            const next = toRows(summaries);
+            // Description and invocation-flag edits must surface too: a name-only
+            // comparison silently dropped those change notifications.
+            const unchanged = next.length === rows.length && next.every((row, index) => row.name === rows[index]?.name
+                && row.description === rows[index]?.description
+                && row.modelInvocable === rows[index]?.modelInvocable);
+            rows = next;
+            loadedFor = target;
+            const recovered = error !== undefined;
+            error = undefined;
+            if (unchanged && !recovered)
+                return;
+            for (const listener of listeners)
+                listener();
+        }).catch((cause) => {
+            if (agent !== target)
+                return;
+            // Discovery failure keeps the last good rows for the SAME target (the
+            // next skills/change notification is the retry surface, mirroring the
+            // web directory); a target that never loaded starts from empty rows —
+            // stale rows from a previous workspace must not keep completing here.
+            // The rows array keeps its identity unless the failure text itself
+            // changed: a repeated identical error on the 0.1.5 event storm must not
+            // churn fresh identities into React's update chain.
+            const nextError = cause instanceof Error ? cause.message : String(cause);
+            if (loadedFor !== target)
+                rows = [];
+            const errorChanged = nextError !== error;
+            error = nextError;
+            if (!errorChanged)
+                return;
+            for (const listener of listeners)
+                listener();
+        });
+    };
+    if (skills !== undefined) {
+        ctx.on('skills/change', reload);
+        // Read the global layer immediately: a bare launch has no agent yet, and
+        // waiting for the first skills/change would leave the menu empty.
+        reload();
+    }
+    const view = {
+        get rows() {
+            return rows;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setAgent(next) {
+            agent = next;
+            reload();
+        },
+    };
+    return view;
+}

package/vendor/tui/lib/startup.mjs

@@ -0,0 +1,111 @@
+/**
+ * The interactive terminal app's command-line provider: parses `--resume`,
+ * `--continue`, `--session`, `--mode`, `--theme`, `--image`, an optional
+ * initial prompt, and `--help`, then
+ * publishes {@link TUI_STARTUP_SERVICE} for the runner to consume lazily.
+ * Follows the headless bundle's startup shape (a commander action publishing
+ * a service through {@link parseCmdline}).
+ *
+ * Semantics:
+ * - `--resume <id|prefix>` — continue the persisted session whose id or unique
+ *   id-prefix matches; the TUI replays its transcript and appends to the same
+ *   durable log.
+ * - `--continue` / `-c` — resume the most recently modified persisted session
+ *   whose project directory matches the current working directory.
+ * - `--session <id>` — create a new session under an explicit identity (the
+ *   id must not exist yet).
+ * - `--theme <dark|light|prismatic|rainbow|auto>` — the color palette; auto follows the
+ *   terminal (dark fallback until OSC-11 detection lands).
+ * - no flags — a fresh session with a minted id.
+ *
+ * @module @deepseek-ai/dsh-tui/startup
+ */
+import { Command } from 'commander';
+import { parseCmdline } from '@deepseek-ai/dsh-cmdline';
+import { THEME_NAMES } from './theme.mjs';
+/** Stable Cordis plugin name. */
+export const name = 'tui-startup';
+/** Services required before the invocation can be resolved. */
+export const inject = ['cmdlineArgs'];
+/** Service provided by this plugin and injected by the terminal runner. */
+const TUI_STARTUP_SERVICE = 'tuiStartup';
+/** Pure option policy shared by Commander and tests. */
+export function resolveTuiStartup(options) {
+    const selected = [options.resume !== undefined, options.continue === true, options.session !== undefined];
+    if (selected.filter(Boolean).length > 1)
+        throw new Error('--resume, --continue, and --session are mutually exclusive');
+    if (options.session === '')
+        throw new Error('--session needs an id');
+    if (options.resume === '')
+        throw new Error('--resume needs a session id or id prefix');
+    if (options.mode === '')
+        throw new Error('--mode needs a preset id');
+    if (options.mode !== undefined && (options.resume !== undefined || options.continue === true)) {
+        throw new Error('--mode applies only to a new session; it cannot be combined with --resume or --continue');
+    }
+    if (options.theme !== undefined && !THEME_NAMES.includes(options.theme)) {
+        throw new Error(`--theme must be one of: ${THEME_NAMES.join(', ')}`);
+    }
+    const input = {
+        ...(options.theme === undefined ? {} : { theme: options.theme }),
+        ...(options.prompt === undefined || options.prompt.trim() === '' ? {} : { prompt: options.prompt.trim() }),
+        ...(options.images === undefined || options.images.length === 0 ? {} : { images: [...options.images] }),
+    };
+    return options.resume !== undefined
+        ? { kind: 'resume', sessionId: options.resume, ...input }
+        : options.continue === true
+            ? { kind: 'latest', ...input }
+            : options.session !== undefined
+                ? { kind: 'named', sessionId: options.session, ...options.mode === undefined ? {} : { mode: options.mode }, ...input }
+                : { kind: 'fresh', ...options.mode === undefined ? {} : { mode: options.mode }, ...input };
+}
+/**
+ * This app's command: the launcher's flags this app owns, its description,
+ * and its help text.
+ * @returns a fresh program, so one process can parse more than once (tests).
+ */
+function tuiCommand() {
+    return new Command()
+        .name('dsh --profile cli')
+        .description('DeepSeek Harness CLI core: the interactive coding terminal.')
+        .helpOption('-h, --help', 'show this help')
+        .option('-r, --resume <session>', 'resume the persisted session with this id (or unique id prefix)')
+        .option('-c, --continue', 'resume the most recent persisted session for this working directory')
+        .option('--session <id>', 'create a new session under this explicit id')
+        .option('--mode <preset>', 'agent preset for a newly created session')
+        .option('--theme <name>', 'color theme: dark (default), light, prismatic, rainbow, or auto')
+        .option('-i, --image <path>', 'attach an image to the initial prompt (repeatable)', (path, paths) => [...paths, path], [])
+        .argument('[prompt...]', 'initial prompt; sends immediately after startup')
+        .addHelpText('after', `
+Examples:
+  dsh --profile cli                       fresh session, minted id
+  dsh --profile cli --resume abc123       resume session by id prefix
+  dsh --profile cli --continue            resume the latest local session
+  dsh --profile cli --mode minimal        fresh session using the minimal preset
+  dsh --profile cli --theme light         light palette for bright terminals
+  dsh --profile cli "explain this repo"   start and send an initial prompt
+  dsh --profile cli -i diagram.png "review this diagram"
+`);
+}
+/**
+ * Parse the invocation and publish the startup service. Mutual exclusions are
+ * usage errors rejected from the action before anything is provided.
+ * @param ctx - plugin context carrying the command line and exit request.
+ */
+export function apply(ctx) {
+    const program = tuiCommand();
+    program.action((prompt) => {
+        const options = { ...program.opts(), prompt: prompt.join(' ') };
+        let startup;
+        try {
+            startup = resolveTuiStartup(options);
+        }
+        catch (error) {
+            program.error(`error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (startup === undefined)
+            return;
+        ctx.provide(TUI_STARTUP_SERVICE, { startup });
+    });
+    parseCmdline(ctx, program);
+}

package/vendor/tui/lib/store.mjs

@@ -0,0 +1,129 @@
+/**
+ * Observable transcript store: folds session events into the projection view
+ * and notifies subscribers. The renderer subscribes through
+ * `useSyncExternalStore`; the runner owns event feeding.
+ *
+ * Folding runs on the same mutable replay accumulator the persisted-log
+ * path uses (`replayProjectEvent`: id-indexed row updates, in-place
+ * appends), so a live structural event costs O(1) entry work regardless of
+ * transcript length — the copy-on-write fold rebuilt the whole entries
+ * array per event, making a growing session quadratic. An immutable
+ * `TranscriptView` snapshot is materialized only when a changed view is
+ * READ (once per rendered frame under the notification throttle, never per
+ * event), and every snapshot copies its arrays, so a view already handed
+ * out never observes later folds.
+ *
+ * Notification coalescing: the fold stays synchronous — `getView()` always
+ * returns the latest state the moment `apply` returns — but listener
+ * notification is frame-throttled (~16ms) and deduplicated. The zai/GLM
+ * adapter delivers tokens as a sustained stream of sub-millisecond,
+ * microtask-spaced bursts: per-burst notification renders at microtask
+ * cadence, which chained SyncLane `useSyncExternalStore` rerenders past
+ * React's nested-update limit ("Maximum update depth exceeded"), while a
+ * bare `setImmediate` merges a whole macrotask turn's bursts into one
+ * chunky repaint (streaming text visibly staggers). The frame budget gives
+ * both: an event ≥16ms after the last paint notifies via `setImmediate`
+ * (sub-millisecond latency for sparse/first tokens), and anything denser
+ * defers to the next 16ms boundary — a 60fps render cap that also breaks
+ * the nesting chain by construction.
+ *
+ * @module @deepseek-ai/dsh-tui/store
+ */
+import { applyAssistantStreamChunk, clearAssistantStream, createReplayAccumulator, replayProjectEvent, snapshotReplayView, } from './render/projection.mjs';
+/** Render frame budget: the notification cadence's upper bound. */
+const NOTIFY_FRAME_MS = 16;
+/**
+ * Create one transcript store, optionally seeded with replayed history. The
+ * seed folds synchronously BEFORE the first render, so a resumed session
+ * paints its full transcript on mount (no live `session/event` fires for
+ * constructor seeds — the store's `session/event` feed only carries new
+ * appends).
+ * @param replay - persisted events in `seq` order (e.g. a resumed session's
+ * constructor seed); folded once and never re-notified.
+ * @returns the store the runner feeds and the renderer subscribes to.
+ */
+export function createTranscriptStore(replay) {
+    let acc = createReplayAccumulator();
+    for (const event of replay ?? [])
+        replayProjectEvent(acc, event);
+    let view = snapshotReplayView(acc);
+    let dirty = false;
+    const listeners = new Set();
+    let scheduled = false;
+    let lastNotifyAt = 0;
+    // Live attempt → `turn:step` key: chunk frames name only their attempt, so
+    // the start frame's turn/step anchor is remembered until the end frame
+    // retires the attempt. A replacement attempt (new start frame) overwrites
+    // the entry; committed settlements already cleared the tails it replaces.
+    const attemptKeys = new Map();
+    const notify = () => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        const wait = NOTIFY_FRAME_MS - (Date.now() - lastNotifyAt);
+        const dispatch = () => {
+            scheduled = false;
+            lastNotifyAt = Date.now();
+            for (const listener of listeners) {
+                listener();
+            }
+        };
+        // Sparse streams paint with setImmediate latency; a denser burst defers
+        // to the next frame boundary instead of repainting per microtask batch.
+        if (wait <= 0)
+            setImmediate(dispatch);
+        else
+            setTimeout(dispatch, wait);
+    };
+    return {
+        getView: () => {
+            if (dirty) {
+                view = snapshotReplayView(acc);
+                dirty = false;
+            }
+            return view;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        apply(event) {
+            if (!replayProjectEvent(acc, event))
+                return;
+            dirty = true;
+            notify();
+        },
+        applyStreamFrame(frame) {
+            if (frame.type === 'start') {
+                attemptKeys.set(frame.attemptId, `${frame.turn}:${frame.step}`);
+                return;
+            }
+            if (frame.type === 'chunk') {
+                const key = attemptKeys.get(frame.attemptId);
+                if (key === undefined)
+                    return;
+                if (!applyAssistantStreamChunk(acc, key, frame.time, frame.chunk))
+                    return;
+                dirty = true;
+                notify();
+                return;
+            }
+            // End frame: committed settlements arrive as durable events before
+            // their end frame and already cleared the tails; an abandoned attempt
+            // has no settlement, so its partial tail is dropped here.
+            attemptKeys.delete(frame.attemptId);
+            if (frame.outcome.kind === 'abandoned' && clearAssistantStream(acc)) {
+                dirty = true;
+                notify();
+            }
+        },
+        reset() {
+            acc = createReplayAccumulator();
+            attemptKeys.clear();
+            dirty = true;
+            notify();
+        },
+    };
+}

package/vendor/tui/lib/subagents.mjs

@@ -0,0 +1,200 @@
+/**
+ * Live subagent activity feed: a bounded, display-only projection of CHILD
+ * session events. The transcript store folds only the root session (the
+ * durable truth this TUI renders); subagent conversations are their own
+ * sessions, and before this module their events were dropped entirely —
+ * a running subagent was invisible until its parent tool call settled.
+ *
+ * This is NOT a second transcript: each child folds to ONE row (label,
+ * running state, bounded last-activity text), capped at
+ * {@link MAX_SUBAGENT_ROWS}. The cap is a display budget, not a fan-out
+ * limit: a new running child evicts the OLDEST settled row when one
+ * exists, and while every row is busy the newcomer waits off-screen — but
+ * the observed-session total (getTotalSeen) keeps counting, so status
+ * totals never under-report the fan-out. Rows are advisory display
+ * state, rebuilt from live events; nothing here persists or replays.
+ * Notification is coalesced
+ * by the same ~16ms frame throttle as the transcript store (per-burst
+ * microtask notify chained SyncLane rerenders past React's nested update
+ * limit; a bare macrotask merge repaints a whole turn's bursts at once).
+ *
+ * @module @deepseek-ai/dsh-code/subagents
+ */
+/** Hard row cap: overflow evicts the oldest settled row; a fully busy feed waits. */
+export const MAX_SUBAGENT_ROWS = 8;
+/** Render frame budget: the notification cadence's upper bound. */
+const NOTIFY_FRAME_MS = 16;
+/** Bounded last-activity text (plain characters, display-sliced later). */
+const MAX_ACTIVITY_CHARS = 80;
+/** Single-line bounded preview of an assembled message's text content. */
+function messagePreview(content) {
+    if (!Array.isArray(content))
+        return 'replied';
+    const texts = [];
+    for (const block of content) {
+        if (texts.join(' ').length >= MAX_ACTIVITY_CHARS)
+            break;
+        if (typeof block === 'object' && block !== null) {
+            const { type, text } = block;
+            if (type === 'text' && typeof text === 'string' && text !== '')
+                texts.push(text);
+        }
+    }
+    const joined = texts.join(' ').replace(/\s+/gu, ' ').trim();
+    return joined === '' ? 'replied' : bound(joined);
+}
+/** Bound one activity string to the display budget. */
+function bound(text) {
+    const flat = text.replace(/\s+/gu, ' ').trim();
+    return flat.length > MAX_ACTIVITY_CHARS ? `${flat.slice(0, MAX_ACTIVITY_CHARS - 1)}…` : flat;
+}
+/**
+ * Fold one child-session event into its feed row (pure).
+ * Unknown event kinds leave the row untouched.
+ * @param previous - the row's current state, when any.
+ * @param sessionId - the child session id.
+ * @param event - the child session event.
+ * @returns the next row state.
+ */
+export function foldSubagentRow(previous, sessionId, event) {
+    const base = previous ?? {
+        id: sessionId,
+        label: `agent ${sessionId.slice(-6)}`,
+        state: 'running',
+        activity: 'starting…',
+        updatedAt: event.time,
+    };
+    const data = event.data;
+    switch (event.type) {
+        case 'session/title': {
+            const title = data['title'];
+            const text = typeof title === 'string' && title.trim() !== '' ? title : undefined;
+            return text === undefined || text === base.label ? base : { ...base, label: bound(text), updatedAt: event.time };
+        }
+        case 'request/header':
+            return { ...base, state: 'running', activity: 'working…', updatedAt: event.time };
+        case 'user/message':
+            return { ...base, state: 'running', activity: 'prompted', updatedAt: event.time };
+        case 'assistant/attempt':
+            // Durable logs are settlement-only since session-log v2; an attempt
+            // landing without a surface message means the model is retrying or
+            // recovered from a stream error, so the child stays running.
+            return { ...base, state: 'running', activity: 'thinking…', updatedAt: event.time };
+        case 'subagent/catalog': {
+            // Parent-owned durable discovery fact (0.1.5): the catalog names the
+            // child's mode (one-shot vs continuable) and its authored label — the
+            // most semantic label the row can carry. It is a discovery fact, not a
+            // lifecycle signal: a fresh row starts idle, but a late delivery never
+            // regresses a row that already ran or finished. An unchanged fact keeps
+            // the row's identity (the no-op discipline of the default branch), so
+            // repeated deliveries never churn the snapshot array.
+            const mode = event.data.mode === 'continuable' ? 'continuable' : 'one-shot';
+            const label = event.data.label !== undefined && event.data.label.trim() !== '' ? bound(event.data.label) : undefined;
+            const nextLabel = label === undefined ? base.label : label;
+            const activity = label === undefined ? `catalog · ${mode}` : `catalog · ${mode} · ${label}`;
+            const state = previous === undefined ? 'idle' : base.state;
+            if (nextLabel === base.label && state === base.state && activity === base.activity)
+                return base;
+            return { ...base, state, label: nextLabel, activity, updatedAt: event.time };
+        }
+        case 'assistant/message':
+            return { ...base, state: 'idle', activity: messagePreview(data['message'] === undefined ? undefined : data['message'].content), updatedAt: event.time };
+        case 'tool/call': {
+            const name = typeof data['name'] === 'string' ? data['name'] : 'tool';
+            return { ...base, state: 'running', activity: `tool ${name}`, updatedAt: event.time };
+        }
+        case 'tool/result':
+            return { ...base, state: 'running', activity: 'tool done', updatedAt: event.time };
+        case 'turn/start':
+            return { ...base, state: 'running', activity: base.activity === 'starting…' ? 'working…' : base.activity, updatedAt: event.time };
+        case 'turn/end':
+            return { ...base, state: 'done', activity: 'finished', updatedAt: event.time };
+        default:
+            // Unknown kinds leave the row untouched (identity-stable: a no-op
+            // fold must not churn the snapshot array).
+            return base;
+    }
+}
+/**
+ * Create one subagent feed. `apply` folds a child event (the caller gates
+ * which sessions are children); `reset` clears on a session switch. Row
+ * order is first-seen; the snapshot array is frozen and only replaced when
+ * a row actually changed.
+ * @returns the mutable feed handle plus its `SubagentFeedView`.
+ */
+export function createSubagentFeed() {
+    let rows = Object.freeze([]);
+    const seen = new Set();
+    const listeners = new Set();
+    let scheduled = false;
+    let lastNotifyAt = 0;
+    const notify = () => {
+        if (scheduled)
+            return;
+        scheduled = true;
+        const wait = NOTIFY_FRAME_MS - (Date.now() - lastNotifyAt);
+        const dispatch = () => {
+            scheduled = false;
+            lastNotifyAt = Date.now();
+            for (const listener of listeners)
+                listener();
+        };
+        if (wait <= 0)
+            setImmediate(dispatch);
+        else
+            setTimeout(dispatch, wait);
+    };
+    return {
+        apply(sessionId, event) {
+            const index = rows.findIndex(row => row.id === sessionId);
+            const previous = index === -1 ? undefined : rows[index];
+            const next = foldSubagentRow(previous, sessionId, event);
+            if (index !== -1) {
+                if (next === previous)
+                    return;
+                rows = Object.freeze(rows.map((row, at) => at === index ? next : row));
+                notify();
+                return;
+            }
+            // A child this feed has not shown yet: the honest total grows even
+            // when every row is busy; admission then prefers evicting the OLDEST
+            // settled row (idle or done — both are non-running) so a new running
+            // agent never waits on one that already settled.
+            const counted = !seen.has(sessionId);
+            if (counted)
+                seen.add(sessionId);
+            if (rows.length >= MAX_SUBAGENT_ROWS) {
+                const evict = rows.findIndex(row => row.state !== 'running');
+                if (evict === -1) {
+                    if (counted)
+                        notify();
+                    return;
+                }
+                rows = Object.freeze([...rows.slice(0, evict), next, ...rows.slice(evict + 1)]);
+            }
+            else {
+                rows = Object.freeze([...rows, next]);
+            }
+            notify();
+        },
+        reset() {
+            seen.clear();
+            if (rows.length === 0)
+                return;
+            rows = Object.freeze([]);
+            notify();
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        getSnapshot() {
+            return rows;
+        },
+        getTotalSeen() {
+            return seen.size;
+        },
+    };
+}