indusagi 0.12.32 → 0.12.34

package/dist/types/react-ink/components/dialogs/ModelDialog.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "indusagi/ai";
+interface ModelDialogProps {
+    models: Model<any>[];
+    search?: string;
+    onClose: () => void;
+    onSelect: (model: Model<any>) => void | Promise<void>;
+}
+export declare function ModelDialog({ models, onClose, onSelect, search }: ModelDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/OAuthDialog.d.ts

@@ -0,0 +1,9 @@
+import type { OAuthOverlayState } from "../../types.js";
+interface OAuthDialogProps {
+    state: OAuthOverlayState;
+    onClose: () => void;
+    onChange: (next: Partial<OAuthOverlayState>) => void;
+    onSubmit: () => void | Promise<void>;
+}
+export declare function OAuthDialog({ onChange, onClose, onSubmit, state }: OAuthDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/ScopedModelsDialog.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "indusagi/ai";
+interface ScopedModelsDialogProps {
+    models: Model<any>[];
+    selectedIds: string[];
+    onClose: () => void;
+    onSave: (selectedIds: string[]) => void | Promise<void>;
+}
+export declare function ScopedModelsDialog({ models, onClose, onSave, selectedIds }: ScopedModelsDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SelectableDialog.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "indusagi/react-host";
+interface SelectableDialogProps<T> {
+    title: string;
+    subtitle?: string;
+    items: T[];
+    isActive?: boolean;
+    searchEnabled?: boolean;
+    emptyText: string;
+    noSearchResultsText?: string;
+    onClose: () => void;
+    onSelect: (item: T) => void | Promise<void>;
+    /**
+     * Fired whenever the highlighted item changes (including on first mount), so a
+     * caller can live-preview the currently-focused choice before it is committed
+     * with Enter. Distinct from {@link onSelect}, which fires only on Enter.
+     */
+    onHighlight?: (item: T, index: number) => void;
+    getSearchText?: (item: T) => string;
+    renderItem: (item: T, selected: boolean, index: number) => ReactNode;
+}
+export declare function SelectableDialog<T>({ title, subtitle, items, isActive, searchEnabled, emptyText, noSearchResultsText, onClose, onSelect, onHighlight, getSearchText, renderItem, }: SelectableDialogProps<T>): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SessionDialog.d.ts

@@ -0,0 +1,13 @@
+import type { SessionInfo } from "../../types.js";
+import { type SessionBrowserProgress } from "../../utils/session-browser.js";
+interface SessionDialogProps {
+    currentSessions: SessionInfo[];
+    currentSessionPath?: string;
+    onClose: () => void;
+    onSelect: (session: SessionInfo) => void | Promise<void>;
+    onLoadAllSessions: (onProgress?: (progress: SessionBrowserProgress) => void) => Promise<SessionInfo[]>;
+    onDeleteSession?: (session: SessionInfo) => void | Promise<void>;
+    onRenameSession?: (session: SessionInfo, name: string) => void | Promise<void>;
+}
+export declare function SessionDialog({ currentSessionPath, currentSessions, onClose, onDeleteSession, onLoadAllSessions, onRenameSession, onSelect, }: SessionDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/SettingsDialog.d.ts

@@ -0,0 +1,14 @@
+export interface SettingsDialogItem {
+    id: string;
+    label: string;
+    description: string;
+    value: string;
+    values: string[];
+    onChange: (value: string) => void | Promise<void>;
+}
+interface SettingsDialogProps {
+    items: SettingsDialogItem[];
+    onClose: () => void;
+}
+export declare function SettingsDialog({ items, onClose }: SettingsDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/StartupSessionPicker.d.ts

@@ -0,0 +1,9 @@
+import type { SessionInfo } from "../../types.js";
+interface StartupSessionPickerProps {
+    sessions: SessionInfo[];
+    totalCount: number;
+    onClose: () => void;
+    onSelect: (session: SessionInfo) => void | Promise<void>;
+}
+export declare function StartupSessionPicker({ onClose, onSelect, sessions, totalCount }: StartupSessionPickerProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/ThemeDialog.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A single selectable scheme row. The `id` is the scheme token committed/
+ * previewed; `label` and `description` are the human-readable strings shown.
+ */
+export interface ThemeDialogItem {
+    id: string;
+    label: string;
+    description?: string;
+}
+interface ThemeDialogProps {
+    /**
+     * The schemes to offer. Either bare scheme tokens (label == token) or rich
+     * items carrying a friendly label + description.
+     */
+    themes: Array<string | ThemeDialogItem>;
+    onClose: () => void;
+    /** Fired on Enter: the chosen scheme token. */
+    onSelect: (themeName: string) => void | Promise<void>;
+    /**
+     * Fired on every highlight move (and on mount): the focused scheme token, so
+     * the caller can live-preview a scheme before it is committed.
+     */
+    onHighlight?: (themeName: string) => void;
+}
+export declare function ThemeDialog({ themes, onClose, onSelect, onHighlight }: ThemeDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/TreeDialog.d.ts

@@ -0,0 +1,8 @@
+import type { SessionTreeOption } from "../../types.js";
+interface TreeDialogProps {
+    items: SessionTreeOption[];
+    onClose: () => void;
+    onSelect: (item: SessionTreeOption) => void | Promise<void>;
+}
+export declare function TreeDialog({ items, onClose, onSelect }: TreeDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/dialogs/UserMessageDialog.d.ts

@@ -0,0 +1,8 @@
+import type { UserMessageOption } from "../../types.js";
+interface UserMessageDialogProps {
+    items: UserMessageOption[];
+    onClose: () => void;
+    onSelect: (item: UserMessageOption) => void | Promise<void>;
+}
+export declare function UserMessageDialog({ items, onClose, onSelect }: UserMessageDialogProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/AssistantMessage.d.ts

@@ -0,0 +1,12 @@
+import type { AssistantMessage, ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface AssistantMessageProps {
+    message: AssistantMessage;
+    showImages: boolean;
+    showThinking: boolean;
+    expandToolOutputs?: boolean;
+    theme: InkThemeAdapter;
+    toolResults?: ToolResultMessage[];
+}
+export declare function AssistantMessageView({ expandToolOutputs, message, showImages, showThinking, theme, toolResults, }: AssistantMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/BashMessage.d.ts

@@ -0,0 +1,8 @@
+import type { BashExecutionMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface BashMessageProps {
+    message: BashExecutionMessage;
+    theme: InkThemeAdapter;
+}
+export declare function BashMessageView({ message, theme }: BashMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/BranchSummaryMessage.d.ts

@@ -0,0 +1,8 @@
+import type { BranchSummaryMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface BranchSummaryMessageProps {
+    message: BranchSummaryMessage;
+    theme: InkThemeAdapter;
+}
+export declare function BranchSummaryMessageView({ message, theme }: BranchSummaryMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/CompactionMessage.d.ts

@@ -0,0 +1,8 @@
+import type { CompactionSummaryMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface CompactionMessageProps {
+    message: CompactionSummaryMessage;
+    theme: InkThemeAdapter;
+}
+export declare function CompactionMessageView({ message, theme }: CompactionMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/CustomMessage.d.ts

@@ -0,0 +1,9 @@
+import type { CustomMessage } from "indusagi/agent";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface CustomMessageProps {
+    message: CustomMessage;
+    showImages: boolean;
+    theme: InkThemeAdapter;
+}
+export declare function CustomMessageView({ message, showImages, theme }: CustomMessageProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/messages/SkillInvocationMessage.d.ts

@@ -0,0 +1,7 @@
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface SkillInvocationMessageProps {
+    content: string;
+    theme: InkThemeAdapter;
+}
+export declare function SkillInvocationMessage({ content, theme }: SkillInvocationMessageProps): JSX.Element | null;
+export {};

package/dist/types/react-ink/components/messages/ToolCallMessage.d.ts

@@ -0,0 +1,8 @@
+import type { ToolCall } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface ToolCallMessageProps {
+    toolCall: ToolCall;
+    theme: InkThemeAdapter;
+}
+export declare function ToolCallMessage({ theme, toolCall }: ToolCallMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/ToolResultBlock.d.ts

@@ -0,0 +1,12 @@
+import type { ToolCall, ToolResultMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface ToolResultBlockProps {
+    message: ToolResultMessage;
+    showImages: boolean;
+    theme: InkThemeAdapter;
+    expanded?: boolean;
+    nested?: boolean;
+    toolCall?: ToolCall;
+}
+export declare function ToolResultBlock({ expanded, message, nested, showImages, theme, toolCall }: ToolResultBlockProps): JSX.Element;
+export {};

package/dist/types/react-ink/components/messages/UserMessage.d.ts

@@ -0,0 +1,9 @@
+import type { UserMessage } from "indusagi/ai";
+import type { InkThemeAdapter } from "../../theme-adapter.js";
+interface UserMessageProps {
+    message: UserMessage;
+    theme: InkThemeAdapter;
+    showImages: boolean;
+}
+export declare function UserMessageView({ message, showImages, theme }: UserMessageProps): JSX.Element;
+export {};

package/dist/types/react-ink/diff/Diff.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { StructuredDiff } from "./structured.js";
+interface DiffProps {
+    diff: StructuredDiff;
+    theme: InkThemeAdapter;
+    /** Left margin (columns) applied to the whole block. */
+    indent?: number;
+    marginBottom?: number;
+}
+/**
+ * A minimal, pure-Ink colored diff block.
+ *
+ * Renders each hunk's classified lines with a right-aligned line-number gutter,
+ * themed add/remove backgrounds, and word-level intra-line emphasis (only the
+ * changed sub-ranges are bolded; suppressed above the change threshold upstream
+ * in {@link buildStructuredDiff}). Multiple hunks are separated by a dim `...`
+ * marker. No state, no effects — colors survive to the terminal because nothing
+ * strips the ANSI on this path.
+ */
+export declare function Diff({ diff, theme, indent, marginBottom }: DiffProps): ReactNode;
+export {};

package/dist/types/react-ink/diff/diff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react-ink/diff/structured.d.ts

@@ -0,0 +1,41 @@
+import { type WordSpan } from "./word-diff.js";
+/** Lines of unchanged context kept around each change, matching git's default. */
+export declare const CONTEXT_LINES = 3;
+/** A single rendered diff line, already classified and numbered. */
+export interface DiffLine {
+    kind: "context" | "added" | "removed";
+    /** The old-file line number, or undefined for added lines. */
+    oldLine?: number;
+    /** The new-file line number, or undefined for removed lines. */
+    newLine?: number;
+    /** The line text without its `+`/`-`/space diff prefix. */
+    text: string;
+    /**
+     * Word-level segments for intra-line highlighting. Present only on added /
+     * removed lines that were paired with their counterpart; context lines and
+     * unpaired changes leave this undefined (render the whole line one colour).
+     */
+    spans?: WordSpan[];
+}
+/** One contiguous change region: classified lines plus a hunk header marker. */
+export interface DiffHunk {
+    oldStart: number;
+    newStart: number;
+    lines: DiffLine[];
+}
+export interface StructuredDiff {
+    hunks: DiffHunk[];
+    addedCount: number;
+    removedCount: number;
+}
+/**
+ * Build a structured diff between `oldStr` and `newStr` using the `diff`
+ * package's {@link structuredPatch} with {@link CONTEXT_LINES} of context.
+ *
+ * The raw hunk `lines` (prefixed `+`/`-`/space) are walked into typed
+ * {@link DiffLine}s carrying gutter line numbers. Adjacent removed→added runs
+ * are paired index-for-index and handed to {@link wordDiffLine} so the renderer
+ * can emphasise only the changed sub-range of each line. Returns `null` when
+ * there is nothing to show (identical input or an empty patch).
+ */
+export declare function buildStructuredDiff(oldStr: string, newStr: string, filePath?: string): StructuredDiff | null;

package/dist/types/react-ink/diff/word-diff.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Above this fraction of a line changing, intra-line word highlighting reads as
+ * noise — almost every span is "changed", so a flat whole-line colour is
+ * clearer. Below it we paint only the genuinely altered sub-ranges brighter.
+ */
+export declare const CHANGE_THRESHOLD = 0.4;
+/** One contiguous run of a removed/added line, flagged whether it changed. */
+export interface WordSpan {
+    text: string;
+    /** True when this run differs between the old and new line. */
+    changed: boolean;
+}
+/**
+ * Pair a removed line with the added line that replaced it and return the
+ * per-segment word diff for ONE side.
+ *
+ * `side` selects which line's segments we want: a removed-line render wants the
+ * segments present in the old text (unchanged + removed), an added-line render
+ * wants the segments present in the new text (unchanged + added). The other
+ * side's segments are dropped so the caller paints exactly the line it is on.
+ *
+ * Word highlighting is suppressed — the whole line is returned as a single
+ * `changed: true` span — when the changed character fraction exceeds
+ * {@link CHANGE_THRESHOLD}, where scattered word spans read worse than a flat
+ * line colour. The returned spans always concatenate back to the original line.
+ */
+export declare function wordDiffLine(oldLine: string, newLine: string, side: "removed" | "added"): WordSpan[];

package/dist/types/react-ink/index.d.ts

@@ -0,0 +1,42 @@
+export * from "./types.js";
+export * from "./theme-adapter.js";
+export * from "./components/ChangelogBlock.js";
+export * from "./components/DisplayBlockView.js";
+export * from "./components/Footer.js";
+export * from "./components/MessageList.js";
+export * from "./components/MessageRow.js";
+export * from "./components/StatusLine.js";
+export * from "./components/TaskPanel.js";
+export * from "./components/ToolEventBlock.js";
+export * from "./components/dialogs/DialogFrame.js";
+export * from "./components/dialogs/LoginDialog.js";
+export * from "./components/dialogs/ModelDialog.js";
+export * from "./components/dialogs/OAuthDialog.js";
+export * from "./components/dialogs/ScopedModelsDialog.js";
+export * from "./components/dialogs/SelectableDialog.js";
+export * from "./components/dialogs/SessionDialog.js";
+export * from "./components/dialogs/SettingsDialog.js";
+export * from "./components/dialogs/StartupSessionPicker.js";
+export * from "./components/dialogs/ThemeDialog.js";
+export * from "./components/dialogs/TreeDialog.js";
+export * from "./components/dialogs/UserMessageDialog.js";
+export * from "./components/messages/AssistantMessage.js";
+export * from "./components/messages/BashMessage.js";
+export * from "./components/messages/BranchSummaryMessage.js";
+export * from "./components/messages/CompactionMessage.js";
+export * from "./components/messages/CustomMessage.js";
+export * from "./components/messages/SkillInvocationMessage.js";
+export * from "./components/messages/ToolCallMessage.js";
+export * from "./components/messages/ToolResultBlock.js";
+export * from "./components/messages/UserMessage.js";
+export * from "./diff/Diff.js";
+export * from "./diff/structured.js";
+export * from "./diff/word-diff.js";
+export * from "./markdown/Markdown.js";
+export * from "./markdown/MarkdownTable.js";
+export * from "./markdown/StreamingMarkdown.js";
+export * from "./markdown/format-token.js";
+export * from "./markdown/highlight.js";
+export * from "./utils/message-groups.js";
+export * from "./utils/selection-dialog.js";
+export * from "./utils/tool-display.js";

package/dist/types/react-ink/markdown/Markdown.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface MarkdownProps {
+    /** The raw markdown source to render. */
+    children: string;
+    /** The theme adapter colours resolve against. */
+    theme: InkThemeAdapter;
+    /** When false, fenced code is rendered plain (no syntax highlighting). */
+    highlightCode?: boolean;
+    /** Render every text run dim (used for de-emphasised content). */
+    dim?: boolean;
+}
+/**
+ * Render markdown as styled terminal output.
+ *
+ * Tables become real flexbox columns ({@link MarkdownTable}); every other token
+ * is formatted to a chalk-ANSI string via {@link formatToken} and accumulated
+ * into a single `<Text>` run. Ink passes embedded ANSI straight to the terminal,
+ * so the chalk escapes render as colour. The `theme` is passed explicitly — the
+ * rebuild has no `useTheme()` hook.
+ */
+export declare function Markdown({ children, theme, highlightCode, dim }: MarkdownProps): ReactNode;
+export {};

package/dist/types/react-ink/markdown/MarkdownTable.d.ts

@@ -0,0 +1,19 @@
+import type { Tokens } from "marked";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { CliHighlight } from "./highlight.js";
+interface MarkdownTableProps {
+    token: Tokens.Table;
+    theme: InkThemeAdapter;
+    highlight?: CliHighlight | null;
+}
+/**
+ * Render a GFM table token as aligned flexbox columns.
+ *
+ * Each column's width is measured from the stripAnsi'd display text (so embedded
+ * ANSI styling does not inflate the column), the header row is bold, a dash rule
+ * separates header from body, and every cell is padded per its column alignment.
+ * Cells render as `<Box>` columns inside `<Box flexDirection="row">` rows, so Ink
+ * lays them out as real columns rather than a raw `| a | b |` pipe string.
+ */
+export declare function MarkdownTable({ token, theme, highlight }: MarkdownTableProps): JSX.Element;
+export {};

package/dist/types/react-ink/markdown/StreamingMarkdown.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface StreamingMarkdownProps {
+    /** The accumulated answer text so far (grows monotonically per delta). */
+    children: string;
+    /** The theme adapter colours resolve against. */
+    theme: InkThemeAdapter;
+    /** When false, fenced code is rendered plain (no syntax highlighting). */
+    highlightCode?: boolean;
+    /** Render every text run dim. */
+    dim?: boolean;
+}
+/**
+ * Streaming-aware markdown renderer with a monotonic stable-prefix boundary.
+ *
+ * On every delta the accumulated answer grows. Re-lexing the whole answer each
+ * time would re-parse (and reflow/flicker) content that is already settled. To
+ * avoid that, we split the answer at the last completed block boundary:
+ *
+ *   - **stable prefix** — every block above the boundary. Memoised on its own
+ *     content, so once a block settles its `<Markdown>` is parsed once and never
+ *     re-renders as later deltas arrive.
+ *   - **unstable suffix** — the still-growing last block. Re-lexed every delta
+ *     (cheap: it is one block, and `Markdown`'s own LRU cache + fast-path absorb
+ *     the cost).
+ *
+ * The boundary only ever moves forward (it is recomputed from `content`, which
+ * grows monotonically, and `lastStableBoundary` is monotonic in its input), so
+ * completed blocks never re-flicker. When the turn ends and the finalized
+ * assistant message takes over rendering, the same `<Markdown>` pipeline draws
+ * identical output, so the hand-off is seamless.
+ */
+export declare function StreamingMarkdown({ children, theme, highlightCode, dim, }: StreamingMarkdownProps): ReactNode;
+export {};

package/dist/types/react-ink/markdown/format-token.d.ts

@@ -0,0 +1,39 @@
+import { type Token } from "marked";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { CliHighlight } from "./highlight.js";
+/**
+ * Configure the shared `marked` instance exactly once. The only customisation is
+ * disabling strikethrough: models frequently write `~` for "approximate"
+ * (e.g. `~100`) and almost never intend an actual strike, so we keep `~` literal.
+ */
+export declare function configureMarked(): void;
+/**
+ * Fast structural check for whether `text` contains any markdown syntax. Samples
+ * the first 500 chars — markdown markers (headings, fences, list bullets) cluster
+ * at the start, while long plain tails (tool output) stay markdown-free.
+ */
+export declare function hasMarkdownSyntax(text: string): boolean;
+/**
+ * Lex `content` into marked tokens, hitting the LRU cache and the plain-text
+ * fast-path. Plain text (no markdown syntax) returns a single synthetic
+ * paragraph token and is intentionally not cached — reconstruction is one
+ * allocation and caching would retain the content for no benefit.
+ */
+export declare function cachedLexer(content: string): Token[];
+/**
+ * Render a single marked token to a chalk-ANSI string, painting via the
+ * framework {@link InkThemeAdapter}. Tables are handled out-of-band by the
+ * `Markdown` component (rendered as flexbox), so this returns an empty string
+ * for `table` tokens — the caller never funnels a table through here.
+ */
+export declare function formatToken(token: Token, theme: InkThemeAdapter, highlight?: CliHighlight | null, listDepth?: number, orderedListNumber?: number | null, parent?: Token | null): string;
+/** Pick the list-marker style for a depth: 1./2. → a./b. → i./ii. → numeric. */
+export declare function getListNumber(listDepth: number, orderedListNumber: number): string;
+/**
+ * Pad `content` to `targetWidth` per alignment. `displayWidth` is the visible
+ * width of `content` (caller computes it on stripAnsi'd text so embedded ANSI
+ * codes do not skew the padding).
+ */
+export declare function padAligned(content: string, displayWidth: number, targetWidth: number, align: "left" | "center" | "right" | null | undefined): string;
+/** Measure a string's visible terminal width (ANSI-aware), for table layout. */
+export declare function stringWidth(text: string): number;

package/dist/types/react-ink/markdown/highlight.d.ts

@@ -0,0 +1,31 @@
+import type { InkThemeAdapter } from "../theme-adapter.js";
+/**
+ * The shape {@link formatToken} (and the tool-body highlighter) consume. It is a
+ * deliberately small surface: ask whether a language is known, then hand back a
+ * chalk-ANSI rendering of the code. Keeping it behind an interface means the
+ * markdown formatter never imports highlight.js directly and a caller can pass
+ * `null` to disable highlighting entirely.
+ */
+export interface CliHighlight {
+    /** Whether highlight.js has a grammar registered for `language`. */
+    supportsLanguage: (language: string) => boolean;
+    /** Render `code` as a chalk-ANSI string, colouring scopes via the theme. */
+    highlight: (code: string, options: {
+        language: string;
+    }) => string;
+}
+/**
+ * Build a {@link CliHighlight} bound to a theme. The returned object paints each
+ * highlight.js scope via the theme's syntax roles ({@link ThemeRole}); unknown
+ * languages and any internal failure fall back to the raw code, never throwing.
+ */
+export declare function createHighlighter(theme: InkThemeAdapter): CliHighlight;
+/**
+ * Highlight `code` keyed on a file path's extension. Used by the read/write/edit
+ * tool bodies, which know the file but not a fenced ```lang tag. Resolves the
+ * extension to a highlight.js language, falling back to the plain code when the
+ * extension is unknown or unsupported.
+ */
+export declare function highlightByPath(code: string, filePath: string, theme: InkThemeAdapter): string;
+/** Resolve a file path to a highlight.js language id, or null when unknown. */
+export declare function languageFromPath(filePath: string): string | null;

package/dist/types/react-ink/theme-adapter.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The named colour roles the markdown / diff / syntax-highlight render path
+ * resolves against. Each value is a colour-key into the adapter's flat
+ * {@link InkThemeAdapter.colors} Record; a consumer asks the adapter for a role,
+ * the adapter looks the key up in `colors`, and falls back gracefully when the
+ * host theme has not supplied that key. Keeping the role → key indirection here
+ * means a host theme (e.g. the console) only has to populate the matching keys
+ * in its `colors` Record — it never has to re-implement an accessor.
+ *
+ * Roles:
+ *   - `codeInline`      — inline `` `code` `` spans.
+ *   - `heading`         — markdown heading text.
+ *   - `blockquoteBar`   — the dim bar/gutter drawn beside a blockquote.
+ *   - `diffAddedBg`     — background tint for an added (`+`) diff line.
+ *   - `diffRemovedBg`   — background tint for a removed (`-`) diff line.
+ *   - `diffAddedText`   — foreground for added-line content / `+` marker.
+ *   - `diffRemovedText` — foreground for removed-line content / `-` marker.
+ *   - `synKeyword`      — syntax scope: keywords.
+ *   - `synString`       — syntax scope: string literals.
+ *   - `synNumber`       — syntax scope: numeric literals.
+ *   - `synComment`      — syntax scope: comments.
+ *   - `synType`         — syntax scope: types / classes / built-ins.
+ */
+export interface ThemeRoleKeys {
+    codeInline: string;
+    heading: string;
+    blockquoteBar: string;
+    diffAddedBg: string;
+    diffRemovedBg: string;
+    diffAddedText: string;
+    diffRemovedText: string;
+    synKeyword: string;
+    synString: string;
+    synNumber: string;
+    synComment: string;
+    synType: string;
+}
+/** A role name the markdown / diff / highlight path can ask the adapter for. */
+export type ThemeRole = keyof ThemeRoleKeys;
+export interface InkThemeAdapter {
+    name: string;
+    colors: Record<string, string>;
+    color: (key: string, text: string) => string;
+    background: (key: string, text: string, textKey?: string) => string;
+    dim: (text: string) => string;
+    muted: (text: string) => string;
+    /**
+     * The colour-key each markdown/diff/syntax role maps to in {@link colors}.
+     * Always present — {@link createThemeAdapter} seeds it with sensible defaults
+     * so existing consumers and host themes that predate these roles keep working.
+     */
+    roles: ThemeRoleKeys;
+    /**
+     * Paint `text` in the foreground colour of a named markdown/diff/syntax
+     * {@link ThemeRole}, resolving the role's colour-key through {@link colors}.
+     */
+    role: (role: ThemeRole, text: string) => string;
+    /**
+     * Paint `text` on the background colour of a named {@link ThemeRole} (the diff
+     * backgrounds in practice), optionally tinting the foreground via a second
+     * role. Unlike {@link background} it does not pad or strip the text — the diff
+     * block owns its own spacing — so highlighted spans survive unmolested.
+     */
+    roleBackground: (role: ThemeRole, text: string, foregroundRole?: ThemeRole) => string;
+}
+export declare function createThemeAdapter(themeName: string, colors: Record<string, string>, roleOverrides?: Partial<ThemeRoleKeys>): InkThemeAdapter;