@oh-my-pi/pi-coding-agent 15.1.0 → 15.1.2

package/dist/types/tools/render-utils.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Shared utilities and constants for tool renderers.
+ *
+ * Provides consistent formatting, truncation, and display patterns across all
+ * tool renderers to ensure a unified TUI experience.
+ */
+import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
+import type { Ellipsis } from "@oh-my-pi/pi-natives";
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../modes/theme/theme";
+import { type ResizedImage } from "../utils/image-resize";
+export { Ellipsis } from "@oh-my-pi/pi-natives";
+export { replaceTabs, truncateToWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
+/** Resolve inline image dimension caps from settings and viewport. */
+export declare function resolveImageOptions(): {
+    maxWidthCells: number;
+    maxHeightCells?: number;
+};
+/** Preview limits for collapsed/expanded views */
+export declare const PREVIEW_LIMITS: {
+    /** Lines shown in collapsed view */
+    readonly COLLAPSED_LINES: 3;
+    /** Lines shown in expanded view */
+    readonly EXPANDED_LINES: 12;
+    /** Items (files, results) shown in collapsed view */
+    readonly COLLAPSED_ITEMS: 8;
+    /** Output preview lines in collapsed view */
+    readonly OUTPUT_COLLAPSED: 3;
+    /** Output preview lines in expanded view */
+    readonly OUTPUT_EXPANDED: 10;
+    /** Max hunks shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_HUNKS: 8;
+    /** Max diff lines shown when collapsed (edit tool) */
+    readonly DIFF_COLLAPSED_LINES: 40;
+};
+/** Truncation lengths for different content types */
+export declare const TRUNCATE_LENGTHS: {
+    /** Short titles, labels */
+    readonly TITLE: 60;
+    /** Medium-length content (messages, previews) */
+    readonly CONTENT: 80;
+    /** Longer content (code, explanations) */
+    readonly LONG: 100;
+    /** Full line content */
+    readonly LINE: 110;
+    /** Very short (task previews, badges) */
+    readonly SHORT: 40;
+};
+/** Standard expand hint text */
+export declare const EXPAND_HINT = "(Ctrl+O for more)";
+/**
+ * Get first N lines of text as preview, with each line truncated.
+ */
+export declare function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[];
+/**
+ * Extract domain from URL, stripping www. prefix.
+ */
+export declare function getDomain(url: string): string;
+export { formatAge, formatBytes, formatCount, formatDuration, pluralize } from "@oh-my-pi/pi-utils";
+/**
+ * Get the appropriate status icon with color for a given state.
+ * Standardizes status icon usage across all renderers.
+ */
+export declare function formatStatusIcon(status: ToolUIStatus, theme: Theme, spinnerFrame?: number): string;
+/**
+ * Format the expand hint with proper theming.
+ * Returns empty string if already expanded or there is nothing more to show.
+ */
+export declare function formatExpandHint(theme: Theme, expanded?: boolean, hasMore?: boolean): string;
+/**
+ * Format a badge like [done] or [failed] with brackets and color.
+ */
+export declare function formatBadge(label: string, color: ToolUIColor, theme: Theme): string;
+/**
+ * Build a "more items" suffix line for truncated lists.
+ * Uses consistent wording pattern.
+ */
+export declare function formatMoreItems(remaining: number, itemType: string): string;
+export declare function formatMeta(meta: string[], theme: Theme): string;
+export declare function formatErrorMessage(message: string | undefined, theme: Theme): string;
+export declare function formatEmptyMessage(message: string, theme: Theme): string;
+export type CodeFrameMarker = "" | " " | "*" | "+" | "-" | ">";
+export declare function formatCodeFrameLine(marker: CodeFrameMarker, lineNumber: string | number, content: string, lineNumberWidth: number): string;
+export type ToolUIStatus = "success" | "error" | "warning" | "info" | "pending" | "running" | "aborted";
+export type ToolUIColor = "success" | "error" | "warning" | "accent" | "muted";
+export interface ToolUITitleOptions {
+    bold?: boolean;
+}
+export declare function formatTitle(label: string, theme: Theme, options?: ToolUITitleOptions): string;
+export declare function formatDiagnostics(diag: {
+    errored: boolean;
+    summary: string;
+    messages: string[];
+}, expanded: boolean, theme: Theme, getLangIcon: (filePath: string) => string): string;
+export interface DiffStats {
+    added: number;
+    removed: number;
+    hunks: number;
+    lines: number;
+}
+export declare function getDiffStats(diffText: string): DiffStats;
+export declare function formatDiffStats(added: number, removed: number, hunks: number, theme: Theme): string;
+export declare function truncateDiffByHunk(diffText: string, maxHunks: number, maxLines: number): {
+    text: string;
+    hiddenHunks: number;
+    hiddenLines: number;
+};
+export declare function shortenPath(filePath: string, homeDir?: string): string;
+export declare function formatToolWorkingDirectory(workdir: string | undefined, projectDir: string): string | undefined;
+export declare function formatScreenshot(opts: {
+    saveFullRes: boolean;
+    savedMimeType: string;
+    savedByteLength: number;
+    dest: string;
+    resized: ResizedImage;
+}): string[];
+export declare function wrapBrackets(text: string, theme: Theme): string;
+export declare const PARSE_ERRORS_LIMIT = 20;
+export declare function dedupeParseErrors(errors: string[] | undefined): string[];
+export declare function formatParseErrors(errors: string[]): string[];
+/**
+ * Group `rawLines` by blank-line separators, mirroring the historical search /
+ * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
+ * runs of blank lines; otherwise collapses non-empty lines into a single group.
+ */
+export declare function splitGroupsByBlankLine(rawLines: string[]): string[][];
+/**
+ * Standard width+expand keyed render cache used by every search-style tool
+ * renderer. `compute` re-runs only when the cache key changes; the returned
+ * Component is the canonical `{ render, invalidate }` pair.
+ */
+export declare function createCachedComponent(getExpanded: () => boolean, compute: (width: number, expanded: boolean) => string[]): Component;
+/**
+ * Append the indented bullet list of parse errors (capped at
+ * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
+ * total exceeds the cap. No-op when `parseErrors` is empty.
+ */
+export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme): void;
+/**
+ * Human-readable summary string for the parse-issues count, capped by
+ * {@link PARSE_ERRORS_LIMIT}.
+ */
+export declare function formatParseErrorsCountLabel(parseErrors: readonly string[]): string;
+export interface LspBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined;

package/dist/types/tools/renderers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * TUI renderers for built-in tools.
+ *
+ * These provide rich visualization for tool calls and results in the TUI.
+ */
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+type ToolRenderer = {
+    renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
+    renderResult: (result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: unknown;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: Record<string, unknown>;
+    }, theme: Theme, args?: unknown) => Component;
+    mergeCallAndResult?: boolean;
+    /** Render without background box, inline in the response flow */
+    inline?: boolean;
+};
+export declare const toolRenderers: Record<string, ToolRenderer>;
+export {};

package/dist/types/tools/report-tool-issue.d.ts

@@ -0,0 +1,6 @@
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "..";
+import type { ToolSession } from "./index";
+export declare function isAutoQaEnabled(settings?: Settings): boolean;
+export declare function getAutoQaDbPath(): string;
+export declare function createReportToolIssueTool(session: ToolSession): AgentTool;

package/dist/types/tools/resolve.d.ts

@@ -0,0 +1,79 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+declare const resolveSchema: z.ZodObject<{
+    action: z.ZodUnion<readonly [z.ZodLiteral<"apply">, z.ZodLiteral<"discard">]>;
+    reason: z.ZodString;
+    extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type ResolveParams = z.infer<typeof resolveSchema>;
+export interface ResolveToolDetails {
+    action: "apply" | "discard";
+    reason: string;
+    extra?: Record<string, unknown>;
+    sourceToolName?: string;
+    label?: string;
+    sourceResultDetails?: unknown;
+}
+/**
+ * Queue a resolve-protocol handler on the tool-choice queue. Forces the next
+ * LLM call to invoke the hidden `resolve` tool, wraps the caller's apply/reject
+ * callbacks into an onInvoked closure that matches the resolve schema, and
+ * steers a preview reminder so the model understands why.
+ *
+ * This is the canonical entry point for any tool that wants preview/apply
+ * semantics. No session-level abstraction is needed: callers pass their
+ * apply/reject functions directly.
+ */
+export declare function queueResolveHandler(session: ToolSession, options: {
+    label: string;
+    sourceToolName: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): void;
+/**
+ * Shared invocation runner used by both queued (in-flight) handlers and
+ * standing handlers (e.g. plan-mode approval). Discriminates on action,
+ * routes through the caller's apply/reject, and wraps the resulting tool
+ * payload with `ResolveToolDetails` so the renderer and event-controller
+ * see a consistent shape.
+ */
+export declare function runResolveInvocation(params: ResolveParams, options: {
+    sourceToolName: string;
+    label: string;
+    apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
+    reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+}): Promise<AgentToolResult<ResolveToolDetails>>;
+export declare class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
+    private readonly session;
+    readonly name = "resolve";
+    readonly label = "Resolve";
+    readonly hidden = true;
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        action: z.ZodUnion<readonly [z.ZodLiteral<"apply">, z.ZodLiteral<"discard">]>;
+        reason: z.ZodString;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    readonly intent: (args: Partial<ResolveParams>) => string;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: ResolveParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<ResolveToolDetails>>;
+}
+export declare const resolveToolRenderer: {
+    renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: ResolveToolDetails;
+        isError?: boolean;
+    }, _options: RenderResultOptions, uiTheme: Theme): Component;
+    inline: boolean;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/review.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Review tools - report_finding for structured code review.
+ *
+ * Used by the reviewer agent to report findings in a structured way.
+ * Hidden by default - only enabled when explicitly listed in agent's tools.
+ * Reviewers finish via `yield` tool with SubmitReviewDetails schema.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import * as z from "zod/v4";
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+export type FindingPriority = "P0" | "P1" | "P2" | "P3";
+export interface FindingPriorityInfo {
+    ord: 0 | 1 | 2 | 3;
+    symbol: "status.error" | "status.warning" | "status.info";
+    color: ThemeColor;
+}
+export declare const PRIORITY_LABELS: FindingPriority[];
+export declare function getPriorityInfo(priority: FindingPriority): FindingPriorityInfo;
+declare const ReportFindingParams: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    priority: z.ZodEnum<{
+        P0: "P0";
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+    }>;
+    confidence: z.ZodNumber;
+    file_path: z.ZodString;
+    line_start: z.ZodNumber;
+    line_end: z.ZodNumber;
+}, z.core.$strict>;
+interface ReportFindingDetails {
+    title: string;
+    body: string;
+    priority: FindingPriority;
+    confidence: number;
+    file_path: string;
+    line_start: number;
+    line_end: number;
+}
+export declare function parseReportFindingDetails(value: unknown): ReportFindingDetails | undefined;
+export declare const reportFindingTool: AgentTool<typeof ReportFindingParams, ReportFindingDetails, Theme>;
+/** SubmitReviewDetails - used for rendering review results from yield tool */
+export interface SubmitReviewDetails {
+    overall_correctness: "correct" | "incorrect";
+    explanation: string;
+    confidence: number;
+}
+export type { ReportFindingDetails };

package/dist/types/tools/search-tool-bm25.d.ts

@@ -0,0 +1,65 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type DiscoverableTool } from "../tool-discovery/tool-index";
+import type { ToolSession } from ".";
+export type { DiscoverableMCPSearchIndex, DiscoverableMCPTool, } from "../mcp/discoverable-tool-metadata";
+declare const searchToolBm25Schema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
+interface SearchToolBm25Match {
+    name: string;
+    label: string;
+    description: string;
+    server_name?: string;
+    mcp_tool_name?: string;
+    schema_keys: string[];
+    score: number;
+}
+export interface SearchToolBm25Details {
+    query: string;
+    limit: number;
+    total_tools: number;
+    activated_tools: string[];
+    active_selected_tools: string[];
+    tools: SearchToolBm25Match[];
+}
+export declare function renderSearchToolBm25Description(discoverableTools?: DiscoverableTool[]): string;
+/**
+ * SearchToolsTool — wire name `search_tool_bm25` (preserved for persisted session back-compat).
+ *
+ * When tools.discoveryMode === "all", this covers both MCP tools and built-in discoverable tools.
+ * When tools.discoveryMode === "mcp-only" or mcp.discoveryMode === true, only MCP tools are searched.
+ */
+export declare class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema, SearchToolBm25Details> {
+    private readonly session;
+    readonly name = "search_tool_bm25";
+    readonly label = "SearchTools";
+    readonly loadMode = "essential";
+    get description(): string;
+    readonly parameters: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): SearchToolBm25Tool | null;
+    execute(_toolCallId: string, params: SearchToolBm25Params, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolBm25Details>, _context?: AgentToolContext): Promise<AgentToolResult<SearchToolBm25Details>>;
+}
+export declare const searchToolBm25Renderer: {
+    renderCall(args: SearchToolBm25Params, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolBm25Details;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme): Component;
+    mergeCallAndResult: boolean;
+    inline: boolean;
+};

package/dist/types/tools/search.d.ts

@@ -0,0 +1,90 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { type TruncationResult } from "../session/streaming-output";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const searchSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    i: z.ZodOptional<z.ZodBoolean>;
+    gitignore: z.ZodOptional<z.ZodBoolean>;
+    skip: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type SearchToolInput = z.infer<typeof searchSchema>;
+/** Maximum number of distinct files surfaced in a single response. The
+ * agent paginates further pages via `skip`. */
+export declare const DEFAULT_FILE_LIMIT = 20;
+/** Per-file match cap for multi-file searches — keeps a single hot file
+ * from crowding out diverse hits. Applied in JS after grep returns. */
+export declare const MULTI_FILE_PER_FILE_MATCHES = 20;
+/** Per-file match cap for single-file searches — there's no diversity
+ * concern when the scope is one file. */
+export declare const SINGLE_FILE_MATCHES = 200;
+export interface SearchToolDetails {
+    truncation?: TruncationResult;
+    fileLimitReached?: number;
+    perFileLimitReached?: number;
+    linesTruncated?: boolean;
+    meta?: OutputMeta;
+    scopePath?: string;
+    matchCount?: number;
+    fileCount?: number;
+    files?: string[];
+    fileMatches?: Array<{
+        path: string;
+        count: number;
+    }>;
+    truncated?: boolean;
+    error?: string;
+    /** Pre-formatted text for the user-visible TUI render. Mirrors the model-facing
+     * `result.text` lines but uses a `│` gutter and `*` to mark match lines (vs space for
+     * context). The TUI uses this directly so it never parses model-facing hashline anchors. */
+    displayContent?: string;
+    /** User-supplied paths whose base directory was missing on disk. The tool
+     * skipped these and continued with the surviving entries; surfaced as a
+     * non-fatal warning in the renderer and in the model-facing text. */
+    missingPaths?: string[];
+}
+type SearchParams = z.infer<typeof searchSchema>;
+export declare class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
+    private readonly session;
+    readonly name = "search";
+    readonly label = "Search";
+    readonly loadMode = "discoverable";
+    readonly summary = "Search file contents using ripgrep (fast text search)";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        pattern: z.ZodString;
+        paths: z.ZodArray<z.ZodString>;
+        i: z.ZodOptional<z.ZodBoolean>;
+        gitignore: z.ZodOptional<z.ZodBoolean>;
+        skip: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: SearchParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<SearchToolDetails>, _toolContext?: AgentToolContext): Promise<AgentToolResult<SearchToolDetails>>;
+}
+interface SearchRenderArgs {
+    pattern: string;
+    paths?: string[];
+    i?: boolean;
+    gitignore?: boolean;
+    skip?: number;
+}
+export declare const searchToolRenderer: {
+    inline: boolean;
+    renderCall(args: SearchRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SearchToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: SearchRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/sqlite-reader.d.ts

@@ -0,0 +1,93 @@
+import type { Database } from "bun:sqlite";
+export interface SqlitePathCandidate {
+    sqlitePath: string;
+    subPath: string;
+    queryString: string;
+}
+export type SqliteSelector = {
+    kind: "list";
+} | {
+    kind: "schema";
+    table: string;
+    sampleLimit: number;
+} | {
+    kind: "row";
+    table: string;
+    key: string;
+} | {
+    kind: "query";
+    table: string;
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+} | {
+    kind: "raw";
+    sql: string;
+};
+export type SqliteRowLookup = {
+    kind: "pk";
+    column: string;
+    type: string;
+} | {
+    kind: "rowid";
+};
+export declare function parseSqlitePathCandidates(filePath: string): SqlitePathCandidate[];
+export declare function isSqliteFile(absolutePath: string): Promise<boolean>;
+export declare function parseSqliteSelector(subPath: string, queryString: string): SqliteSelector;
+export declare function listTables(db: Database): {
+    name: string;
+    rowCount: number;
+}[];
+export declare function getTableSchema(db: Database, table: string): string;
+export declare function getTablePrimaryKey(db: Database, table: string): {
+    column: string;
+    type: string;
+} | null;
+export declare function resolveTableRowLookup(db: Database, table: string): SqliteRowLookup;
+export declare function queryRows(db: Database, table: string, opts: {
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+}): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    totalCount: number;
+};
+export declare function getRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): Record<string, unknown> | null;
+export declare function getRowByRowId(db: Database, table: string, key: string): Record<string, unknown> | null;
+export declare function executeReadQuery(db: Database, sql: string): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+};
+export declare function insertRow(db: Database, table: string, data: Record<string, unknown>): void;
+export declare function updateRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string, data: Record<string, unknown>): number;
+export declare function updateRowByRowId(db: Database, table: string, key: string, data: Record<string, unknown>): number;
+export declare function deleteRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): number;
+export declare function deleteRowByRowId(db: Database, table: string, key: string): number;
+export declare function renderTableList(tables: {
+    name: string;
+    rowCount: number;
+}[]): string;
+export declare function renderSchema(createSql: string, sampleRows: {
+    columns: string[];
+    rows: Record<string, unknown>[];
+}): string;
+export declare function renderRow(row: Record<string, unknown>): string;
+export declare function renderTable(columns: string[], rows: Record<string, unknown>[], meta: {
+    totalCount: number;
+    offset: number;
+    limit: number;
+    table: string;
+    dbPath: string;
+}): string;

package/dist/types/tools/ssh.d.ts

@@ -0,0 +1,67 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import * as z from "zod/v4";
+import type { SSHHost } from "../capability/ssh";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const sshSchema: z.ZodObject<{
+    host: z.ZodString;
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>;
+export interface SSHToolDetails {
+    meta?: OutputMeta;
+}
+type SshToolParams = z.infer<typeof sshSchema>;
+export declare class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
+    #private;
+    private readonly session;
+    private readonly hostNames;
+    private readonly hostsByName;
+    readonly description: string;
+    readonly name = "ssh";
+    readonly summary = "Execute a command on a remote host over SSH";
+    readonly loadMode = "discoverable";
+    readonly label = "SSH";
+    readonly parameters: z.ZodObject<{
+        host: z.ZodString;
+        command: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    constructor(session: ToolSession, hostNames: string[], hostsByName: Map<string, SSHHost>, description: string);
+    execute(_toolCallId: string, { host, command, cwd, timeout: rawTimeout }: SshToolParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SSHToolDetails>, _ctx?: AgentToolContext): Promise<AgentToolResult<SSHToolDetails>>;
+}
+export declare function loadSshTool(session: ToolSession): Promise<SshTool | null>;
+interface SshRenderArgs {
+    host?: string;
+    command?: string;
+    timeout?: number;
+}
+interface SshRenderContext {
+    /** Visual lines for truncated output (pre-computed by tool-execution) */
+    visualLines?: string[];
+    /** Number of lines skipped */
+    skippedCount?: number;
+    /** Total visual lines */
+    totalVisualLines?: number;
+}
+export declare const sshToolRenderer: {
+    renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SSHToolDetails;
+    }, options: RenderResultOptions & {
+        renderContext?: SshRenderContext;
+    }, uiTheme: Theme, args?: SshRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};