@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/dist/types/tools/conflict-detect.d.ts

@@ -0,0 +1,43 @@
+/** Recorded merge-conflict region. */
+export interface ConflictBlock {
+    /** 1-indexed line of the `<<<<<<<` marker. */
+    startLine: number;
+    /** 1-indexed line of the `=======` separator. */
+    separatorLine: number;
+    /** 1-indexed line of the `>>>>>>>` marker. */
+    endLine: number;
+    /** 1-indexed line of the `|||||||` base marker (diff3 only). */
+    baseLine?: number;
+    oursLabel?: string;
+    baseLabel?: string;
+    theirsLabel?: string;
+    oursLines: string[];
+    baseLines?: string[];
+    theirsLines: string[];
+}
+/** Recorded merge-conflict identity and paths. */
+export interface ConflictEntry extends ConflictBlock {
+    id: number;
+    absolutePath: string;
+    displayPath: string;
+}
+/** A selectable side of a recorded conflict. */
+export type ConflictScope = "ours" | "theirs" | "base";
+/**
+ * Materialise a conflict block for `conflict://<N>` reads (and their
+ * `/ours` / `/theirs` / `/base` scopes).
+ *
+ * Returns:
+ * - `lines`: the lines to render, ordered top-to-bottom.
+ * - `startLine`: the 1-indexed file line number `lines[0]` corresponds
+ *   to, so the read formatter can label hashline anchors with the
+ *   original file positions.
+ *
+ * Bare (no scope) returns the full block including marker lines. A
+ * scoped view returns only that side's body — `base` throws when the
+ * recorded conflict is a 2-way merge with no base section.
+ */
+export declare function renderConflictRegion(entry: ConflictEntry, scope: ConflictScope | undefined): {
+    lines: string[];
+    startLine: number;
+};

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

@@ -0,0 +1,60 @@
+import type { Component } from "../tui.js";
+import type { Theme } from "../theme/theme.js";
+import type { RenderResultOptions } from "./renderer.js";
+/** Display fields captured from a debugger session. */
+export interface DebugSessionSnapshot {
+    id: string;
+    adapter: string;
+    status: string;
+    cwd: string;
+    program?: string;
+    stopReason?: string;
+    frameName?: string;
+    instructionPointerReference?: string;
+    source?: {
+        path?: string;
+    };
+    line?: number;
+    column?: number;
+    needsConfigurationDone: boolean;
+    exitCode?: number;
+}
+/** Debug execution metadata consumed by the transcript. */
+export interface DebugToolDetails {
+    action: string;
+    success: boolean;
+    snapshot?: DebugSessionSnapshot;
+}
+/** Debug arguments used to describe a pending request. */
+export interface DebugRenderArgs {
+    action?: string;
+    program?: string;
+    file?: string;
+    line?: number;
+    function?: string;
+    expression?: string;
+    command?: string;
+    memory_reference?: string;
+    instruction_reference?: string;
+    data_id?: string;
+    name?: string;
+}
+/** Formats a debugger stop location as a source path and coordinates. */
+export declare function formatLocation(snapshot: DebugSessionSnapshot | undefined): string | null;
+/** Formats the debugger session snapshot for model and terminal output. */
+export declare function formatSessionSnapshot(snapshot: DebugSessionSnapshot): string[];
+/** Renders debugger calls and captured execution snapshots. */
+export declare const debugToolRenderer: {
+    animatedPartialResult: true;
+    renderCall(args: DebugRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: DebugToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, theme: Theme, args?: DebugRenderArgs): Component;
+    mergeCallAndResult: true;
+    inline: true;
+};

package/dist/types/tools/default-renderer.d.ts

@@ -0,0 +1,24 @@
+import type { Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { Theme } from "../theme/theme.js";
+/** Inputs rendered by the fallback card used when a tool has no bespoke renderer. */
+export interface DefaultToolRenderInput {
+    /** Human-readable tool label. */
+    label: string;
+    /** Tool arguments, shown inline when collapsed and as a tree when expanded. */
+    args: unknown;
+    /** Settled or streaming result; omitted while only the call is available. */
+    result?: {
+        output: string;
+        isError?: boolean;
+        /** Synthetic placeholder for a call skipped mid-batch to service steering/peer
+         * input — the tool never ran, so it renders neutral (info) rather than as an error. */
+        skipped?: boolean;
+    };
+    /** Current expansion and lifecycle state. */
+    options: RenderResultOptions;
+}
+/** Format one generic tool call/result card at the available content width. */
+export declare function formatDefaultToolExecution(input: DefaultToolRenderInput, contentWidth: number, uiTheme: Theme): string;
+/** Render the generic fallback as the state-tinted card used by direct custom tools. */
+export declare function renderDefaultToolExecution(input: DefaultToolRenderInput, uiTheme: Theme): Component;

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

@@ -0,0 +1,158 @@
+/**
+ * Edit tool renderer.
+ */
+import type { Component } from "../tui.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { FileDiagnosticsResult } from "./lsp.js";
+import type { Theme } from "../theme/theme.js";
+import type { OutputMeta } from "./output-meta.js";
+import type { ToolActivityContext, ToolActivitySummary } from "./renderer.js";
+/** Edit payload syntax selected by the caller. */
+export type EditMode = "replace" | "patch" | "hashline" | "apply_patch" | "sloppy";
+/** Filesystem operation represented by an edit. */
+export type Operation = "create" | "delete" | "update";
+/** Computed streaming diff or preview error for one file. */
+export interface PerFileDiffPreview {
+    path: string;
+    diff?: string;
+    firstChangedLine?: number;
+    error?: string;
+}
+type EditDiffPreview = {
+    diff: string;
+    firstChangedLine?: number;
+} | {
+    error: string;
+    diff?: undefined;
+    firstChangedLine?: undefined;
+};
+/** Result metadata for one edited file. */
+export interface EditToolPerFileResult {
+    path: string;
+    diff: string;
+    firstChangedLine?: number;
+    diagnostics?: FileDiagnosticsResult;
+    op?: Operation;
+    move?: string;
+    isError?: boolean;
+    errorText?: string;
+    /** TUI-friendly error text. When present, rendered to the user instead of `errorText`.
+     * Set when the underlying error carries a `displayMessage` (e.g. {@link HashlineMismatchError}). */
+    displayErrorText?: string;
+    meta?: OutputMeta;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+/** Diff, diagnostics, and snapshots returned by an edit. */
+export interface EditToolDetails {
+    /** Unified diff of the changes made */
+    diff: string;
+    /** Line number of the first change in the new file (for editor navigation) */
+    firstChangedLine?: number;
+    /** Diagnostic result (if available) */
+    diagnostics?: FileDiagnosticsResult;
+    /** Operation type (patch mode only) */
+    op?: Operation;
+    /** New path after move/rename (patch mode only) */
+    move?: string;
+    /** Structured output metadata */
+    meta?: OutputMeta;
+    /** Per-file results (multi-file edits) */
+    perFileResults?: EditToolPerFileResult[];
+    /** Absolute file path for single-file edit results. Required by ACP diff metadata consumers. */
+    path?: string;
+    /** Source-of-truth content before the edit; `undefined` for create operations. */
+    oldText?: string;
+    /** Source-of-truth content after the edit; `undefined` for delete operations. */
+    newText?: string;
+    /** True when {@link pruneOversizedEditSnapshots} dropped `oldText`/`newText` from this entry. Aggregators check this to suppress misleading combined snapshots when at least one entry of a multi-entry single-path edit was pruned. */
+    snapshotsPruned?: boolean;
+    /** Pre-move source path; set only when the edit moved/renamed the file. The header renders `sourcePath → path`. */
+    sourcePath?: string;
+}
+/** Memoized native inspection of the streamed payload, tagged onto the args it came from. */
+declare const kInspectedInput: unique symbol;
+type InspectedInput = {
+    mode: EditMode;
+    input: string;
+} & ({
+    entries: InspectedInputEntry[];
+    error?: undefined;
+} | {
+    entries?: undefined;
+    error: unknown;
+});
+interface EditRenderArgs {
+    path?: unknown;
+    file_path?: unknown;
+    oldText?: string;
+    newText?: string;
+    patch?: string;
+    input?: string;
+    _input?: string;
+    replace_all?: boolean;
+    op?: Operation;
+    rename?: unknown;
+    diff?: string;
+    /**
+     * Computed preview diff (used when tool args don't include a diff, e.g. hashline mode).
+     */
+    previewDiff?: string;
+    __partialJson?: string;
+    edits?: EditRenderEntry[];
+    [kInspectedInput]?: InspectedInput;
+}
+type EditRenderEntry = {
+    path?: unknown;
+    rename?: unknown;
+    move?: unknown;
+    op?: Operation;
+};
+interface InspectedInputEntry {
+    path: string;
+    op?: Operation;
+    rename?: string;
+}
+/** Extended context for edit tool rendering */
+export interface EditRenderContext {
+    /** Edit mode resolved by the caller; lets the renderer dispatch without shape-sniffing */
+    editMode?: EditMode;
+    /** Pre-computed diff preview (computed before tool executes) */
+    editDiffPreview?: EditDiffPreview;
+    /** Multi-file streaming diff preview (edits spanning several files) */
+    perFileDiffPreview?: PerFileDiffPreview[];
+    /** Raw in-flight edit text shown while a computed diff preview is unavailable */
+    editStreamingFallback?: string;
+    /** Function to render diff text with syntax highlighting */
+    renderDiff?: (diffText: string, options?: {
+        filePath?: string;
+    }) => string;
+}
+/** Render replacement text until a computed diff preview is available. */
+export declare function renderStreamingFallback(editMode: EditMode, args: unknown, theme: Theme): string;
+/** Render edit previews and completed file diffs. */
+export declare const editToolRenderer: {
+    mergeCallAndResult: true;
+    /** Compact one-line activity: operation + target path instead of the payload's first line. */
+    activitySummary(args: unknown, context: ToolActivityContext): ToolActivitySummary;
+    renderCall(args: EditRenderArgs, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: EditToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: EditRenderContext;
+    }, uiTheme: Theme, args?: EditRenderArgs): Component;
+};
+export {};

package/dist/types/tools/eval-format/code-mode-declarations.d.ts

@@ -0,0 +1,5 @@
+/** Format tool schemas as TypeScript declarations for code-mode discovery. */
+export declare function generateCodeModeDeclarations(tools: ReadonlyArray<{
+    name: string;
+    parameters: unknown;
+}>): string;

package/dist/types/tools/eval-format/index.d.ts

@@ -0,0 +1,5 @@
+import type { EvalLanguage } from "../eval.js";
+export * from "./javascript.js";
+export * from "./python.js";
+/** Formats an arbitrary eval-code prefix for display without changing the executed source. */
+export declare function formatEvalCodeForDisplay(source: string, language: EvalLanguage): string;

package/dist/types/tools/eval-format/javascript.d.ts

@@ -0,0 +1,2 @@
+/** Formats JavaScript/TypeScript-like eval source for safe, stable display without requiring valid syntax. */
+export declare function formatJavaScriptForDisplay(source: string): string;

package/dist/types/tools/eval-format/python.d.ts

@@ -0,0 +1,2 @@
+/** Formats an arbitrary Python source prefix for stable, readable display. */
+export declare function formatPythonForDisplay(source: string): string;

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

@@ -0,0 +1,94 @@
+import type { Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import { type Theme } from "../theme/theme.js";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import type { OutputMeta } from "./output-meta.js";
+import type { ConfiguredThinkingLevel } from "../render/render-utils.js";
+/** Runtime backend that an eval cell dispatches to. */
+export type EvalLanguage = "python" | "js";
+/** Status event emitted by eval prelude helpers for TUI rendering. */
+export interface EvalStatusEvent {
+    op: string;
+    /** Validated thinking level supplied by the execution layer. */
+    resolvedThinkingLevel?: ConfiguredThinkingLevel;
+    [key: string]: unknown;
+}
+/** Per-cell execution result for transcript rendering. */
+export interface EvalCellResult {
+    index: number;
+    title?: string;
+    code: string;
+    language?: EvalLanguage;
+    output: string;
+    status: "pending" | "running" | "complete" | "error";
+    durationMs?: number;
+    exitCode?: number;
+    statusEvents?: EvalStatusEvent[];
+    hasMarkdown?: boolean;
+}
+/** Tool result detail object surfaced to the UI/transcript. */
+export interface EvalToolDetails {
+    cells?: EvalCellResult[];
+    jsonOutputs?: unknown[];
+    images?: ImageContent[];
+    statusEvents?: EvalStatusEvent[];
+    isError?: boolean;
+    meta?: OutputMeta;
+    /** First backend that produced cells. Kept for transcript compatibility. */
+    language?: EvalLanguage;
+    /** Backends that produced cells in this call, in first-use order. */
+    languages?: EvalLanguage[];
+    /** Optional human-readable notice (e.g. fallback explanation). */
+    notice?: string;
+    /** Present when the cell was auto-backgrounded as an async job. */
+    async?: {
+        state: "running" | "completed" | "failed";
+        jobId: string;
+        type: "eval";
+    };
+}
+/** Default collapsed eval output preview height; kept as a named alias (consumed by chat/tool-execution). */
+export declare const EVAL_DEFAULT_PREVIEW_LINES: number;
+interface EvalRenderCellArg {
+    language?: string;
+    code?: string;
+    title?: string;
+}
+interface EvalRenderArgs {
+    language?: string;
+    code?: string;
+    title?: string;
+    cells?: EvalRenderCellArg[];
+    __partialJson?: string;
+}
+interface EvalRenderContext {
+    output?: string;
+    expanded?: boolean;
+    previewLines?: number;
+    timeout?: number;
+}
+/**
+ * Append or replace a status event. `agent` events are progress snapshots keyed
+ * by `id`, so they coalesce in place (preserving first-seen order); every other
+ * op is a discrete action and simply appends. Keeps the persisted event list
+ * bounded even when a subagent emits hundreds of throttled progress ticks.
+ */
+export declare function upsertStatusEvent(events: EvalStatusEvent[], event: EvalStatusEvent): void;
+/** Render eval code cells, structured display output, and progress events. */
+export declare const evalToolRenderer: {
+    animatedPendingPreview: true;
+    animatedPartialResult: true;
+    renderCall(args: EvalRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: EvalToolDetails;
+    }, options: RenderResultOptions & {
+        renderContext?: EvalRenderContext;
+    }, uiTheme: Theme, _args?: EvalRenderArgs): Component;
+    mergeCallAndResult: true;
+    inline: true;
+};
+export {};

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

@@ -0,0 +1,42 @@
+import type { Component } from "../tui.js";
+import type { RenderResultOptions } from "./renderer.js";
+import { type Theme } from "../theme/theme.js";
+import type { OutputMeta } from "./output-meta.js";
+/** Display metadata for fetch tool results. */
+export interface ReadUrlToolDetails {
+    kind: "url";
+    url: string;
+    finalUrl: string;
+    contentType: string;
+    method: string;
+    truncated: boolean;
+    notes: string[];
+    meta?: OutputMeta;
+}
+/** Restore the double slash in a collapsed HTTP URL scheme. */
+export declare function repairCollapsedScheme(value: string): string;
+/**
+ * Peel one or more selector tokens off the right of a URL string. Walks back through
+ * trailing `:tok` segments while each token (a) looks like a selector and (b) leaves
+ * behind a string that still parses as a URL. Returns selectors left-to-right so callers
+ * can apply them in source order.
+ */
+export declare function tryExtractEmbeddedUrlSelector(readPath: string): {
+    path: string;
+    sels: string[];
+} | null;
+/** Render URL read call (URL preview) */
+export declare function renderReadUrlCall(args: {
+    path?: string;
+    url?: string;
+    raw?: boolean;
+}, _options: RenderResultOptions, uiTheme?: Theme): Component;
+/** Render URL read result with tree-based layout */
+export declare function renderReadUrlResult(result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: ReadUrlToolDetails;
+    isError?: boolean;
+}, options: RenderResultOptions, uiTheme?: Theme): Component;

package/dist/types/tools/gh-format.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return the first 12 hex characters of a commit SHA, or undefined when the
+ * input is missing. Shared between GitHub tool argument normalization and the
+ * run-watch renderer.
+ */
+export declare function formatShortSha(value: string | undefined): string | undefined;
+/** Append a labeled Markdown metadata value when present. */
+export declare function pushLine(lines: string[], label: string, value: string | number | boolean | undefined): void;

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

@@ -0,0 +1,144 @@
+import { type Component } from "../index.js";
+import type { RenderResultOptions } from "./renderer.js";
+import type { Theme } from "../theme/theme.js";
+type GithubToolRenderArgs = {
+    op?: string;
+    run?: string;
+    branch?: string;
+    repo?: string;
+    pr?: string | string[];
+    query?: string;
+};
+/** Render GitHub operations and live workflow status. */
+export declare const githubToolRenderer: {
+    renderCall(args: GithubToolRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: GhToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GithubToolRenderArgs): Component;
+    mergeCallAndResult: true;
+};
+import type { OutputMeta } from "./output-meta.js";
+import type { IsoBackendKind } from "@oh-my-pi/pi-natives";
+/** Display metadata for GitHub operations. */
+export interface GhToolDetails {
+    meta?: OutputMeta;
+    artifactId?: string;
+    repo?: string;
+    branch?: string;
+    worktreePath?: string;
+    remote?: string;
+    remoteBranch?: string;
+    headSha?: string;
+    runId?: number;
+    runIds?: number[];
+    status?: string;
+    conclusion?: string;
+    failedJobs?: string[];
+    watch?: GhRunWatchViewDetails;
+    checkouts?: GhPrCheckoutSummary[];
+}
+/** Checkout location and branch metadata for a pull request. */
+export interface GhPrCheckoutSummary {
+    prNumber?: number;
+    url?: string;
+    branch: string;
+    worktreePath: string;
+    remote: string;
+    remoteBranch: string;
+    reused: boolean;
+    clonedWith?: IsoBackendKind;
+}
+/** Display state of a watched workflow job. */
+export interface GhRunWatchJobDetails {
+    id: number;
+    name: string;
+    status?: string;
+    conclusion?: string;
+    durationSeconds?: number;
+    url?: string;
+}
+/** Display state of a watched workflow run. */
+export interface GhRunWatchRunDetails {
+    id: number;
+    workflowName?: string;
+    displayTitle?: string;
+    status?: string;
+    conclusion?: string;
+    branch?: string;
+    headSha?: string;
+    url?: string;
+    jobs: GhRunWatchJobDetails[];
+}
+/** Captured log preview for a failed job. */
+export interface GhRunWatchFailedLogDetails {
+    runId: number;
+    workflowName?: string;
+    jobName: string;
+    conclusion?: string;
+    tail?: string;
+    available: boolean;
+}
+/** Live workflow watcher display snapshot. */
+export interface GhRunWatchViewDetails {
+    mode: "run" | "commit";
+    state: "watching" | "completed";
+    repo: string;
+    branch?: string;
+    headSha?: string;
+    pollCount?: number;
+    note?: string;
+    run?: GhRunWatchRunDetails;
+    runs?: GhRunWatchRunDetails[];
+    failedLogs?: GhRunWatchFailedLogDetails[];
+}
+/** Normalized status and timestamps of a workflow job. */
+export interface GhRunJobSnapshot {
+    id: number;
+    name: string;
+    status?: string;
+    conclusion?: string;
+    startedAt?: string;
+    completedAt?: string;
+    url?: string;
+}
+/** Normalized workflow run and job snapshot. */
+export interface GhRunSnapshot {
+    id: number;
+    workflowName?: string;
+    displayTitle?: string;
+    status?: string;
+    conclusion?: string;
+    branch?: string;
+    headSha?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    url?: string;
+    jobs: GhRunJobSnapshot[];
+}
+/** Captured failure logs associated with a run and job. */
+export interface GhFailedJobLog {
+    run: GhRunSnapshot;
+    job: GhRunJobSnapshot;
+    full?: string;
+    tail?: string;
+    available: boolean;
+}
+/** Choose the terminal conclusion or current job state. */
+export declare function formatJobState(job: GhRunJobSnapshot): string;
+/** Format workflow jobs as a Markdown section. */
+export declare function renderJobsSection(jobs: GhRunJobSnapshot[]): string[];
+/** Format failed workflow logs as Markdown sections. */
+export declare function renderFailedJobLogs(failedJobLogs: GhFailedJobLog[], options: {
+    mode: "tail";
+    tail: number;
+} | {
+    mode: "full";
+}): string[];
+/** Format a workflow run and its jobs as Markdown. */
+export declare function renderRunSection(run: GhRunSnapshot): string[];
+export {};

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

@@ -0,0 +1,44 @@
+import type { Component } from "../tui.js";
+import type { RenderResultOptions } from "./renderer.js";
+import { type Theme } from "../theme/theme.js";
+import type { OutputMeta } from "./output-meta.js";
+import type { TruncationResult } from "./streaming-output.js";
+/** Display metadata for glob tool results. */
+export interface GlobToolDetails {
+    truncation?: TruncationResult;
+    resultLimitReached?: number;
+    meta?: OutputMeta;
+    scopePath?: string;
+    fileCount?: number;
+    files?: string[];
+    truncated?: boolean;
+    error?: string;
+    /** Working directory at search time. Used by the renderer to resolve relative
+     * file paths to absolute paths for OSC 8 hyperlinks. */
+    cwd?: 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[];
+}
+interface GlobRenderArgs {
+    path?: string | string[];
+    /** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
+    paths?: string | string[];
+    limit?: number;
+}
+/** Render glob calls and results in the transcript. */
+export declare const globToolRenderer: {
+    inline: true;
+    renderCall(args: GlobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: GlobToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: GlobRenderArgs): Component;
+    mergeCallAndResult: true;
+};
+export {};