@sayknow-cli/coding-agent 0.4.1 → 0.4.3

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

@@ -0,0 +1,393 @@
+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[]>;
+    prune(cwd: string, signal?: AbortSignal): Promise<void>;
+};
+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 interface BisectCommitInfo {
+    sha: string;
+    author: string;
+    date: string;
+    subject: string;
+    stat: string;
+}
+/**
+ * Thin wrappers over `git bisect`. The marking commands (`good`/`bad`/`skip`)
+ * return the raw {@link GitCommandResult} without throwing so callers can both
+ * detect a genuine failure (non-zero exit) and scan the output for the
+ * "<sha> is the first bad commit" conclusion. `reset` is best-effort and never
+ * throws so it is safe to call from a `finally` block to restore the worktree.
+ */
+export declare const bisect: {
+    /** Begin a bisect session (does not seed good/bad endpoints). */
+    start(cwd: string, signal?: AbortSignal): Promise<void>;
+    /** Mark a revision (or current HEAD when omitted) good. Returns raw output. */
+    good(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Mark a revision (or current HEAD when omitted) bad. Returns raw output. */
+    bad(cwd: string, ref?: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Skip the current (untestable) revision. Returns raw output. */
+    skip(cwd: string, signal?: AbortSignal): Promise<GitCommandResult>;
+    /** Read the replayable bisect log for the current session. */
+    log(cwd: string, signal?: AbortSignal): Promise<string>;
+    /** End the bisect session, restoring the original HEAD. Never throws. */
+    reset(cwd: string, signal?: AbortSignal): Promise<void>;
+    /** True when `ancestor` is a first-parent-or-merge ancestor of `descendant`. */
+    isAncestor(cwd: string, ancestor: string, descendant: string, signal?: AbortSignal): Promise<boolean>;
+    /** Resolve author/date/subject and a diffstat for a commit (for the receipt). */
+    describe(cwd: string, sha: string, signal?: AbortSignal): Promise<BisectCommitInfo>;
+};
+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,49 @@
+import type { ImageContent } from "@sayknow-cli/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;
+    signal?: AbortSignal;
+}
+export interface LoadImageInputBytesOptions {
+    inputBuffer: Buffer;
+    resolvedPath: string;
+    mimeType: string;
+    autoResize: boolean;
+    maxBytes?: number;
+    maxOutputBytes?: number;
+    signal?: AbortSignal;
+}
+export interface TransformedImageInput {
+    resolvedPath: string;
+    mimeType: string;
+    buffer: Uint8Array;
+    textNote: string;
+    dimensionNote?: string;
+    bytes: number;
+}
+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>;
+/** Transform trusted source bytes without materializing a base64 payload. */
+export declare function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput>;
+export declare function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput;
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export declare function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput>;
+export declare function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null>;

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

@@ -0,0 +1,41 @@
+import type { ImageContent } from "@sayknow-cli/ai";
+export interface ImageResizeOptions {
+    maxWidth?: number;
+    maxHeight?: number;
+    maxBytes?: number;
+    jpegQuality?: number;
+    excludeWebP?: boolean;
+}
+export interface ResizedImage {
+    buffer: Uint8Array;
+    mimeType: string;
+    originalWidth: number;
+    originalHeight: number;
+    width: number;
+    height: number;
+    wasResized: boolean;
+    get data(): string;
+}
+export declare const DEFAULT_IMAGE_RESIZE_MAX_BYTES: number;
+/**
+ * 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.
+ *
+ * Set SKC_NO_WEBP to exclude WebP from encoding (llama.cpp STB doesn't decode it).
+ *
+ * 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 resizeImageBuffer(inputBuffer: Buffer, inputMimeType: string, options?: ImageResizeOptions): Promise<ResizedImage>;
+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/linkedom.d.ts

@@ -0,0 +1,4 @@
+type LinkedomModule = typeof import("linkedom");
+type ParseHtml = LinkedomModule["parseHTML"];
+export declare function parseHtmlLazy(markup: string): Promise<ReturnType<ParseHtml>>;
+export {};

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/pasted-image-loading.d.ts

@@ -0,0 +1,39 @@
+import type { ImageContent } from "@sayknow-cli/ai";
+import { type LoadedImageInput, transformImageInputBytes } from "./image-loading";
+export declare const MAX_PASTED_IMAGE_SOURCE_BYTES: number;
+export declare const MAX_PASTED_IMAGE_OUTPUT_BYTES: number;
+export declare const MAX_PASTED_IMAGE_DIMENSION = 20000;
+export declare const MAX_PASTED_IMAGE_PIXELS = 40000000;
+export declare const MAX_PASTED_IMAGE_DECODED_BYTES: number;
+export type PastedImageBatchErrorCode = "too-many" | "unsafe-path" | "unsupported-image" | "source-aggregate-too-large" | "output-aggregate-too-large" | "dimensions-too-large";
+export declare class PastedImageBatchError extends Error {
+    readonly code: PastedImageBatchErrorCode;
+    readonly imagePath?: string | undefined;
+    constructor(code: PastedImageBatchErrorCode, message: string, imagePath?: string | undefined);
+}
+export interface LoadedPastedImageBatch {
+    images: ImageContent[];
+    loadedInputs: LoadedImageInput[];
+    sourcePaths: string[];
+}
+export interface PastedImageLoadingDependencies {
+    /** Synchronization hook used to exercise pathname swaps after descriptor open. */
+    afterDescriptorOpen?: (imagePath: string, index: number) => Promise<void> | void;
+    beforeDescriptorRead?: (imagePath: string, index: number) => Promise<void> | void;
+    transformImageBytes?: typeof transformImageInputBytes;
+}
+export type PastedImageSourcePolicy = "confirmed" | "automatic-temp";
+export interface LoadPastedImageBatchOptions {
+    paths: readonly string[];
+    autoResize: boolean;
+    signal: AbortSignal;
+    sourcePolicy?: PastedImageSourcePolicy;
+    maxImageBytes?: number;
+    maxSourceBytes?: number;
+    maxOutputBytes?: number;
+    maxDimension?: number;
+    maxPixels?: number;
+    maxDecodedBytes?: number;
+    dependencies?: PastedImageLoadingDependencies;
+}
+export declare function loadPastedImageBatch(options: LoadPastedImageBatchOptions): Promise<LoadedPastedImageBatch>;

package/dist/types/utils/pasted-image-path.d.ts

@@ -0,0 +1,34 @@
+export declare const MAX_PASTED_IMAGE_COUNT = 16;
+export declare const MAX_PASTED_IMAGE_PASTE_CHARACTERS: number;
+export declare const MAX_PASTED_IMAGE_PATH_CHARACTERS: number;
+export interface DecodePastedPathOptions {
+    /** Platform whose path and shell semantics apply. Defaults to `process.platform`. */
+    platform?: NodeJS.Platform;
+    /** Home directory for `~/` expansion. Defaults to `os.homedir()`. */
+    homedir?: string;
+}
+export interface ResolvePastedImagePathOptions extends DecodePastedPathOptions {
+    /** Base directory for relative paths. Defaults to `process.cwd()`. */
+    cwd?: string;
+}
+export type PastedImagePathParseResult = {
+    kind: "paths";
+    paths: string[];
+    requiresConfirmation: boolean;
+} | {
+    kind: "too-many";
+    maxCandidates: number;
+};
+/** Decode one pasted path candidate without filesystem access. */
+export declare function decodePastedPathCandidate(text: string, options?: DecodePastedPathOptions): string | undefined;
+/** Tokenize a bounded complete path list without filesystem access. */
+export declare function decodePastedPathCandidates(text: string, options?: DecodePastedPathOptions, maxCandidates?: number): string[] | undefined;
+/** Resolve one recognized clipboard-temp image path lexically, before any filesystem access. */
+export declare function resolvePastedImagePath(text: string, options?: ResolvePastedImagePathOptions): string | undefined;
+/**
+ * Parse a complete image path paste without filesystem access. A single path
+ * keeps the clipboard-temp-only policy; multi-path saved-image pastes require
+ * explicit confirmation before any path is opened.
+ */
+export declare function parsePastedImagePaths(text: string, options?: ResolvePastedImagePathOptions): PastedImagePathParseResult | undefined;
+export declare function formatPastedImageReference(placeholder: string, imagePath: string): string;

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

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

@@ -0,0 +1,21 @@
+/**
+ * Returns whether SIXEL passthrough is explicitly enabled.
+ *
+ * Both gates must be enabled to preserve SIXEL control sequences:
+ * - PI_FORCE_IMAGE_PROTOCOL=sixel
+ * - PI_ALLOW_SIXEL_PASSTHROUGH=1
+ */
+export declare function isSixelPassthroughEnabled(): boolean;
+/** Returns true when the text contains a SIXEL start sequence. */
+export declare function containsSixelSequence(text: string): boolean;
+/**
+ * Returns a boolean mask indicating which lines belong to a SIXEL sequence block.
+ * Supports multi-line SIXEL payloads generated by libsixel.
+ */
+export declare function getSixelLineMask(lines: string[]): boolean[];
+/** Returns true when the line contains a SIXEL start sequence. */
+export declare function isSixelLine(line: string): boolean;
+/**
+ * Sanitizes text while preserving embedded SIXEL sequences when passthrough is enabled.
+ */
+export declare function sanitizeWithOptionalSixelPassthrough(text: string, sanitize: (text: string) => string): string;

package/dist/types/utils/title-generator.d.ts

@@ -0,0 +1,31 @@
+import { type Api, type Model } from "@sayknow-cli/ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+/**
+ * Generate a title for a session based on the first user message.
+ *
+ * @param firstMessage The first user message
+ * @param registry Model registry
+ * @param settings Settings used to resolve the smol role
+ * @param sessionId Optional session id for sticky API key selection
+ * @param currentModel Current model (used to derive title model)
+ * @param metadataResolver Optional resolver evaluated after credential selection
+ *   to produce request metadata (e.g. user_id for session attribution). Using a
+ *   resolver instead of a pre-evaluated value ensures the metadata's account_uuid
+ *   reflects the credential actually selected for this request.
+ */
+export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined): Promise<string | null>;
+export declare function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string;
+/**
+ * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.
+ */
+export declare function setTerminalTitle(title: string): void;
+export declare function setSessionTerminalTitle(sessionName: string | undefined, cwd?: string): void;
+/**
+ * Save the current terminal title on terminals that support xterm window ops.
+ */
+export declare function pushTerminalTitle(): void;
+/**
+ * Restore the previously saved terminal title on terminals that support xterm window ops.
+ */
+export declare function popTerminalTitle(): void;