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

package/dist/types/tools/todo-write.d.ts

@@ -0,0 +1,120 @@
+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 "../sdk";
+import type { SessionEntry } from "../session/session-manager";
+export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+    /**
+     * Append-only list of freeform notes attached by `op: "note"`.
+     * Each element is one note and may itself be multi-line.
+     * Rendered as text only when the task is in_progress; otherwise shown as a
+     * dim marker indicating the task has notes.
+     */
+    notes?: string[];
+}
+export interface TodoPhase {
+    name: string;
+    tasks: TodoItem[];
+}
+export interface TodoWriteToolDetails {
+    phases: TodoPhase[];
+    storage: "session" | "memory";
+}
+declare const todoWriteSchema: z.ZodObject<{
+    ops: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            append: "append";
+            done: "done";
+            drop: "drop";
+            init: "init";
+            note: "note";
+            rm: "rm";
+            start: "start";
+        }>;
+        list: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            phase: z.ZodString;
+            items: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        task: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodString>;
+        items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type TodoWriteParams = z.infer<typeof todoWriteSchema>;
+export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
+export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
+/** Apply an array of `todo_write`-style ops to existing phases. Used by /todo slash command. */
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoWriteParams["ops"]): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+/** Render todo phases as a Markdown checklist suitable for editing/copying. */
+export declare function phasesToMarkdown(phases: TodoPhase[]): string;
+/** Parse a Markdown checklist back into todo phases. */
+export declare function markdownToPhases(md: string): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+export declare class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWriteToolDetails> {
+    private readonly session;
+    readonly name = "todo_write";
+    readonly label = "Todo Write";
+    readonly summary = "Write a structured todo list to track progress within a session";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        ops: z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                append: "append";
+                done: "done";
+                drop: "drop";
+                init: "init";
+                note: "note";
+                rm: "rm";
+                start: "start";
+            }>;
+            list: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                phase: z.ZodString;
+                items: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+            task: z.ZodOptional<z.ZodString>;
+            phase: z.ZodOptional<z.ZodString>;
+            items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: TodoWriteParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoWriteToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoWriteToolDetails>>;
+}
+type TodoWriteRenderArgs = {
+    ops?: Array<{
+        op?: string;
+        task?: string;
+        phase?: string;
+        items?: string[];
+    }>;
+};
+/** One-based ASCII roman numeral for display (I, II, III, IV, …). */
+export declare function phaseRomanNumeral(oneBasedIndex: number): string;
+/** Display-only phase header: `I. Foundation`. State and prompts never see this. */
+export declare function formatPhaseDisplayName(name: string, oneBasedIndex: number): string;
+export declare const todoWriteToolRenderer: {
+    renderCall(args: TodoWriteRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: TodoWriteToolDetails;
+    }, options: RenderResultOptions, uiTheme: Theme, _args?: TodoWriteRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/tool-errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Standardized error types for tool execution.
+ *
+ * Tools should throw these instead of returning error text.
+ * The agent loop catches and renders them appropriately.
+ */
+/**
+ * Base error for tool execution failures.
+ * Override render() for custom LLM-facing formatting.
+ */
+export declare class ToolError extends Error {
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, context?: Record<string, unknown> | undefined);
+    /** Render error for LLM consumption. Override for custom formatting. */
+    render(): string;
+}
+/**
+ * Error thrown when a tool operation is aborted (e.g., via AbortSignal).
+ */
+export declare class ToolAbortError extends Error {
+    static readonly MESSAGE = "Operation aborted";
+    constructor(message?: string);
+}
+/**
+ * Throw ToolAbortError if the signal is aborted.
+ * Use this instead of signal?.throwIfAborted() to get consistent error types.
+ */
+export declare function throwIfAborted(signal?: AbortSignal): void;
+/**
+ * Render an error for LLM consumption.
+ * Handles ToolError.render() and falls back to message/string.
+ */
+export declare function renderError(e: unknown): string;

package/dist/types/tools/tool-result.d.ts

@@ -0,0 +1,30 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
+type ToolContent = Array<TextContent | ImageContent>;
+type DetailsWithMeta = {
+    meta?: OutputMeta;
+};
+export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
+    #private;
+    constructor(details?: TDetails);
+    text(text: string): this;
+    content(content: ToolContent): this;
+    truncation(result: TruncationResult, options: TruncationOptions): this;
+    truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
+    truncationFromText(text: string, options: TruncationTextOptions): this;
+    limits(limits: {
+        matchLimit?: number;
+        resultLimit?: number;
+        headLimit?: number;
+        columnMax?: number;
+    }): this;
+    sourceUrl(value: string): this;
+    sourcePath(value: string): this;
+    sourceInternal(value: string): this;
+    diagnostics(summary: string, messages: string[]): this;
+    done(): AgentToolResult<TDetails>;
+}
+export declare function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails>;
+export {};

package/dist/types/tools/tool-timeouts.d.ts

@@ -0,0 +1,51 @@
+export interface ToolTimeoutConfig {
+    /** Default timeout in seconds when agent omits the field */
+    default: number;
+    /** Minimum allowed timeout in seconds */
+    min: number;
+    /** Maximum allowed timeout in seconds (per-tool ceiling) */
+    max: number;
+}
+export declare const TOOL_TIMEOUTS: {
+    readonly bash: {
+        readonly default: 300;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly eval: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 600;
+    };
+    readonly browser: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 30;
+    };
+    readonly ssh: {
+        readonly default: 60;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly fetch: {
+        readonly default: 20;
+        readonly min: 1;
+        readonly max: 45;
+    };
+    readonly lsp: {
+        readonly default: 20;
+        readonly min: 5;
+        readonly max: 60;
+    };
+    readonly debug: {
+        readonly default: 30;
+        readonly min: 5;
+        readonly max: 300;
+    };
+};
+export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;
+/**
+ * Clamp a raw timeout to the allowed range for a tool.
+ * If rawTimeout is undefined, returns the tool's default.
+ */
+export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number): number;

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

@@ -0,0 +1,58 @@
+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 { VimToolDetails } from "../vim/types";
+import type { ToolSession } from ".";
+declare const vimSchema: z.ZodObject<{
+    file: z.ZodString;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kbd: z.ZodArray<z.ZodString>;
+        insert: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    pause: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type VimParams = z.infer<typeof vimSchema>;
+interface VimRenderStep {
+    kbd?: string[];
+    insert?: string;
+}
+export interface VimRenderArgs {
+    file?: string;
+    steps?: VimRenderStep[];
+    pause?: boolean;
+    __partialJson?: string;
+}
+export declare class VimTool implements AgentTool<typeof vimSchema, VimToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "vim";
+    readonly label = "Vim";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        file: z.ZodString;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kbd: z.ZodArray<z.ZodString>;
+            insert: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        pause: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly concurrency = "exclusive";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: VimParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<VimToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<VimToolDetails>>;
+}
+export declare function resetVimRendererStateForTest(): void;
+export declare const vimToolRenderer: {
+    renderCall(args: VimRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: VimToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme): Component;
+    mergeCallAndResult: boolean;
+};
+export { vimSchema };

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

@@ -0,0 +1,59 @@
+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 FileDiagnosticsResult } from "../lsp";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import { type OutputMeta } from "./output-meta";
+declare const writeSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type WriteToolInput = z.infer<typeof writeSchema>;
+/** Details returned by the write tool for TUI rendering */
+export interface WriteToolDetails {
+    diagnostics?: FileDiagnosticsResult;
+    meta?: OutputMeta;
+}
+type WriteParams = WriteToolInput;
+/**
+ * Write tool implementation.
+ *
+ * Creates or overwrites files with optional LSP formatting and diagnostics.
+ */
+export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "write";
+    readonly label = "Write";
+    readonly description: string;
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    readonly nonAbortable = true;
+    readonly strict = true;
+    readonly concurrency = "exclusive";
+    readonly loadMode = "discoverable";
+    readonly summary = "Write content to a file (creates or overwrites)";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, { path, content }: WriteParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
+}
+interface WriteRenderArgs {
+    path?: string;
+    file_path?: string;
+    content?: string;
+}
+export declare const writeToolRenderer: {
+    renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: WriteToolDetails;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: WriteRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * Submit result tool for structured subagent output.
+ *
+ * Subagents must call this tool to finish and return structured JSON output.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { TSchema } from "@oh-my-pi/pi-ai/types";
+import type { ToolSession } from ".";
+export interface YieldDetails {
+    data: unknown;
+    status: "success" | "aborted";
+    error?: string;
+}
+export declare class YieldTool implements AgentTool<TSchema, YieldDetails> {
+    #private;
+    readonly name = "yield";
+    readonly label = "Submit Result";
+    readonly description: string;
+    readonly parameters: TSchema;
+    strict: boolean;
+    readonly intent: "omit";
+    lenientArgValidation: boolean;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: unknown, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<YieldDetails>, _context?: AgentToolContext): Promise<AgentToolResult<YieldDetails>>;
+}

package/dist/types/tui/code-cell.d.ts

@@ -0,0 +1,32 @@
+import { type Theme } from "../modes/theme/theme";
+export interface CodeCellOptions {
+    code: string;
+    language?: string;
+    index?: number;
+    total?: number;
+    title?: string;
+    status?: "pending" | "running" | "warning" | "complete" | "error";
+    spinnerFrame?: number;
+    duration?: number;
+    output?: string;
+    outputMaxLines?: number;
+    codeMaxLines?: number;
+    expanded?: boolean;
+    width: number;
+}
+export declare function renderCodeCell(options: CodeCellOptions, theme: Theme): string[];
+export interface MarkdownCellOptions {
+    content: string;
+    index?: number;
+    total?: number;
+    title?: string;
+    status?: "pending" | "running" | "warning" | "complete" | "error";
+    spinnerFrame?: number;
+    duration?: number;
+    output?: string;
+    outputMaxLines?: number;
+    contentMaxLines?: number;
+    expanded?: boolean;
+    width: number;
+}
+export declare function renderMarkdownCell(options: MarkdownCellOptions, theme: Theme): string[];

package/dist/types/tui/file-list.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Render file listings with optional icons and metadata.
+ */
+import type { Theme } from "../modes/theme/theme";
+export interface FileEntry {
+    path: string;
+    isDirectory?: boolean;
+    meta?: string;
+}
+export interface FileListOptions {
+    files: FileEntry[];
+    expanded?: boolean;
+    maxCollapsed?: number;
+    showIcons?: boolean;
+}
+export declare function renderFileList(options: FileListOptions, theme: Theme): string[];

package/dist/types/tui/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Public exports for shared TUI components.
+ */
+export * from "./code-cell";
+export * from "./file-list";
+export * from "./output-block";
+export * from "./status-line";
+export * from "./tree-list";
+export * from "./types";
+export * from "./utils";

package/dist/types/tui/output-block.d.ts

@@ -0,0 +1,28 @@
+import type { Theme } from "../modes/theme/theme";
+import type { State } from "./types";
+export interface OutputBlockOptions {
+    header?: string;
+    headerMeta?: string;
+    state?: State;
+    sections?: Array<{
+        label?: string;
+        lines: string[];
+    }>;
+    width: number;
+    applyBg?: boolean;
+}
+export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
+/**
+ * Cached wrapper around `renderOutputBlock`.
+ *
+ * Since output blocks are re-rendered on every frame (via `render(width)` closures),
+ * but their content rarely changes, this cache avoids redundant `visibleWidth()` and
+ * `padding()` computations on ~99% of render calls.
+ */
+export declare class CachedOutputBlock {
+    #private;
+    /** Render with caching. Returns cached result if options haven't changed. */
+    render(options: OutputBlockOptions, theme: Theme): string[];
+    /** Invalidate the cache, forcing a rebuild on next render. */
+    invalidate(): void;
+}

package/dist/types/tui/status-line.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Standardized status header rendering for tool output.
+ */
+import type { Theme, ThemeColor } from "../modes/theme/theme";
+import type { ToolUIStatus } from "../tools/render-utils";
+export interface StatusLineOptions {
+    icon?: ToolUIStatus;
+    spinnerFrame?: number;
+    title: string;
+    titleColor?: ThemeColor;
+    description?: string;
+    badge?: {
+        label: string;
+        color: ThemeColor;
+    };
+    meta?: string[];
+}
+export declare function renderStatusLine(options: StatusLineOptions, theme: Theme): string;

package/dist/types/tui/tree-list.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hierarchical tree list rendering helper.
+ */
+import type { Theme } from "../modes/theme/theme";
+import type { TreeContext } from "./types";
+export interface TreeListOptions<T> {
+    items: T[];
+    expanded?: boolean;
+    maxCollapsed?: number;
+    /** Strict total-line budget for collapsed mode. When set (and not expanded),
+     *  rendered item lines plus the trailing summary line must fit within this budget.
+     */
+    maxCollapsedLines?: number;
+    itemType?: string;
+    /** Called once per item with `isLast: false` during budget calculation;
+     *  line count MUST NOT vary based on `isLast`. */
+    renderItem: (item: T, context: TreeContext) => string | string[];
+}
+export declare function renderTreeList<T>(options: TreeListOptions<T>, theme: Theme): string[];

package/dist/types/tui/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared types for TUI rendering components.
+ */
+import type { Theme } from "../modes/theme/theme";
+export type State = "pending" | "running" | "success" | "error" | "warning";
+export interface TreeContext {
+    index: number;
+    isLast: boolean;
+    depth: number;
+    theme: Theme;
+    prefix: string;
+    continuePrefix: string;
+}

package/dist/types/tui/utils.d.ts

@@ -0,0 +1,36 @@
+import type { Theme, ThemeBg } from "../modes/theme/theme";
+import type { State } from "./types";
+export { Ellipsis, truncateToWidth } from "@oh-my-pi/pi-tui";
+/**
+ * Incremental xxHash64 key builder.
+ *
+ * Chains `Bun.hash.xxHash64` calls via seeding — each fed value
+ * mixes into the running hash without intermediate string allocations.
+ * Accepts strings, numbers (u32), booleans, bigints, and `undefined`/`null`
+ * (hashed as a sentinel byte) natively.
+ */
+export declare class Hasher {
+    #private;
+    /** Feed a string. */
+    str(s: string): this;
+    /** Feed an unsigned 32-bit integer. */
+    u32(n: number): this;
+    /** Feed a 64-bit bigint. */
+    u64(n: bigint): this;
+    /** Feed a boolean (single byte: 1 = true, 0 = false). */
+    bool(b: boolean): this;
+    /** Feed a value that may be `undefined` or `null` (hashed as a 0xFF sentinel byte). */
+    optional(v: string | undefined | null): this;
+    /** Return the final hash digest. */
+    digest(): bigint;
+}
+/** Render-cache entry used by tool renderers. */
+export interface RenderCache {
+    key: bigint;
+    lines: string[];
+}
+export declare function buildTreePrefix(ancestors: boolean[], theme: Theme): string;
+export declare function getTreeBranch(isLast: boolean, theme: Theme): string;
+export declare function getTreeContinuePrefix(isLast: boolean, theme: Theme): string;
+export declare function padToWidth(text: string, width: number, bgFn?: (s: string) => string): string;
+export declare function getStateBgColor(state: State): ThemeBg;

package/dist/types/utils/changelog.d.ts

@@ -0,0 +1,20 @@
+export interface ChangelogEntry {
+    major: number;
+    minor: number;
+    patch: number;
+    content: string;
+}
+/**
+ * Parse changelog entries from CHANGELOG.md
+ * Scans for ## lines and collects content until next ## or EOF
+ */
+export declare function parseChangelog(changelogPath: string): Promise<ChangelogEntry[]>;
+/**
+ * Compare versions. Returns: -1 if v1 < v2, 0 if v1 === v2, 1 if v1 > v2
+ */
+export declare function compareVersions(v1: ChangelogEntry, v2: ChangelogEntry): number;
+/**
+ * Get entries newer than lastVersion
+ */
+export declare function getNewEntries(entries: ChangelogEntry[], lastVersion: string): ChangelogEntry[];
+export { getChangelogPath } from "../config";

package/dist/types/utils/clipboard.d.ts

@@ -0,0 +1,20 @@
+import type { ClipboardImage } from "@oh-my-pi/pi-natives";
+/**
+ * Copy text to the system clipboard.
+ *
+ * Emits OSC 52 first when running in a real terminal (works over SSH/mosh),
+ * then attempts native clipboard copy as best-effort for local sessions.
+ * On Termux, tries `termux-clipboard-set` before native.
+ *
+ * @param text - UTF-8 text to place on the clipboard.
+ */
+export declare function copyToClipboard(text: string): Promise<void>;
+/**
+ * Read an image from the system clipboard.
+ *
+ * Returns null on Termux (no image clipboard support) or when no display
+ * server is available (headless/SSH without forwarding).
+ *
+ * @returns PNG payload or null when no image is available.
+ */
+export declare function readImageFromClipboard(): Promise<ClipboardImage | null>;

package/dist/types/utils/command-args.d.ts

@@ -0,0 +1,9 @@
+export declare function parseCommandArgs(argsString: string): string[];
+/**
+ * Substitute argument placeholders in template content
+ * Supports $1, $2, ... for positional args, $@ and $ARGUMENTS for all args
+ *
+ * Note: Replacement happens on the template string only. Argument values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export declare function substituteArgs(content: string, args: string[]): string;

package/dist/types/utils/commit-message-generator.d.ts

@@ -0,0 +1,7 @@
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+/**
+ * Generate a commit message from a unified diff.
+ * Returns null if generation fails (caller should fall back to generic message).
+ */
+export declare function generateCommitMessage(diff: string, registry: ModelRegistry, settings: Settings, sessionId?: string): Promise<string | null>;

package/dist/types/utils/edit-mode.d.ts

@@ -0,0 +1,13 @@
+export type EditMode = "replace" | "patch" | "hashline" | "vim" | "apply_patch";
+export declare const DEFAULT_EDIT_MODE: EditMode;
+export declare const EDIT_MODES: EditMode[];
+export declare function normalizeEditMode(mode?: string | null): EditMode | undefined;
+export interface EditModeSettingsLike {
+    get(key: "edit.mode"): unknown;
+    getEditVariantForModel?(model: string | undefined): EditMode | null;
+}
+export interface EditModeSessionLike {
+    settings: EditModeSettingsLike;
+    getActiveModelString?: () => string | undefined;
+}
+export declare function resolveEditMode(session: EditModeSessionLike): EditMode;

package/dist/types/utils/event-bus.d.ts

@@ -0,0 +1,6 @@
+export declare class EventBus {
+    #private;
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: (data: unknown) => void): () => void;
+    clear(): void;
+}

package/dist/types/utils/external-editor.d.ts

@@ -0,0 +1,17 @@
+/** Returns the user's preferred editor command, or undefined if not configured. */
+export declare function getEditorCommand(): string | undefined;
+export interface OpenInEditorOptions {
+    /** File extension for the temp file (default: ".md"). */
+    extension?: string;
+    /** Custom stdio configuration (default: all "inherit"). */
+    stdio?: [number | "inherit", number | "inherit", number | "inherit"];
+    /** Keep the file's trailing newline instead of trimming it from the returned text. */
+    trimTrailingNewline?: boolean;
+}
+/**
+ * Opens `content` in the user's external editor and returns the edited text.
+ * Returns `null` if the editor exits with a non-zero code.
+ *
+ * The caller is responsible for stopping/starting the TUI around this call.
+ */
+export declare function openInEditor(editorCmd: string, content: string, options?: OpenInEditorOptions): Promise<string | null>;