@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

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>;

package/dist/types/utils/file-display-mode.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Resolve line-display mode for file-like outputs (read, grep, @file mentions).
+ */
+export interface FileDisplayMode {
+    lineNumbers: boolean;
+    hashLines: boolean;
+}
+/** Session-like object providing settings and tool availability for display mode resolution. */
+export interface FileDisplayModeSession {
+    /** Whether the edit tool is available. Hashlines are suppressed without it. */
+    hasEditTool?: boolean;
+    settings: {
+        get(key: "readLineNumbers" | "readHashLines" | "edit.mode"): unknown;
+    };
+}
+/**
+ * Computes effective line display mode from session settings/env.
+ * Hashline mode takes precedence and implies line-addressed output everywhere.
+ * Hashlines are suppressed when the edit tool is not available (e.g. explore agents),
+ * when the caller signals a `raw` read, and when the source is `immutable`
+ * (e.g. internal URLs like artifact://, agent://, memory:// — there is no edit
+ * path that could consume the anchors). Raw output is returned as-is.
+ */
+export declare function resolveFileDisplayMode(session: FileDisplayModeSession, options?: {
+    raw?: boolean;
+    immutable?: boolean;
+}): FileDisplayMode;

package/dist/types/utils/file-mentions.d.ts

@@ -0,0 +1,11 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+/** Extract all @filepath mentions from text */
+export declare function extractFileMentions(text: string): string[];
+/**
+ * Generate a FileMentionMessage containing the contents of mentioned files.
+ * Returns empty array if no files could be read.
+ */
+export declare function generateFileMentionMessages(filePaths: string[], cwd: string, options?: {
+    autoResizeImages?: boolean;
+    useHashLines?: boolean;
+}): Promise<AgentMessage[]>;

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

@@ -0,0 +1,360 @@
+import type { FileDiff, FileHunks, NumstatEntry } from "../commit/types";
+export interface GitCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface GitRepository {
+    commonDir: string;
+    gitDir: string;
+    gitEntryPath: string;
+    headPath: string;
+    repoRoot: string;
+}
+export interface GitStatusSummary {
+    staged: number;
+    unstaged: number;
+    untracked: number;
+}
+export type HunkSelection = {
+    path: string;
+    hunks: {
+        type: "all";
+    } | {
+        type: "indices";
+        indices: number[];
+    } | {
+        type: "lines";
+        start: number;
+        end: number;
+    };
+};
+export interface StageHunksOptions {
+    readonly diffCached?: boolean;
+    readonly rawDiff?: string;
+    readonly signal?: AbortSignal;
+}
+export interface DiffOptions {
+    readonly allowFailure?: boolean;
+    readonly base?: string;
+    readonly binary?: boolean;
+    readonly cached?: boolean;
+    readonly env?: Record<string, string | undefined>;
+    readonly files?: readonly string[];
+    readonly head?: string;
+    readonly nameOnly?: boolean;
+    readonly noIndex?: {
+        left: string;
+        right: string;
+    };
+    readonly numstat?: boolean;
+    readonly signal?: AbortSignal;
+    readonly stat?: boolean;
+}
+export interface StatusOptions {
+    readonly pathspecs?: readonly string[];
+    readonly porcelainV1?: boolean;
+    readonly signal?: AbortSignal;
+    readonly untrackedFiles?: "all" | "no" | "normal";
+    readonly z?: boolean;
+}
+export interface CommitOptions {
+    readonly allowEmpty?: boolean;
+    readonly files?: readonly string[];
+    readonly signal?: AbortSignal;
+}
+export interface PushOptions {
+    readonly forceWithLease?: boolean;
+    readonly refspec?: string;
+    readonly remote?: string;
+    readonly signal?: AbortSignal;
+}
+export interface PatchOptions {
+    readonly cached?: boolean;
+    readonly check?: boolean;
+    readonly env?: Record<string, string | undefined>;
+    readonly signal?: AbortSignal;
+}
+export interface RestoreOptions {
+    readonly files?: readonly string[];
+    readonly signal?: AbortSignal;
+    readonly source?: string;
+    readonly staged?: boolean;
+    readonly worktree?: boolean;
+}
+export interface CloneOptions {
+    readonly ref?: string;
+    readonly sha?: string;
+    readonly signal?: AbortSignal;
+}
+interface GitHeadBase extends GitRepository {
+    headContent: string;
+}
+export interface GitRefHead extends GitHeadBase {
+    branchName: string | null;
+    commit: string | null;
+    kind: "ref";
+    ref: string;
+}
+export interface GitDetachedHead extends GitHeadBase {
+    commit: string | null;
+    kind: "detached";
+}
+export type GitHeadState = GitRefHead | GitDetachedHead;
+export interface GitWorktreeEntry {
+    branch?: string;
+    detached: boolean;
+    head?: string;
+    path: string;
+}
+export declare class GitCommandError extends Error {
+    readonly args: readonly string[];
+    readonly result: GitCommandResult;
+    constructor(args: readonly string[], result: GitCommandResult);
+}
+interface CommandOptions {
+    readonly env?: Record<string, string | undefined>;
+    readonly readOnly?: boolean;
+    readonly signal?: AbortSignal;
+    readonly stdin?: string | Uint8Array | ArrayBuffer | SharedArrayBuffer;
+}
+/**
+ * Serialize an async block that mutates a git repository against other
+ * in-process callers operating on the same repository. The lock is keyed by
+ * the primary repo root so worktrees of the same repo share a single queue.
+ * Failures in one block do not poison the queue for the next caller.
+ *
+ * Not reentrant: do NOT nest acquisitions for the same repo. Helpers in this
+ * module never auto-acquire — callers wrap the critical section themselves.
+ */
+export declare function withRepoLock<T>(cwd: string, fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+declare function parseStatusPorcelain(text: string): GitStatusSummary;
+/** Run `git diff` with the given options. Returns raw diff text. */
+export declare const diff: ((cwd: string, options?: DiffOptions) => Promise<string>) & {
+    /** List changed file paths. */
+    changedFiles(cwd: string, options?: Pick<DiffOptions, "cached" | "files" | "signal">): Promise<string[]>;
+    /** Parsed per-file add/remove counts. */
+    numstat(cwd: string, options?: Pick<DiffOptions, "cached" | "signal">): Promise<NumstatEntry[]>;
+    /** Parsed diff hunks for the given files. */
+    hunks(cwd: string, files: readonly string[], options?: {
+        cached?: boolean;
+        signal?: AbortSignal;
+    }): Promise<FileHunks[]>;
+    /** Check whether a diff exists (uses `--quiet` for efficiency). */
+    has(cwd: string, options?: Pick<DiffOptions, "cached" | "files" | "signal">): Promise<boolean>;
+    /** Diff between two tree-ish objects (`git diff-tree`). */
+    tree(cwd: string, base: string, headRef: string, options?: {
+        binary?: boolean;
+        signal?: AbortSignal;
+        allowFailure?: boolean;
+    }): Promise<string>;
+    /** Parse raw diff text into per-file diffs. */
+    parseFiles(text: string): FileDiff[];
+    /** Parse raw diff text into per-file hunks. */
+    parseHunks(text: string): FileHunks[];
+};
+/** Run `git status --porcelain`. Returns raw status text. */
+export declare const status: ((cwd: string, options?: StatusOptions) => Promise<string>) & {
+    /** Parsed status counts (staged, unstaged, untracked). */
+    summary(cwd: string, signal?: AbortSignal): Promise<GitStatusSummary | null>;
+    /** Parse porcelain status text into counts. */
+    parse: typeof parseStatusPorcelain;
+};
+export declare const stage: {
+    /** Stage files. Empty array stages all (`git add -A`). */
+    files(cwd: string, files?: readonly string[], signal?: AbortSignal): Promise<void>;
+    /** Selectively stage hunks from the provided diff or the current working tree diff. */
+    hunks(cwd: string, selections: HunkSelection[], options?: StageHunksOptions): Promise<void>;
+    /** Unstage files. Empty array unstages all (`git reset`). */
+    reset(cwd: string, files?: readonly string[], signal?: AbortSignal): Promise<void>;
+};
+/** Create a commit with the given message (passed via stdin). */
+export declare function commit(cwd: string, message: string, options?: CommitOptions): Promise<GitCommandResult>;
+/** Push the current branch. */
+export declare function push(cwd: string, options?: PushOptions): Promise<void>;
+/** Checkout a ref. */
+export declare function checkout(cwd: string, ref: string, signal?: AbortSignal): Promise<void>;
+/** Fetch a specific refspec from a remote. */
+export declare function fetch(cwd: string, remote: string, source: string, target: string, signal?: AbortSignal): Promise<void>;
+/** Read a tree-ish into the index. */
+export declare function readTree(cwd: string, treeish: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<void>;
+/** Write the current index as a tree and return its object id. */
+export declare function writeTree(cwd: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<string>;
+/** Run `git show` on a revision. */
+export declare const show: ((cwd: string, revision: string, options?: {
+    format?: string;
+    signal?: AbortSignal;
+}) => Promise<string>) & {
+    /** Get the path prefix of the current directory relative to the repo root. */
+    prefix(cwd: string, signal?: AbortSignal): Promise<string>;
+};
+export declare const log: {
+    /** Recent commit subjects (one-line each). */
+    subjects(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
+    /** Recent commits as `<short-sha> <subject>` onelines. */
+    onelines(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
+};
+export declare const branch: {
+    /** Current branch name, or null if detached/unavailable. */
+    current(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /** Default branch name (from remote HEAD refs). */
+    default(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /** Create a new branch at the given start point. */
+    create(cwd: string, name: string, startPoint?: string, signal?: AbortSignal): Promise<void>;
+    /** Force-move a branch to a new start point. */
+    force(cwd: string, name: string, startPoint: string, signal?: AbortSignal): Promise<void>;
+    /** Delete a branch. Throws on failure. */
+    delete(cwd: string, name: string, options?: {
+        force?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Delete a branch. Returns false on failure instead of throwing. */
+    tryDelete(cwd: string, name: string, options?: {
+        force?: boolean;
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    /** Create and checkout a new branch. */
+    checkoutNew(cwd: string, name: string, signal?: AbortSignal): Promise<void>;
+    /** List branches. Pass `{ all: true }` to include remotes. */
+    list(cwd: string, options?: {
+        all?: boolean;
+        signal?: AbortSignal;
+    }): Promise<string[]>;
+};
+export declare const remote: {
+    /** List remote names. */
+    list(cwd: string, signal?: AbortSignal): Promise<string[]>;
+    /** Get the URL for a remote. */
+    url(cwd: string, name: string, signal?: AbortSignal): Promise<string | undefined>;
+    /**
+     * Add a remote pointing at `url`. Idempotent: if a remote named `name`
+     * already exists with the same URL (e.g. an in-process race or a leftover
+     * remote from a previous run), this is treated as success. Throws when the
+     * remote exists with a different URL — that's a real conflict the caller
+     * needs to resolve, not paper over.
+     */
+    add(cwd: string, name: string, url: string, signal?: AbortSignal): Promise<void>;
+};
+export declare const ref: {
+    /** Check if a ref exists. */
+    exists(cwd: string, refName: string, signal?: AbortSignal): Promise<boolean>;
+    /** Resolve a ref to its commit SHA. */
+    resolve(cwd: string, refName: string, signal?: AbortSignal): Promise<string | null>;
+    /** Tags pointing at a ref. */
+    tags(cwd: string, refName?: string, signal?: AbortSignal): Promise<string[]>;
+};
+export declare const config: {
+    get(cwd: string, key: string, signal?: AbortSignal): Promise<string | undefined>;
+    set(cwd: string, key: string, value: string, signal?: AbortSignal): Promise<void>;
+    getBranch(cwd: string, branchName: string, key: string, signal?: AbortSignal): Promise<string | undefined>;
+    setBranch(cwd: string, branchName: string, key: string, value: string, signal?: AbortSignal): Promise<void>;
+};
+export declare const worktree: {
+    add(cwd: string, worktreePath: string, refName: string, options?: {
+        detach?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    remove(cwd: string, worktreePath: string, options?: {
+        force?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    tryRemove(cwd: string, worktreePath: string, options?: {
+        force?: boolean;
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    list(cwd: string, signal?: AbortSignal): Promise<GitWorktreeEntry[]>;
+};
+export declare const patch: {
+    /** Apply a patch file. */
+    apply(cwd: string, patchPath: string, options?: PatchOptions): Promise<void>;
+    /** Apply a patch from a string (writes to a temp file). */
+    applyText(cwd: string, patchText: string, options?: PatchOptions): Promise<void>;
+    /** Check if a patch file can be applied cleanly. */
+    canApply(cwd: string, patchPath: string, options?: Omit<PatchOptions, "check">): Promise<boolean>;
+    /** Check if a patch string can be applied cleanly. */
+    canApplyText(cwd: string, patchText: string, options?: Omit<PatchOptions, "check">): Promise<boolean>;
+    /** Join patch parts into a single patch string. */
+    join(parts: string[]): string;
+};
+export declare const cherryPick: ((cwd: string, revision: string, signal?: AbortSignal) => Promise<void>) & {
+    abort(cwd: string, signal?: AbortSignal): Promise<void>;
+};
+export declare const stash: {
+    /** Stash working tree + index changes. Returns true when git created a new stash entry. */
+    push(cwd: string, message?: string): Promise<boolean>;
+    /** Pop the most recent stash entry, optionally restoring its staged state. */
+    pop(cwd: string, options?: {
+        index?: boolean;
+    }): Promise<void>;
+};
+export declare function clone(url: string, targetDir: string, options?: CloneOptions): Promise<void>;
+export declare function restore(cwd: string, options?: RestoreOptions): Promise<void>;
+/**
+ * Run `git reset` with options. Default is a soft reset (no flag); pass `hard: true` for a destructive reset.
+ *
+ * NOTE: stage.reset() handles the per-file unstaging case. This helper exists for tree-wide resets.
+ */
+export declare function reset(cwd: string, options?: {
+    hard?: boolean;
+    mixed?: boolean;
+    soft?: boolean;
+    target?: string;
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare function clean(cwd: string, options?: {
+    ignoredOnly?: boolean;
+    paths?: readonly string[];
+    signal?: AbortSignal;
+}): Promise<void>;
+export declare const ls: {
+    /** List files tracked or untracked by git. */
+    files(cwd: string, options?: {
+        others?: boolean;
+        excludeStandard?: boolean;
+        signal?: AbortSignal;
+    }): Promise<string[]>;
+    /** List untracked files (excludes ignored). */
+    untracked(cwd: string, signal?: AbortSignal): Promise<string[]>;
+    /** List submodule paths (recursive). */
+    submodules(cwd: string, signal?: AbortSignal): Promise<string[]>;
+};
+export declare const head: {
+    /** Full HEAD state (branch, commit, repo info). */
+    resolve(cwd: string): Promise<GitHeadState | null>;
+    /** Full HEAD state (synchronous). */
+    resolveSync(cwd: string): GitHeadState | null;
+    /** Current HEAD commit SHA. */
+    sha(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /** Abbreviated HEAD commit SHA. */
+    short(cwd: string, length?: number, signal?: AbortSignal): Promise<string | null>;
+};
+export declare const repo: {
+    /** Resolve the repository root (may be a worktree root). */
+    root(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /** Resolve the primary repository root (not a worktree — the main checkout). */
+    primaryRoot(cwd: string, signal?: AbortSignal): Promise<string | null>;
+    /** Full GitRepository metadata (sync). */
+    resolveSync(cwd: string): GitRepository | null;
+    /** Full GitRepository metadata. */
+    resolve(cwd: string): Promise<GitRepository | null>;
+};
+export interface GhCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface GhCommandOptions {
+    repoProvided?: boolean;
+    trimOutput?: boolean;
+}
+export declare const github: {
+    /** Check if `gh` CLI is installed. */
+    available(): boolean;
+    /** Run a raw `gh` CLI command. Does not throw on non-zero exit. */
+    run(cwd: string, args: string[], signal?: AbortSignal, options?: GhCommandOptions): Promise<GhCommandResult>;
+    /** Run `gh` and parse stdout as JSON. Throws on non-zero exit or invalid JSON. */
+    json<T>(cwd: string, args: string[], signal?: AbortSignal, options?: GhCommandOptions): Promise<T>;
+    /** Run `gh` and return stdout as text. Throws on non-zero exit. */
+    text(cwd: string, args: string[], signal?: AbortSignal, options?: GhCommandOptions): Promise<string>;
+};
+export {};

package/dist/types/utils/image-loading.d.ts

@@ -0,0 +1,26 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export declare const MAX_IMAGE_INPUT_BYTES: number;
+export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
+export interface LoadImageInputOptions {
+    path: string;
+    cwd: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    resolvedPath?: string;
+    detectedMimeType?: string;
+}
+export interface LoadedImageInput {
+    resolvedPath: string;
+    mimeType: string;
+    data: string;
+    textNote: string;
+    dimensionNote?: string;
+    bytes: number;
+}
+export declare class ImageInputTooLargeError extends Error {
+    readonly bytes: number;
+    readonly maxBytes: number;
+    constructor(bytes: number, maxBytes: number);
+}
+export declare function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null>;
+export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;

package/dist/types/utils/image-resize.d.ts

@@ -0,0 +1,36 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+export interface ImageResizeOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    maxBytes?: number;
+    jpegQuality?: number;
+}
+export interface ResizedImage {
+    buffer: Uint8Array;
+    mimeType: string;
+    originalWidth: number;
+    originalHeight: number;
+    width: number;
+    height: number;
+    wasResized: boolean;
+    get data(): string;
+}
+/**
+ * Resize and recompress an image to fit within the specified max dimensions and file size.
+ *
+ * Strategy:
+ *  1. Probe metadata. If already within all limits, return original.
+ *  2. Resize to fit max dimensions and encode at high quality across PNG/JPEG/WebP — return smallest.
+ *  3. If still too large, walk a lossy JPEG/WebP quality ladder.
+ *  4. If still too large, walk a dimension-scale ladder × quality ladder.
+ *  5. If still too large, return the smallest variant produced.
+ *
+ * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
+ * off the JS thread when the terminal (`.bytes()`) is awaited.
+ */
+export declare function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage>;
+/**
+ * Format a dimension note for resized images.
+ * This helps the model understand the coordinate mapping.
+ */
+export declare function formatDimensionNote(result: ResizedImage): string | undefined;

package/dist/types/utils/lang-from-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Language id for syntax highlighting and UI (icons, read tool), or undefined if unknown.
+ */
+export declare function getLanguageFromPath(filePath: string): string | undefined;
+/**
+ * LSP language identifier; falls back to `plaintext`.
+ */
+export declare function detectLanguageId(filePath: string): string;

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

@@ -0,0 +1,7 @@
+export interface MarkitConversionResult {
+    content: string;
+    ok: boolean;
+    error?: string;
+}
+export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
+export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal): Promise<MarkitConversionResult>;

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

@@ -0,0 +1,2 @@
+/** Open a URL or file path in the default browser/application. Best-effort, never throws. */
+export declare function openPath(urlOrPath: string): void;

package/dist/types/utils/session-color.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Derive a stable CSS hex accent color from a session name.
+ * High saturation, vivid — suitable for both status bar text and border coloring.
+ */
+export declare function getSessionAccentHex(name: string): string;
+/**
+ * Convert a hex accent color to an ANSI-16m foreground escape sequence.
+ * Returns `undefined` if `hex` is nullish or Bun.color conversion fails.
+ */
+export declare function getSessionAccentAnsi(hex: string | undefined): string | undefined;

package/dist/types/utils/shell-snapshot.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Create a shell snapshot, caching the result.
+ * Returns the path to the snapshot file, or null if creation failed.
+ */
+export declare function getOrCreateSnapshot(shell: string, env: Record<string, string | undefined>): Promise<string | null>;