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

package/lib/catalogs.js

@@ -1,308 +0,0 @@
-import { readdir, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { formatFileMention } from '@deepseek-ai/dsh-file-reference/grammar';
-import { isUserInvocable } from '@deepseek-ai/dsh-skill';
-import { detectAtTrigger } from './at-trigger.js';
-import { pluginCompletionQuery, slashCompletionQuery } from './completion-trigger.js';
-import { isImagePath } from './image-input.js';
-import { sessionTitle } from './session-list.js';
-function matchRank(name, query) {
-    const candidate = name.toLocaleLowerCase();
-    const needle = query.toLocaleLowerCase();
-    return candidate.startsWith(needle) ? 0 : candidate.includes(needle) ? 1 : 2;
-}
-function selectedModel(ctx, agent) {
-    const selection = ctx.sessionProjections.snapshot(agent.session, ['modelSelection']).values.modelSelection;
-    return selection?.next ?? selection?.lastUsed ?? undefined;
-}
-/** Build command and skill completion rows for one exact root. */
-export async function completionOptions(ctx, agent, input, caret = input.length, signal) {
-    const plugin = pluginCompletionQuery(input, caret);
-    if (plugin !== undefined) {
-        let candidates = ['add', 'remove', 'update', 'outdated', 'list', 'why', 'exec', 'licenses'];
-        if (plugin.command !== undefined) {
-            const profile = fileURLToPath(new URL('.', ctx.baseUrl));
-            if (plugin.command === 'exec') {
-                candidates = (await readdir(join(profile, 'node_modules', '.bin')).catch((error) => error.code === 'ENOENT' ? [] : Promise.reject(error))).sort();
-            }
-            else {
-                const manifest = JSON.parse(await readFile(join(profile, 'package.json'), 'utf8'));
-                candidates = Object.keys(manifest.dependencies ?? {}).sort();
-            }
-        }
-        return candidates.filter(name => matchRank(name, plugin.query) < 2).map(name => ({
-            group: 'Commands', label: name,
-            value: { kind: 'insert', text: `/plugin ${plugin.command === undefined ? '' : `${plugin.command} `}${name} ` },
-        }));
-    }
-    const at = detectAtTrigger(input, caret);
-    if (at !== undefined) {
-        const service = ctx.get('fileReferences');
-        if (service === undefined)
-            return [];
-        const candidates = await service.list(agent, at.query, signal ?? new AbortController().signal);
-        return candidates.flatMap((candidate) => {
-            const mention = formatFileMention(candidate, at.quoted);
-            if (mention === undefined)
-                return [];
-            const text = `${input.slice(0, at.start)}${mention}${input.slice(at.end)}`;
-            const image = candidate.kind === 'file' && isImagePath(candidate.path);
-            return [{
-                    detail: candidate.kind === 'directory' ? 'directory' : image ? 'attach image' : 'file',
-                    group: 'Files',
-                    label: `${candidate.path}${candidate.kind === 'directory' ? '/' : ''}`,
-                    value: image
-                        ? {
-                            kind: 'attach',
-                            path: candidate.path,
-                            source: input,
-                            text: `${input.slice(0, at.start)}${input.slice(at.end)}`,
-                        }
-                        : { kind: 'insert', text },
-                }];
-        });
-    }
-    const query = slashCompletionQuery(input);
-    if (query === undefined)
-        return [];
-    const commands = ctx.commands.list(agent)
-        .filter(command => matchRank(command.name, query) < 2)
-        .sort((left, right) => matchRank(left.name, query) - matchRank(right.name, query)
-        || left.name.localeCompare(right.name))
-        .map(command => ({
-        detail: command.description,
-        group: 'Commands',
-        label: `/${command.name}${command.input?.hint === undefined ? '' : ` ${command.input.hint}`}`,
-        ...(command.input?.hint === undefined ? { submitOnEnter: true } : {}),
-        value: { kind: 'insert', text: `/${command.name} ` },
-    }));
-    const skills = (await ctx.skills.list({ cwd: agent.session.header.cwd, scope: agent, signal }))
-        .filter(isUserInvocable)
-        .filter(skill => matchRank(skill.name, query) < 2)
-        .sort((left, right) => matchRank(left.name, query) - matchRank(right.name, query)
-        || left.name.localeCompare(right.name))
-        .map(skill => ({
-        detail: skill.description,
-        group: 'Skills',
-        label: `/${skill.name}`,
-        value: { kind: 'insert', text: `/${skill.name} ` },
-    }));
-    return [...commands, ...skills];
-}
-/** Build a filtered view of the skills resolved for one live session. */
-export async function skillOverlay(ctx, agent, filter, signal) {
-    const lookup = { cwd: agent.session.header.cwd, scope: agent, signal };
-    const needle = filter.trim().toLocaleLowerCase();
-    const skills = (await ctx.skills.list(lookup)).filter(skill => needle === ''
-        || skill.name.toLocaleLowerCase().includes(needle)
-        || skill.description.toLocaleLowerCase().includes(needle));
-    const definitions = await Promise.all(skills.map(skill => ctx.skills.get(skill.name, lookup)));
-    return {
-        cursor: 0, kind: 'list', purpose: 'skills', title: needle === '' ? 'Skills' : `Skills · ${filter.trim()}`,
-        options: skills.map((skill, index) => ({
-            detail: `${skill.description} · user ${skill.invocation.userInvocable ? 'yes' : 'no'} · model ${skill.invocation.modelInvocable ? 'yes' : 'no'} · source ${skill.source} · provider ${skill.provider} · path ${definitions[index]?.path ?? 'unavailable'}`,
-            label: `/${skill.name}`,
-            value: { kind: 'insert', text: `/${skill.name} ` },
-        })),
-    };
-}
-/** Build the cold session picker without adopting any candidate. */
-export function sessionOverlay(items, currentId, cwd) {
-    return {
-        cursor: 0,
-        kind: 'list',
-        options: items.filter(item => item.origin === undefined && (cwd === undefined || item.cwd === cwd)).map(item => ({
-            active: String(item.sessionId) === currentId,
-            detail: `${item.cwd ?? 'cwd unavailable'} · ${new Date(item.updatedAt).toISOString()}`,
-            label: `${sessionTitle(item) ?? 'Untitled'} · ${String(item.sessionId)}`,
-            value: { kind: 'resume', sessionId: String(item.sessionId) },
-        })),
-        purpose: 'resume',
-        title: 'Resume session',
-    };
-}
-/** Flatten DSH's provider/model/effort catalog into one terminal picker. */
-export function modelOverlay(catalog, selected) {
-    const options = [];
-    for (const group of catalog.groups) {
-        for (const model of group.models) {
-            const efforts = model.reasoning?.efforts ?? [];
-            if (efforts.length === 0) {
-                options.push({
-                    active: selected?.provider === group.id && selected.model === model.id,
-                    label: `${group.name} · ${model.name}`,
-                    value: { kind: 'model', model: model.id, provider: group.id },
-                    ...(model.description === undefined ? {} : { detail: model.description }),
-                });
-                continue;
-            }
-            for (const effort of efforts) {
-                options.push({
-                    active: selected?.provider === group.id && selected.model === model.id
-                        && (selected.reasoningEffort ?? model.reasoning?.defaultEffort) === effort.id,
-                    label: `${group.name} · ${model.name} · ${effort.name}`,
-                    value: { kind: 'model', effort: effort.id, model: model.id, provider: group.id },
-                    ...(effort.description ?? model.description) === undefined
-                        ? {} : { detail: effort.description ?? model.description },
-                });
-            }
-        }
-    }
-    return { cursor: Math.max(0, options.findIndex(option => option.active === true)), kind: 'list', options, purpose: 'model', title: 'Model' };
-}
-/** Build the preset picker from the native preset service. */
-export function permissionOverlay(ctx, agent) {
-    const current = ctx.permissionPresets.current(agent.session);
-    const options = ctx.permissionPresets.names.map((preset) => {
-        const option = ctx.permissionPresets.optionOf(preset);
-        const spec = ctx.permissionPresets.resolve(preset);
-        return {
-            active: preset === current,
-            confirmDetail: [`Sandbox: ${spec.sandbox}`, `Approval: ${spec.approval}`],
-            danger: spec.approval === 'never',
-            label: option.name,
-            value: { kind: 'permission', preset },
-            ...(option.description === undefined ? {} : { detail: option.description }),
-        };
-    });
-    return {
-        cursor: Math.max(0, options.findIndex(option => option.active)),
-        kind: 'list', options, purpose: 'permission', title: 'Permission preset',
-    };
-}
-function number(value) {
-    return typeof value === 'number' ? value.toLocaleString('en-US') : 'unavailable';
-}
-function milliseconds(value) {
-    return typeof value === 'number' ? `${number(value)} ms` : 'unavailable';
-}
-function compactTokens(value) {
-    return Intl.NumberFormat('en-US', { maximumFractionDigits: 1, notation: 'compact' }).format(value).replace('K', 'k');
-}
-export function sessionStatusLine(ctx, agent, root, repo) {
-    const { modelSelection, permissions, tokenUsage, contextPressure } = ctx.sessionProjections
-        .snapshot(agent.session, ['modelSelection', 'permissions', 'tokenUsage', 'contextPressure']).values;
-    const model = modelSelection?.next ?? modelSelection?.lastUsed;
-    const input = tokenUsage === undefined ? 0 : tokenUsage.uncachedInputTokens + tokenUsage.cacheReadTokens + tokenUsage.cacheWriteTokens;
-    const total = input + (tokenUsage?.outputTokens ?? 0);
-    const used = contextPressure?.projectedTokens ?? contextPressure?.pressureTokens;
-    const context = used === undefined ? undefined
-        : contextPressure?.contextWindow === undefined ? `ctx ${compactTokens(used)}`
-            : `ctx ${compactTokens(used)}/${compactTokens(contextPressure.contextWindow)} ${String(Math.min(100, Math.round(used / contextPressure.contextWindow * 100)))}%`;
-    const agents = root.subagents?.filter(item => item.state === 'running').length ?? 0;
-    const jobs = root.jobs?.filter(item => item.status === 'running' || item.status === 'stopping').length ?? 0;
-    return [
-        model?.model ?? root.model,
-        ...(model?.reasoningEffort === undefined ? [] : [model.reasoningEffort]),
-        permissions?.currentValue ?? root.permission ?? 'unknown',
-        ...(context === undefined ? [] : [context]),
-        ...(input === 0 ? [] : [`cache ${String(Math.min(tokenUsage?.cacheReadTokens === input ? 100 : 99, Math.round((tokenUsage?.cacheReadTokens ?? 0) / input * 100)))}%`]),
-        ...(tokenUsage === undefined ? [] : [`${compactTokens(total)} tok`]),
-        ...(agents === 0 ? [] : [`${String(agents)} agents`]),
-        ...(jobs === 0 ? [] : [`${String(jobs)} jobs`]),
-        ...(root.title === undefined ? [] : [root.title]),
-        ...(repo === undefined ? [] : [repo]),
-    ].join(' · ');
-}
-/** Read DSH-owned root facts for /status in one projection cut. */
-export function statusOverlay(ctx, agent, root) {
-    const values = ctx.sessionProjections.snapshot(agent.session, [
-        'modelSelection', 'permissions', 'tokenUsage', 'contextPressure', 'contextBreakdown',
-    ]).values;
-    const model = values.modelSelection?.next ?? values.modelSelection?.lastUsed;
-    const usage = values.tokenUsage;
-    const pressure = values.contextPressure;
-    const breakdown = values.contextBreakdown;
-    return {
-        kind: 'info',
-        lines: [
-            `UUID: ${root.id}`,
-            `Title: ${root.title ?? 'Untitled'}`,
-            `Cwd: ${root.cwd}`,
-            root.parent === undefined
-                ? 'Lineage: root session'
-                : `Lineage: forked from ${root.parent} at turn ${String(root.parentTurn ?? 'unknown')}`,
-            `Model: ${model === null || model === undefined ? root.model : `${model.provider}/${model.model}`}`,
-            `Effort: ${model?.reasoningEffort ?? root.effort ?? 'default'}`,
-            `Permission: ${ctx.permissionPresets.current(agent.session)}`,
-            `Usage: input ${number(usage?.uncachedInputTokens)} · output ${number(usage?.outputTokens)} · cache read ${number(usage?.cacheReadTokens)} · cache write ${number(usage?.cacheWriteTokens)}`,
-            `Context: ${number(pressure?.projectedTokens)} / ${number(pressure?.contextWindow)} tokens`,
-            `Composition: system ${number(breakdown?.systemTokens)} · tools ${number(breakdown?.toolsTokens)} · messages ${number(breakdown?.messageTokens)}`,
-        ],
-        title: 'Status',
-    };
-}
-/** Show DSH's heuristic next-request composition without treating it as an exact total. */
-export function contextOverlay(ctx, agent) {
-    const breakdown = ctx.sessionProjections.snapshot(agent.session, ['contextBreakdown'])
-        .values.contextBreakdown;
-    return {
-        kind: 'info',
-        lines: [
-            `System prompt: ${number(breakdown?.systemTokens)} tokens`,
-            `Tool schemas: ${number(breakdown?.toolsTokens)} tokens`,
-            `Messages: ${number(breakdown?.messageTokens)} tokens`,
-            'These are DSH heuristic estimates for the next request, not a provider-reported total.',
-        ],
-        title: 'Context',
-    };
-}
-/** Read DSH's whole-log token and timing projections without folding session history. */
-export function usageOverlay(ctx, agent) {
-    const values = ctx.sessionProjections.snapshot(agent.session, ['tokenUsage', 'sessionStats']).values;
-    const tokens = values.tokenUsage;
-    const stats = values.sessionStats;
-    const measured = stats === undefined ? undefined : stats.llmMs + stats.toolMs;
-    return {
-        kind: 'info',
-        lines: [
-            `Input tokens: ${number(tokens?.uncachedInputTokens)}`,
-            `Output tokens: ${number(tokens?.outputTokens)}`,
-            `Cache read: ${number(tokens?.cacheReadTokens)}`,
-            `Cache write: ${number(tokens?.cacheWriteTokens)}`,
-            `Turns: ${number(stats?.turns)} · Steps: ${number(stats?.steps)}`,
-            `Model time: ${milliseconds(stats?.llmMs)}`,
-            `Tool time: ${milliseconds(stats?.toolMs)}`,
-            `Measured wall time: ${milliseconds(measured)}`,
-        ],
-        title: 'Usage',
-    };
-}
-/** Build the native agent-preset picker; broken presets are visible elsewhere, not selectable here. */
-export function agentPresetOverlay(presets, current, blank) {
-    const options = presets.filter(preset => preset.broken === undefined).map(preset => ({
-        active: preset.id === current,
-        label: preset.name ?? preset.id,
-        value: { kind: 'agent-preset', preset: preset.id },
-        ...(preset.description === undefined ? {} : { detail: preset.description }),
-    }));
-    return {
-        cursor: Math.max(0, options.findIndex(option => option.active)),
-        kind: 'list',
-        notice: blank ? 'The current session is blank.' : 'Choosing a preset starts a new session.',
-        options,
-        purpose: 'agents',
-        title: 'Agent preset',
-    };
-}
-/** Build bounded same-cwd prompt-search rows from DSH query hits. */
-export function searchOverlay(items, rootId) {
-    return {
-        cursor: 0,
-        kind: 'list',
-        options: items.map(item => ({
-            detail: `${String(item.header.id)} · ${item.header.cwd ?? 'cwd unavailable'}`,
-            label: item.bestMatch.snippet.replaceAll(/\s+/gu, ' ').trim(),
-            value: {
-                kind: 'search-result', rootId, seq: item.bestMatch.seq,
-                sessionId: String(item.header.id),
-            },
-        })),
-        purpose: 'search',
-        title: 'Prompt search',
-    };
-}
-export function currentModel(ctx, agent) {
-    return selectedModel(ctx, agent);
-}

package/lib/clipboard-image.d.ts

@@ -1,3 +0,0 @@
-import type { DraftAttachment } from './state.js';
-/** Read a PNG from an installed platform clipboard helper. */
-export declare function readClipboardImage(platform?: NodeJS.Platform, path?: string): Promise<DraftAttachment>;

package/lib/clipboard-image.js

@@ -1,74 +0,0 @@
-import { spawn } from 'node:child_process';
-import { draftImage } from './image-input.js';
-const APPLE_SCRIPT = `
-ObjC.import('AppKit')
-const pasteboard = $.NSPasteboard.generalPasteboard
-let data = pasteboard.dataForType('public.png')
-if (!data) {
-  const tiff = pasteboard.dataForType('public.tiff')
-  if (tiff) {
-    const image = $.NSBitmapImageRep.imageRepWithData(tiff)
-    if (image) data = image.representationUsingTypeProperties($.NSBitmapImageFileTypePNG, $())
-  }
-}
-if (!data) $.exit(2)
-console.log(ObjC.unwrap(data.base64EncodedStringWithOptions(0)))
-`.trim();
-function capture(command, args, base64, path) {
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            ...(path === undefined ? {} : { env: { ...process.env, PATH: path } }),
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        const chunks = [];
-        child.stdout.on('data', (chunk) => { chunks.push(chunk); });
-        child.once('error', error => {
-            if (error.code === 'ENOENT')
-                resolve({ found: false });
-            else
-                reject(error);
-        });
-        child.once('close', code => {
-            if (code !== 0)
-                return resolve({ found: true });
-            const output = Buffer.concat(chunks);
-            if (output.length === 0)
-                return resolve({ found: true });
-            if (!base64)
-                return resolve({ found: true, output: new Uint8Array(output) });
-            try {
-                const decoded = Buffer.from(output.toString('utf8').trim(), 'base64');
-                resolve({ found: true, ...(decoded.length === 0 ? {} : { output: new Uint8Array(decoded) }) });
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    });
-}
-/** Read a PNG from an installed platform clipboard helper. */
-export async function readClipboardImage(platform = process.platform, path) {
-    const attempts = platform === 'darwin'
-        ? [
-            ['pngpaste', ['-'], false],
-            ['osascript', ['-l', 'JavaScript', '-e', APPLE_SCRIPT], true],
-        ]
-        : platform === 'linux'
-            ? [
-                ['wl-paste', ['--no-newline', '--type', 'image/png'], false],
-                ['xclip', ['-selection', 'clipboard', '-t', 'image/png', '-o'], false],
-            ]
-            : [];
-    let helperFound = false;
-    for (const [command, args, base64] of attempts) {
-        const result = await capture(command, args, base64, path);
-        helperFound ||= result.found;
-        if (result.output !== undefined)
-            return draftImage(result.output, 'image/png', 'clipboard.png', 'clipboard');
-    }
-    if (attempts.length === 0)
-        throw new Error('Clipboard image paste is supported on Linux and macOS.');
-    throw new Error(helperFound
-        ? 'The clipboard does not contain a PNG image.'
-        : `Clipboard image paste needs ${platform === 'darwin' ? 'pngpaste or osascript' : 'wl-paste or xclip'}.`);
-}

package/lib/completion-trigger.d.ts

@@ -1,6 +0,0 @@
-export declare function slashCompletionQuery(input: string): string | undefined;
-export declare function pluginCompletionQuery(input: string, caret: number): {
-    readonly command?: string;
-    readonly query: string;
-} | undefined;
-export declare function hasCompletionTrigger(input: string, caret: number): boolean;

package/lib/completion-trigger.js

@@ -1,19 +0,0 @@
-import { detectAtTrigger } from './at-trigger.js';
-export function slashCompletionQuery(input) {
-    return /^\/([a-z0-9_-]*)$/u.exec(input)?.[1];
-}
-export function pluginCompletionQuery(input, caret) {
-    if (caret !== input.length)
-        return undefined;
-    const match = /^\/plugin +([^\s]*)(?: +([^\s]*))?$/u.exec(input);
-    if (match === null)
-        return undefined;
-    const command = match[1] ?? '';
-    if (match[2] === undefined)
-        return { query: command };
-    return /^(?:exec|remove|update|why)$/u.test(command) ? { command, query: match[2] } : undefined;
-}
-export function hasCompletionTrigger(input, caret) {
-    return slashCompletionQuery(input) !== undefined || pluginCompletionQuery(input, caret) !== undefined
-        || detectAtTrigger(input, caret) !== undefined;
-}

package/lib/diff-view.d.ts

@@ -1,5 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import type { Overlay } from './state.js';
-import { type ToolPresenter } from './tool-presentation.js';
-export declare function diffOverlay(ctx: Context, agent: Agent, presenter: ToolPresenter, mode: '' | 'turn', signal: AbortSignal): Promise<Overlay>;

package/lib/diff-view.js

@@ -1,24 +0,0 @@
-import { HUMAN_SHELL_STREAM_BYTES } from './shell-command.js';
-import { boundedBody } from './tool-presentation.js';
-import { foldCells } from './transcript.js';
-export async function diffOverlay(ctx, agent, presenter, mode, signal) {
-    if (mode === 'turn') {
-        const events = agent.session.snapshotEvents();
-        const start = events.map(event => event.type).lastIndexOf('turn/start');
-        const cells = (start < 0 ? [] : foldCells(events.slice(start), presenter)).filter(cell => cell.pending !== true && cell.tool?.card === 'diff' && (cell.tool.diffs?.length ?? 0) > 0);
-        return { cells, kind: 'info', lines: cells.length === 0 ? ['No write/edit changes in the last turn.'] : [], title: 'Last turn diff' };
-    }
-    const command = 'git diff --no-ext-diff --no-color HEAD --';
-    const result = await ctx.shell.run(ctx.shell.resolve({
-        command, sandboxPolicy: ctx.sandboxPolicy.resolve({ session: agent.session }), signal,
-        stdoutMaxBytes: HUMAN_SHELL_STREAM_BYTES, timeoutMs: 30_000, workdir: agent.session.header.cwd,
-    }));
-    const output = [result.stdout.text, result.stderr.text].filter(Boolean).join('\n');
-    const cell = {
-        key: 'diff:working', kind: result.exitCode === 0 ? 'tool' : 'error', text: 'git diff',
-        tool: { card: 'terminal', title: 'git diff', status: result.exitCode === 0 ? output === '' ? 'clean' : 'changed'
-                : result.exitCode === null ? result.signal ?? 'failed' : `exit ${String(result.exitCode)}`,
-            ...(output === '' ? {} : { body: boundedBody(output) }) },
-    };
-    return { cells: [cell], kind: 'info', lines: [], title: 'Working tree diff' };
-}

package/lib/external-editor.d.ts

@@ -1,3 +0,0 @@
-export declare function runEditor(command: string, file: string, cwd: string): Promise<void>;
-/** Edit one draft through the user's terminal editor and always remove its file. */
-export declare function editDraftExternally(text: string, cwd: string): Promise<string>;

package/lib/external-editor.js

@@ -1,39 +0,0 @@
-import { spawn } from 'node:child_process';
-import { mkdtemp, readFile, rm, rmdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-export function runEditor(command, file, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('/bin/sh', ['-c', `exec ${command} "$1"`, 'dashi-editor', file], {
-            cwd, stdio: 'inherit',
-        });
-        child.once('error', reject);
-        child.once('exit', (code, signal) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`editor exited with ${code === null ? signal ?? 'unknown status' : `code ${String(code)}`}`));
-        });
-    });
-}
-/** Edit one draft through the user's terminal editor and always remove its file. */
-export async function editDraftExternally(text, cwd) {
-    const command = process.env.VISUAL?.trim() || process.env.EDITOR?.trim();
-    if (command === undefined || command === '')
-        throw new Error('set $VISUAL or $EDITOR to use Ctrl+G');
-    const directory = await mkdtemp(join(tmpdir(), 'dashi-editor-'));
-    const file = join(directory, 'draft.md');
-    try {
-        await writeFile(file, text, { encoding: 'utf8', mode: 0o600 });
-        await runEditor(command, file, cwd);
-        return await readFile(file, 'utf8');
-    }
-    finally {
-        try {
-            await rm(file, { force: true });
-        }
-        finally {
-            await rmdir(directory);
-        }
-    }
-}

package/lib/help.d.ts

@@ -1,2 +0,0 @@
-export declare const VERSION_LINE: string;
-export declare const FLAG_HELP: readonly ["Launch flags: --inline | --fullscreen · --accessible · --verbose · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all", "  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL", "  --permission PRESET · --tools NAMES · --disallowedTools NAMES · --yolo | --dangerously-skip-permissions · --image PATH", "  --system-prompt TEXT | --system-prompt-file PATH · --append-system-prompt TEXT | --append-system-prompt-file PATH · -h, --help"];

package/lib/help.js

@@ -1,6 +0,0 @@
-import dashi from '../package.json' with { type: 'json' };
-import dsh from '@deepseek-ai/dsh-cmdline/package.json' with { type: 'json' };
-export const VERSION_LINE = `dashi ${dashi.version} on DSH ${dsh.version}`;
-export const FLAG_HELP = [
-    'Launch flags: --inline | --fullscreen · --accessible · --verbose · -r, --resume [NAME|UUID] · -c, --continue · --fork-session · --all', '  -n, --name TITLE · --agent PRESET · --session-id UUID · --model ID [--provider ID] · --effort LEVEL', '  --permission PRESET · --tools NAMES · --disallowedTools NAMES · --yolo | --dangerously-skip-permissions · --image PATH', '  --system-prompt TEXT | --system-prompt-file PATH · --append-system-prompt TEXT | --append-system-prompt-file PATH · -h, --help'
-];

package/lib/history-records.d.ts

@@ -1,4 +0,0 @@
-import type { SessionHistoryRecord } from '@deepseek-ai/dsh-api-session-controller';
-import { type SessionEvent } from '@deepseek-ai/dsh-session';
-/** Expand the Controller's compact history wire records to canonical Session events. */
-export declare function eventsFromRecords(records: readonly SessionHistoryRecord[]): SessionEvent[];

package/lib/history-records.js

@@ -1,14 +0,0 @@
-import { decodeStorageRecord } from '@deepseek-ai/dsh-session';
-/** Expand the Controller's compact history wire records to canonical Session events. */
-export function eventsFromRecords(records) {
-    return records.flatMap((record) => {
-        if (record.type === 'event')
-            return [record.event];
-        const encoded = record.event.type === 'chunkrow/text-chunks'
-            ? { type: 'text-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
-            : record.event.type === 'chunkrow/reasoning-chunks'
-                ? { type: 'reasoning-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data }
-                : { type: 'tool-call-chunks', seq0: record.event.seq, time0: record.event.time, data: record.event.data };
-        return decodeStorageRecord(encoded);
-    });
-}

package/lib/image-input.d.ts

@@ -1,8 +0,0 @@
-import type { AttachmentStore, EncodedImageAttachment, ImageAttachmentRef, ImageMediaType } from '@deepseek-ai/dsh-attachment';
-import type { DraftAttachment } from './state.js';
-export declare function isImagePath(path: string): boolean;
-export declare function draftImage(data: Uint8Array, mediaType: ImageMediaType, name: string, path: string): DraftAttachment;
-/** Snapshot explicit user paths into one disposable composer draft. */
-export declare function readDraftImages(cwd: string, paths: readonly string[]): Promise<DraftAttachment[]>;
-export declare function encodeDraftImages(images: readonly DraftAttachment[]): EncodedImageAttachment[];
-export declare function admitDraftImages(attachments: AttachmentStore, images: readonly DraftAttachment[]): Promise<readonly ImageAttachmentRef[]>;

package/lib/image-input.js

@@ -1,37 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { basename, extname, resolve } from 'node:path';
-const MEDIA_TYPES = {
-    '.gif': 'image/gif',
-    '.jpeg': 'image/jpeg',
-    '.jpg': 'image/jpeg',
-    '.png': 'image/png',
-    '.webp': 'image/webp',
-};
-export function isImagePath(path) {
-    return MEDIA_TYPES[extname(path).toLocaleLowerCase()] !== undefined;
-}
-export function draftImage(data, mediaType, name, path) {
-    return { bytes: data.byteLength, data, mediaType, name, path };
-}
-/** Snapshot explicit user paths into one disposable composer draft. */
-export async function readDraftImages(cwd, paths) {
-    return Promise.all(paths.map(async (path) => {
-        const absolute = resolve(cwd, path);
-        const mediaType = MEDIA_TYPES[extname(absolute).toLocaleLowerCase()];
-        if (mediaType === undefined) {
-            throw new Error(`unsupported image extension for ${path}; accepted: .png, .jpg, .jpeg, .webp, .gif`);
-        }
-        const data = new Uint8Array(await readFile(absolute));
-        return draftImage(data, mediaType, basename(absolute), absolute);
-    }));
-}
-export function encodeDraftImages(images) {
-    return images.map(image => ({
-        data: Buffer.from(image.data).toString('base64'), mediaType: image.mediaType, name: image.name,
-    }));
-}
-export function admitDraftImages(attachments, images) {
-    return attachments.saveImages(images.map(image => ({
-        data: image.data, mediaType: image.mediaType, name: image.name,
-    })));
-}

package/lib/index.d.ts

@@ -1,4 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-export declare const name = "dashi";
-export declare const inject: string[];
-export declare function apply(ctx: Context): void;