@xiaoso/dsh-tool-plus 0.1.7 → 0.1.8-beta.3

package/lib/types/tools/glob/adapter/index.d.ts

@@ -25,6 +25,8 @@ export interface GlobToolOutput {
     text: string;
     fileCount?: number;
     truncated?: boolean;
+    /** 引擎的结果路径列表（display 相对路径），卡片按它出 paths 卡。 */
+    paths?: string[];
 }
 /**
  * 把 OMP AgentToolResult 转成 DSH glob 工具输出。

package/lib/types/tools/grep/adapter/index.d.ts

@@ -26,6 +26,10 @@ export interface GrepToolOutput {
     files?: string[];
     scopePath?: string;
     truncated?: boolean;
+    /** 引擎给渲染器的分组显示文本（`# dir/` + `## file` + `*N│line` 代码帧）。 */
+    displayContent?: string;
+    /** 搜索时的会话 cwd：display 头里的相对路径按它还原成绝对路径。 */
+    cwd?: string;
 }
 /**
  * 把 OMP AgentToolResult 转成 DSH grep 工具输出。

package/lib/types/tools/read/adapter/index.d.ts

@@ -27,6 +27,24 @@ export interface ReadToolOutput {
     truncated?: boolean;
     /** 拍板#22：图片读取的附件提交结果（信封文本已并入 text，此字段供 UI/审计）。 */
     image?: SavedImageRef;
+    /**
+     * 引擎给渲染器的无前缀窗口（read.ts 的 `details.displayContent`）：卡片
+     * meta 的唯一数据源，不含 hashline/行号前缀，供 gutter 自绘。
+     */
+    display?: {
+        text: string;
+        startLine: number;
+        lineNumbers?: Array<number | null>;
+    };
+    /** 引擎的 source meta（`{type:'path'|'url'|'internal', value}`）——卡片取路径用。 */
+    source?: {
+        type: string;
+        value: string;
+    };
+    /** 目录列举读取（不出行号卡）。 */
+    isDirectory?: boolean;
+    /** 结果里 text 块的个数（>1 说明是多目标/信封读取，不出行号卡）。 */
+    textBlocks?: number;
 }
 /**
  * 把 OMP AgentToolResult 转成 DSH read 工具输出。

package/lib/types/tools/write/adapter/index.d.ts

@@ -19,6 +19,8 @@ export type { ToolSession } from '../../omp/sdk.ts';
 export interface WriteToolOutput {
     path: string;
     text: string;
+    /** 卡片用语法提示；认不出语言时不带该键（meta 里不许出现 undefined）。 */
+    lang?: string;
 }
 /** 完整执行链路（defineTool.execute 与单测共用）。 */
 export declare function executeWriteTool(exec: any, cfg: RuntimeConfig, args: any): Promise<WriteToolOutput>;

package/lib/types/web/client/ToolCardShell.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The shared card shell every row renders through.
+ *
+ * The shipped `ToolRow` is not reusable from a plugin (ui-tool is not part of
+ * the client platform baseline), so this is our own: one 24px header line
+ * (state dot + title + separator + ellipsized summary + optional `+N -M`
+ * suffix + clickable path), a keyboard-reachable disclosure, and a body that
+ * is either the card a row built or the flattened result text.
+ *
+ * Two properties matter more than the visuals:
+ * - **Never throw.** Every value is coerced defensively, and {@link CardBoundary}
+ *   turns a crash inside a card into the same generic shell, because an
+ *   exception reaching the slot retires the cell and abdicates the call to the
+ *   shipped row.
+ * - **Theme tokens only.** The sheet below reads `--dsw-alias-*` (plus the two
+ *   published content-font vars) and hard-codes no colour, so light and dark
+ *   both come out right.
+ * @module @xiaoso/dsh-tool-plus/web/client/ToolCardShell
+ */
+import { Component, type ReactNode } from 'react';
+import { type CardBlockView, type CardOpenFileOptions, type CardState, type CardTranslate } from './row-utils.ts';
+/** Props of {@link ToolCardShell}. */
+export interface ToolCardShellProps {
+    /** Card translate seat. */
+    t: CardTranslate;
+    /** Run state driving the leading dot and the status word. */
+    state: CardState;
+    /** Single-line title (the tool name). */
+    title: string;
+    /** Collapsed summary after the separator; empty renders no separator. */
+    summary?: string | null | undefined;
+    /** Trailing fragment kept outside the summary's ellipsis (e.g. `+3 -1`). */
+    summarySuffix?: string | null | undefined;
+    /** Render the summary in the error tone (a failure line, not a description). */
+    summaryTone?: 'default' | 'error' | undefined;
+    /** Filesystem path to offer as a clickable link; requires `openFile`. */
+    filePath?: string | null | undefined;
+    /** 1-based line the call was about; absent opens the file at its start. */
+    filePathLine?: number | null | undefined;
+    /** Opens `filePath` in the host's file viewer. */
+    openFile?: ((path: string, options?: CardOpenFileOptions) => void) | undefined;
+    /** Jump to this call in the trajectory view; absent renders no affordance. */
+    inspect?: (() => void) | undefined;
+    /** Body text used when no `children` card is supplied. */
+    text?: string | null | undefined;
+    /** Start expanded. */
+    defaultOpen?: boolean | undefined;
+    /** Card body; wins over `text` when supplied. */
+    children?: ReactNode;
+}
+/**
+ * Render the shared card shell.
+ * @param props - see {@link ToolCardShellProps}.
+ * @returns the card row and, when expanded, its body.
+ */
+export declare function ToolCardShell(props: ToolCardShellProps): import("react").JSX.Element;
+/** Props of {@link GenericCard}. */
+export interface GenericCardProps {
+    /** Card translate seat. */
+    t: CardTranslate;
+    /** Localized card title. */
+    title: string;
+    /** The frozen call node. */
+    block: CardBlockView;
+    /** The call's parsed arguments, when there are any. */
+    args: Record<string, unknown> | null;
+    /** Jump to this call in the trajectory view. */
+    inspect?: (() => void) | undefined;
+}
+/**
+ * The generic card: every row's degradation path.
+ *
+ * A card is only drawn once its metadata passed a `narrow*` guard, so anything
+ * else — a running call, a window-truncated call, a Code Dispatch child, a
+ * failure, a payload from another plugin version — lands here with the call's
+ * own title, run state, argument count, and result text.
+ * @param props - see {@link GenericCardProps}.
+ * @returns the generic shell.
+ */
+export declare function GenericCard({ t, title, block, args, inspect }: GenericCardProps): import("react").JSX.Element;
+/** Props of {@link CardBoundary}. */
+export interface CardBoundaryProps {
+    /** Card translate seat, forwarded to the fallback shell. */
+    t: CardTranslate;
+    /** Title the fallback shell shows. */
+    title: string;
+    /** The call node, so the fallback can still offer its result text. */
+    block?: CardBlockView | undefined;
+    /** Summary the fallback shell shows before the failure line replaces it. */
+    summary?: string | null | undefined;
+    /** The card to protect. */
+    children: ReactNode;
+}
+/** State of {@link CardBoundary}: the caught failure, once there is one. */
+interface CardBoundaryState {
+    failure: string | null;
+}
+/**
+ * Contain a card's render failure: the fallback is a generic shell (never the
+ * card's own chrome), so one malformed payload cannot take the call's cell —
+ * or the whole slot — down with it.
+ */
+export declare class CardBoundary extends Component<CardBoundaryProps, CardBoundaryState> {
+    state: CardBoundaryState;
+    /** React's error-boundary hook: record the failure and render the fallback. */
+    static getDerivedStateFromError(error: unknown): CardBoundaryState;
+    /** Report the failure without rethrowing. */
+    componentDidCatch(error: unknown): void;
+    render(): ReactNode;
+}
+export {};

package/lib/types/web/client/labels.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Card copy for the browser tool views: every string the six row components
+ * and the shared shell draw, in its own locale namespace so it can never
+ * collide with the settings card's `tool-plus` bundle (the slots registry
+ * merges namespaces, and re-declaring one would be a compile error).
+ *
+ * zh is the source of truth for the key set; both dictionaries are
+ * `Record<ToolCardLocaleKey, string>`, so a missing or extra key in either is
+ * a compile error. Template parameters use the host's `{name}` placeholder
+ * convention (the seat interpolates the params record into the string).
+ *
+ * The wording mirrors the shipped conversation namespace for the same
+ * primitives (diff / read / search / terminal chrome) so a takeover does not
+ * change how the cards read; tool titles and the generic-row copy are ours.
+ * @module @xiaoso/dsh-tool-plus/web/client/labels
+ */
+/** Locale namespace of the tool-card bundle (registered by `registerToolCards`). */
+export declare const CARD_LOCALE_NS = "tool-plus-cards";
+/** Every copy key of the tool-card namespace. */
+export type ToolCardLocaleKey = 'copy' | 'copied' | 'collapse' | 'expand' | 'collapseAria' | 'expandAria' | 'expandRest' | 'files.one' | 'files.other' | 'running' | 'done' | 'failed' | 'cancelled' | 'timedOut' | 'noOutput' | 'title.bash' | 'title.read' | 'title.write' | 'title.edit' | 'title.grep' | 'title.glob' | 'title.astGrep' | 'title.astEdit' | 'write.lines' | 'write.madeExecutable' | 'astEdit.replacements' | 'astEdit.files' | 'astEdit.parseErrors' | 'astEdit.rules' | 'astEdit.rulesRest' | 'read.window' | 'read.collapseAria' | 'read.expandAria' | 'read.expandRest' | 'search.paths' | 'search.paths.truncated' | 'search.matches' | 'search.matches.truncated' | 'search.noResults' | 'search.scope' | 'search.collapseAria' | 'search.expandAria' | 'search.expandRest' | 'terminal.signal' | 'terminal.exitCode' | 'terminal.running' | 'terminal.failed' | 'terminal.done' | 'terminal.noOutput' | 'bash.background' | 'image.loading' | 'image.loadFailed' | 'image.open' | 'image.openNamed' | 'image.dialog' | 'image.close' | 'image.unnamed' | 'image.caption' | 'generic.params' | 'generic.noDetail' | 'inspect';
+/** Simplified Chinese copy (the source dictionary). */
+export declare const zh: Record<ToolCardLocaleKey, string>;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: Record<ToolCardLocaleKey, string>;
+/** The bilingual bundle handed to `ctx.locale.register(CARD_LOCALE_NS, …)`. */
+export declare const cardLocales: {
+    zh: Record<ToolCardLocaleKey, string>;
+    en: Record<ToolCardLocaleKey, string>;
+};
+/** Merge this plugin's card namespace into the slot locale table (official pattern). */
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Copy for the browser tool cards. */
+        'tool-plus-cards': ToolCardLocaleKey;
+    }
+}

package/lib/types/web/client/registerToolCards.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Register every tool card this plugin renders through the keyed
+ * `tool.call.toolview` slot.
+ *
+ * Two shapes live here:
+ *  - `ast_grep` / `ast_edit` are this plugin's own tool names, so their keys are
+ *    unclaimed and registering them is purely additive;
+ *  - `bash` / `read` / `write` / `edit` / `grep` / `glob` have a shipped row at
+ *    the slot's default priority, which we shadow by registering at
+ *    {@link CARD_TAKEOVER_PRIORITY} (the lowest live entry of a cell renders).
+ *
+ * The shadowing mechanism is a public API but has no published design note, so
+ * this module never trusts it blindly: right after registering it reads the
+ * cell winners back and, when one of them is not our row, it reports the lost
+ * key (`console.error`) and keeps its own entries anyway — a mixed tool view is
+ * the deliberate signal that the takeover assumption broke, never a silent
+ * fallback to the shipped rows. The `webCards` settings switch (default on)
+ * mounts and unmounts the cards on demand.
+ *
+ * Registration runs inside `ctx.slots.inject`, so it waits for the shipped
+ * declaration and is torn down with the plugin fiber. A crash inside a row is
+ * contained by that row's own boundary rather than thrown at the slot.
+ *
+ * @module @xiaoso/dsh-tool-plus/web/client/registerToolCards
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+/**
+ * Mount the tool cards.
+ *
+ * Registers the card dictionaries and one entry per tool key, then keeps the
+ * registration in step with the `webCards` switch. Everything
+ * installed here rides the caller's fiber, so plugin unload removes it all.
+ * @param ctx - the browser plugin context.
+ */
+export declare function registerToolCards(ctx: ClientContext): void;

package/lib/types/web/client/row-utils.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Defensive readers shared by the tool-card rows, plus the adapters that bind
+ * this plugin's card dictionary onto the cordis-free UI primitives.
+ *
+ * The rows render data the model never sees: a call's frozen node, its raw
+ * arguments, its result text, and the Host-projected metadata. Every read here
+ * is written to survive a malformed input — a window-truncated call, a
+ * hand-rolled argument payload, a metadata blob from another plugin version —
+ * and to return a "no data" answer instead of throwing: an exception inside a
+ * row reaches the slot, which retires the cell and hands the call back to the
+ * shipped row with the failure surfaced in the console.
+ *
+ * Metadata is only ever read through `src/web/contract.ts`'s `narrow*` guards;
+ * nothing here touches a raw `meta` field directly.
+ * @module @xiaoso/dsh-tool-plus/web/client/row-utils
+ */
+import type { DiffBlockLabels, ReadBlockLabels, SearchBlockLabels, StateDotState, TerminalBlockLabels } from '@deepseek-ai/dsh-client-ui-primitives';
+import type { TranslateNS } from '@deepseek-ai/dsh-client-ui-slots';
+import type { CARD_LOCALE_NS, ToolCardLocaleKey } from './labels.ts';
+/** Translate seat of this plugin's card namespace. */
+export type CardTranslate = TranslateNS<typeof CARD_LOCALE_NS>;
+/**
+ * Structural view of the frozen running-or-settled node a row receives. It
+ * names only the fields the cards actually read, so an upstream node shape
+ * change degrades a card instead of breaking the row.
+ */
+export interface CardBlockView {
+    readonly kind?: unknown;
+    readonly callId?: unknown;
+    readonly parentCallId?: unknown;
+    readonly name?: unknown;
+    readonly argsRaw?: unknown;
+    readonly call?: {
+        readonly name?: unknown;
+        readonly argsRaw?: unknown;
+    } | null;
+    readonly content?: unknown;
+    readonly isError?: unknown;
+    readonly meta?: unknown;
+}
+/** Card run state, one step off the shipped `ToolRowState` (no `stopped`). */
+export type CardState = 'running' | 'ok' | 'error' | 'warning';
+/** Whether a block is the settled half of a call pair. */
+export declare function isSettled(block: CardBlockView): boolean;
+/**
+ * Parse the call's raw argument JSON.
+ *
+ * The parsed object is memoized per node (the node is immutable), so repeated
+ * renders of one card pay for a single parse.
+ * @param block - the frozen running-or-settled call node.
+ * @returns the argument object, or `null` when the head is missing or its JSON
+ *   is not an object.
+ */
+export declare function parseCardArgs(block: CardBlockView): Record<string, unknown> | null;
+/**
+ * Run state of one call.
+ *
+ * A settled `isError` result is an error; a foreground command that timed out
+ * or was cancelled is amber rather than green (the shipped terminal model
+ * reads only the trailing exit marker, which is exactly what the card owner
+ * was told not to trust). A non-zero exit stays `ok`: bash reports a failing
+ * command as result data, and the card's own status pill carries the red.
+ * @param block - the frozen running-or-settled call node.
+ * @returns the card run state.
+ */
+export declare function cardState(block: CardBlockView): CardState;
+/** Map a card run state onto the primitive's dot semantics. */
+export declare function dotState(state: CardState): StateDotState;
+/**
+ * The assistive-technology status word for a run state, or `null` when the
+ * state is already carried by the row's content.
+ */
+export declare function stateStatus(state: CardState, t: CardTranslate): string | null;
+/**
+ * Flatten a settled result's text blocks.
+ * @param block - the frozen call node.
+ * @returns the joined text blocks (empty for a running call or non-text output).
+ */
+export declare function resultText(block: CardBlockView): string;
+/**
+ * The opaque metadata a call's result carried, exactly as the transport
+ * delivered it. Callers must run it through a `narrow*` guard before reading.
+ * @param block - the frozen call node.
+ * @returns the raw metadata, or `undefined` while the call is running.
+ */
+export declare function cardMeta(block: CardBlockView): unknown;
+/**
+ * Whether the call was dispatched by another tool (a Code Dispatch child).
+ * The card rows fall back to the generic shell for those, mirroring the
+ * shipped rows: a child diff/read/search inside a parent card would nest a
+ * surface inside the parent's own body.
+ */
+export declare function isSubCall(block: CardBlockView): boolean;
+/**
+ * The first non-empty line of a text, trimmed — the collapsed summary of an
+ * error, and the closing line of the generic shell's body.
+ * @param text - the source text.
+ * @returns the first line, clipped to a row-sized maximum (never throws).
+ */
+export declare function firstLine(text: string): string;
+/**
+ * A string argument by name.
+ * @param args - parsed arguments, or `null`.
+ * @param name - the argument key.
+ * @returns its value when it is a non-empty string, else `null`.
+ */
+export declare function argText(args: Record<string, unknown> | null, name: string): string | null;
+/** Options object passed to the owner's `openFile` (a line to land on). */
+export interface CardOpenFileOptions {
+    line?: number;
+}
+/**
+ * Shorten an absolute path against the session workspace so a summary stays
+ * readable in a narrow row.
+ * @param path - the path to display.
+ * @param cwd - the session workspace root, when known.
+ * @returns the path relative to `cwd`, or `path` unchanged.
+ */
+export declare function displayPath(path: string, cwd: string | undefined): string;
+/**
+ * The collapsed summary for a call whose card could not be built: how many
+ * arguments the model sent, so the row is not blank.
+ * @param args - parsed arguments, or `null`.
+ * @param t - the card translate seat.
+ * @returns the localized parameter count.
+ */
+export declare function argsSummary(args: Record<string, unknown> | null, t: CardTranslate): string;
+/**
+ * The card title for a wire tool name.
+ *
+ * The same row component can be registered under several keys (one search row
+ * serves `grep`, `glob`, and `ast_grep`), and a window-truncated call has no
+ * name at all, so the caller names the key it was registered for as a fallback.
+ * @param toolName - the node's wire tool name (empty when truncated).
+ * @param t - the card translate seat.
+ * @param fallback - title key to use when the name is unknown.
+ * @returns the localized title.
+ */
+export declare function cardTitle(toolName: string, t: CardTranslate, fallback: ToolCardLocaleKey): string;
+/**
+ * Count a preview's content lines, ignoring the single trailing newline that
+ * terminates the last line.
+ * @param text - the preview text.
+ * @returns its line count (0 for empty text).
+ */
+export declare function lineCount(text: string): number;
+/** A shell result's trailing status markers, and the text they were stripped from. */
+export interface ShellStatus {
+    /** The output text with its trailing marker lines removed. */
+    output: string;
+    /** Marked exit code; `null` when the marker itself carried no code. */
+    exitCode: number | null | undefined;
+    /** Terminating signal name, when a marker named one. */
+    signal: string | undefined;
+    /** A timeout marker was present. */
+    timedOut: boolean;
+}
+/**
+ * Split a settled shell result into its output and the status markers the
+ * renderer appended (timeout, terminating signal, exit code — in that order,
+ * so every marker is at the end and any run of them is stripped).
+ *
+ * The Host metadata already carries the run state; parsing is what keeps the
+ * markers out of the terminal card's output pane, and it is the only source
+ * for a signal name the projection does not carry.
+ * @param text - the result text.
+ * @returns the marker-free output and the facts the markers named.
+ */
+export declare function parseShellStatus(text: string): ShellStatus;
+/** Bind the card dictionary to the diff primitive's chrome labels. */
+export declare function diffBlockLabels(t: CardTranslate): DiffBlockLabels;
+/** Bind the card dictionary to the read primitive's chrome labels. */
+export declare function readBlockLabels(t: CardTranslate): ReadBlockLabels;
+/** Bind the card dictionary to the search primitive's chrome labels. */
+export declare function searchBlockLabels(t: CardTranslate): SearchBlockLabels;
+/** Bind the card dictionary to the terminal primitive's chrome labels. */
+export declare function terminalBlockLabels(t: CardTranslate): TerminalBlockLabels;

package/lib/types/web/client/rows/AstEditRow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `ast_edit` row: the engine's own change preview.
+ *
+ * The AST engine already renders a grouped preview (file header, replacement
+ * count, the first line of each change) and hands it to the Host as
+ * `displayContent`; that text is what this card shows, because the exact
+ * before/after hunks are dropped inside the ported tool and the write happens
+ * in the native engine. No diff is computed here, and no `±` totals are shown.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/AstEditRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render an `ast_edit` call as a change preview.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the preview card, or the generic shell when there is no preview.
+ */
+export default function AstEditRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/FileMutationRow.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `edit` row: a diff card.
+ *
+ * Two sources, in order: the Host projection (`meta.diffs`, built from the
+ * engine's own unified diff — the change is already computed and needs no
+ * extra I/O), then the replace-form arguments while the call is still running
+ * (or when the Host could not project a diff). Every other edit mode (patch,
+ * hashline, apply_patch) has no diff until it settles, so it falls back to the
+ * generic shell rather than guessing from `patch`/`input` text.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/FileMutationRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render an `edit` call as a diff card.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the diff card, or the generic shell for a mode with no diff yet.
+ */
+export default function FileMutationRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/ReadRow.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `read` row: a line-numbered window view, or the image the read returned.
+ *
+ * Two mutually exclusive bodies hang off one call:
+ * - The Host projected a readable window (`meta`) → the line-numbered text card.
+ * - It did not (an image, a directory, a sqlite or archive target, an internal
+ *   URL, a multi-range `:raw` read) → this row tries the image branch, which
+ *   draws the result's image blocks through the session-authorized loader the
+ *   slot hands every tool view. Anything else keeps the generic shell and its
+ *   result text.
+ *
+ * The image branch reimplements the shipped message-image interaction — the
+ * `singleFit` box, 64px gallery tiles, a retry control on a failed load, and a
+ * body-portal lightbox for the original — so a tool-card image and a message
+ * image of the same file behave identically. It lives here rather than in
+ * `image-card.ts` because that module stays pure: this file owns the loader
+ * calls, their cancellation, and the DOM.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/ReadRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render a `read` call as a line-numbered window or an image.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the read card, or the generic shell when nothing else fits.
+ */
+export default function ReadRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/SearchRow.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `grep` / `glob` / `ast_grep` row: a search result card.
+ *
+ * One component serves all three keys because the Host projects one
+ * `shape`-discriminated metadata form for them: grouped matches for the two
+ * grep engines, a flat path list for glob. The title follows the call's own
+ * wire name, so the same component reads as Grep, Glob, or AST Grep.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/SearchRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render a search call as a result card.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the search card, or the generic shell with the result text.
+ */
+export default function SearchRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/TerminalRow.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `bash` row: a terminal card for foreground runs, a generic row for jobs.
+ *
+ * The card's command comes from the arguments, its working directory from the
+ * arguments falling back to the Host projection and then the session root, and
+ * its exit status from the Host projection — the trailing `[exit code: N]`
+ * marker is only parsed to keep it out of the output pane (and to recover the
+ * signal name the projection does not carry). A call the Host handed to a
+ * background job shows the job id instead: its result is a hand-off notice,
+ * not a finished command.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/TerminalRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render a `bash` call as a terminal card.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the terminal card, the job hand-off row, or the generic shell.
+ */
+export default function TerminalRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/WriteRow.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `write` row: a content preview card.
+ *
+ * The engine's write card is a preview of what was written, not a diff, and
+ * the content is in the arguments — so the card is complete while the call is
+ * still running, and the line count is counted on the client exactly as the
+ * engine's own header does. The language hint comes from the Host projection
+ * (`meta.lang`), which is the only part the arguments cannot supply.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/WriteRow
+ */
+import type { PropsLocale } from '@deepseek-ai/dsh-client-ui-slots';
+import type { ToolCallViewProps } from '@deepseek-ai/dsh-client-ui-tool/client';
+import { CARD_LOCALE_NS } from '../labels.ts';
+/** Props the slot hands this row, plus its own locale seat. */
+type RowProps = ToolCallViewProps & PropsLocale<typeof CARD_LOCALE_NS>;
+/**
+ * Render a `write` call as a content preview.
+ * @param props - the slot's owner props and this plugin's translate seat.
+ * @returns the card, or the generic shell when the arguments are unusable.
+ */
+export default function WriteRow(props: RowProps): import("react").JSX.Element;
+export {};

package/lib/types/web/client/rows/command-card-facts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Collapsed-fact builders for the two command-shaped cards: the command a
+ * `bash` description hides, and the rewrite rule an `ast_edit` preview only
+ * shows once expanded.
+ *
+ * Both cards collapse to one head line. `bash`'s head used to be the model's
+ * own `description` — a sentence about intent, never the command that ran — so
+ * the only way to learn what executed was to expand the card. `ast_edit`'s head
+ * names the file and the replacement count, and its body previews the *result*:
+ * the rule that produced that result lives only in the call's `ops` argument,
+ * which no card showed at all. Each builder recovers one fact from the call's
+ * own arguments, so nothing is inferred from output, and a call head that fell
+ * outside the session window degrades to the facts the card already holds.
+ * @module @xiaoso/dsh-tool-plus/web/client/rows/command-card-facts
+ */
+import { type CardTranslate } from '../row-utils.ts';
+/**
+ * The `bash` card's collapsed summary: what ran, placed after the sentence
+ * saying why.
+ *
+ * The command is the fact the head must carry, so the description can never be
+ * the whole summary — it is a prefix at most. Only its first line is used: a
+ * summary is one row high, and the rest of a multi-line command belongs to the
+ * expanded body, which draws the whole thing.
+ * @param description - the model's one-line intent, or `null` when absent.
+ * @param command - the command actually executed (never empty).
+ * @param outcome - the interruption word (`timedOut` / `cancelled`), or `null`.
+ * @returns the outcome alone when the run was interrupted; otherwise the
+ *   description joined to the command's first line, or that line alone.
+ */
+export declare function bashCardSummary(description: string | null, command: string, outcome: string | null): string;
+/**
+ * The `ast_edit` card's rule line: the first usable `ops` entry, written the
+ * way the tool's own `ops` argument writes it (`pat → out`).
+ *
+ * Only the first rule is stated, with the count of the entries behind it: the
+ * card exists to preview one change, and a call may carry many rules whose
+ * patterns are whole AST fragments — listing them would bury the preview. The
+ * remaining count is the array tail, not the number of *usable* entries, so it
+ * always describes the call as it was made.
+ * @param args - the call's parsed arguments, or `null` when its head is gone.
+ * @param t - this plugin's card translate seat.
+ * @returns the rule line, or `null` when the call carries no usable rule.
+ */
+export declare function astEditRuleLine(args: Record<string, unknown> | null, t: CardTranslate): string | null;