indusagi 0.13.7 → 0.13.8

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

@@ -0,0 +1,101 @@
+/**
+ * Hand back the single grapheme segmenter that the whole module shares.
+ */
+export declare function getSegmenter(): Intl.Segmenter;
+export declare class GraphemeHandler {
+    segment(text: string): Intl.Segments;
+    iterator(text: string): Generator<string>;
+}
+export declare class TextWidthCalculator {
+    getWidth(text: string): number;
+    clearCache(): void;
+}
+export declare const textWidthCalculator: TextWidthCalculator;
+/**
+ * Compute how many columns a whole string takes up when rendered to a terminal.
+ */
+export declare function visibleWidth(str: string): number;
+/**
+ * If an ANSI escape sequence begins exactly at the given index, return it along
+ * with how many characters it spans; otherwise return null.
+ */
+export declare function extractAnsiCode(str: string, pos: number): {
+    code: string;
+    length: number;
+} | null;
+/**
+ * Word-wrap text without losing its ANSI styling.
+ *
+ * This handles wrapping alone — it never pads lines out or paints backgrounds.
+ * Every returned line has a visible width no greater than the limit, and any
+ * styling active at a break point is re-applied on the following line.
+ *
+ * @param text - the text to wrap, possibly carrying ANSI codes and newlines
+ * @param width - the largest visible width a single line may reach
+ * @returns the wrapped lines, left un-padded
+ */
+export declare class AnsiCodeManager {
+    private readonly tracker;
+    process(ansiCode: string): void;
+    toAnsiString(): string;
+    reset(): void;
+}
+export declare class TextWrapper {
+    wrap(text: string, width: number): string[];
+}
+export declare const textWrapper: TextWrapper;
+export declare function wrapTextWithAnsi(text: string, width: number): string[];
+/**
+ * Report whether the given character counts as whitespace.
+ */
+export declare function isWhitespaceChar(char: string): boolean;
+/**
+ * Report whether the given character is a punctuation mark.
+ */
+export declare function isPunctuationChar(char: string): boolean;
+/**
+ * Pad a line out to the full width, then run a background-color function over
+ * the result so the colour fills the entire column span.
+ *
+ * @param line - the line to colour (ANSI codes allowed)
+ * @param width - the column width to pad up to
+ * @param bgFn - the function that applies the background colour
+ * @returns the padded line with its background applied
+ */
+export declare function applyBackgroundToLine(line: string, width: number, bgFn: (text: string) => string): string;
+/**
+ * Shorten text so its visible width stays within a cap, tacking on an ellipsis
+ * when something had to be cut. The result can optionally be padded out so it
+ * lands on exactly maxWidth. ANSI escapes are respected and never counted
+ * toward the width.
+ *
+ * @param text - the text to shorten (ANSI codes allowed)
+ * @param maxWidth - the largest visible width permitted
+ * @param ellipsis - what to append once truncation happens (defaults to "...")
+ * @param pad - when true, pad the output with spaces up to exactly maxWidth (defaults to false)
+ * @returns the shortened text, padded to maxWidth if requested
+ */
+export declare function truncateToWidth(text: string, maxWidth: number, ellipsis?: string, pad?: boolean): string;
+/**
+ * Cut out a span of visible columns from a line, coping correctly with ANSI
+ * codes and double-width characters.
+ * @param strict - when true, a wide char straddling the far edge is left out rather than included
+ */
+export declare function sliceByColumn(line: string, startCol: number, length: number, strict?: boolean): string;
+/** Same as sliceByColumn, but additionally reports the visible width of what it returns. */
+export declare function sliceWithWidth(line: string, startCol: number, length: number, strict?: boolean): {
+    text: string;
+    width: number;
+};
+/**
+ * In one traversal, pull out the text that precedes an overlay region and the
+ * text that follows it. This feeds overlay compositing, where both the content
+ * before and the content after the overlay are needed. Styling established
+ * before the overlay is carried over so it still governs the "after" portion.
+ */
+export declare function extractSegments(line: string, beforeEnd: number, afterStart: number, afterLen: number, strictAfter?: boolean): {
+    before: string;
+    beforeWidth: number;
+    after: string;
+    afterWidth: number;
+};

package/dist/types/ui-bridge/InteractiveApp.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The interactive Ink app — a real REPL over the new runtime.
+ *
+ * This is the live terminal surface: it composes the copied react-ink components
+ * (`MessageList`, `TaskPanel`, `StatusLine`, `Footer`) and drives them from the
+ * new runtime's {@link Agent}. The agent owns the conversation; this component is
+ * a *view* over it: on every {@link RunEvent} it re-reads `agent.snapshot()`,
+ * projects it through the ui-bridge adapter (`toAgentMessages` / `liveUsage`),
+ * and folds the result into React state so the screen live-updates as text
+ * streams and tools run.
+ *
+ * Input is a minimal `useInput`-driven controlled buffer (the task allows this
+ * over reusing the heavier TUI editor primitives): printable keys extend the
+ * draft, Backspace trims it, Enter submits it to the agent, and Ctrl-C / Esc tear
+ * the session down. While a run is active the prompt is locked and a "working"
+ * indicator shows; pressing Esc mid-run aborts the run rather than exiting.
+ *
+ * Nothing here mutates the copied react-ink files — it only consumes their public
+ * props (verified against their sources): `MessageList` takes `AgentMessage[]` +
+ * an `InkThemeAdapter`; `Footer`/`StatusLine`/`TaskPanel` take a `SessionSnapshot`
+ * built here from the adapter's `liveUsage` aggregates.
+ */
+import type { Agent } from "../runtime";
+/** Options the host passes when mounting the interactive app. */
+export interface InteractiveAppOptions {
+    /** The model id this run is bound to (rendered in the Footer). */
+    readonly model: string;
+    /** The working directory shown in the Footer's cwd line. */
+    readonly cwd: string;
+    /** Called when the user asks to leave (Ctrl-C / Esc at the prompt, /exit). */
+    readonly onExit: () => void;
+}
+interface InteractiveAppProps extends InteractiveAppOptions {
+    /** The live runtime agent this view renders and drives. */
+    readonly agent: Agent;
+}
+export declare function InteractiveApp({ agent, cwd, model, onExit }: InteractiveAppProps): JSX.Element;
+export {};

package/dist/types/ui-bridge/adapter.d.ts

@@ -0,0 +1,90 @@
+/**
+ * UI bridge: NEW runtime state -> OLD react-ink message shapes.
+ *
+ * The copied react-ink TUI renders an `AgentMessage[]` (the union from
+ * "indusagi/agent": UserMessage | AssistantMessage | ToolResultMessage |
+ * BranchSummaryMessage | CompactionSummaryMessage | CustomMessage |
+ * BashExecutionMessage). It discriminates content blocks by a `type` tag
+ * ("text" | "image" | "thinking" | "toolCall") — see
+ * react-ink/utils/message-groups.ts.
+ *
+ * The new runtime exposes a `RunSnapshot` whose `messages` are `Turn[]`
+ * (user | assistant | tool), each carrying `Block[]` discriminated by a `kind`
+ * tag ("text" | "thinking" | "tool_call" | "tool_result" | "image"), plus a
+ * running `Usage` total and the bound model id.
+ *
+ * This module translates one side into the other. It is purely a *projection*
+ * for rendering: required old fields the renderer does not read are filled with
+ * sensible defaults (zeroed usage, "stop" reasons, best-effort timestamps).
+ *
+ * Imports:
+ *   - NEW types from "../runtime" and "../llmgateway/contract".
+ *   - OLD types from "indusagi/ai" and "indusagi/agent" (the compat shims).
+ */
+import type { RunSnapshot } from "../runtime";
+import type { Reply, Turn, Usage as GatewayUsage } from "../llmgateway/contract";
+import type { AssistantMessage, Usage as MlUsage } from "indusagi/ai";
+import type { AgentMessage } from "indusagi/agent";
+/**
+ * Convert a single new `Turn` into the old message(s) it projects to.
+ *
+ * Returns an array because a tool turn fans out to one message per result. The
+ * `timestamp` is a synthesized, monotonically increasing stamp (the new turns
+ * carry none) so the renderer's relative ordering and time labels stay stable.
+ */
+export declare function turnToAgentMessages(turn: Turn, model: string, timestamp: number): AgentMessage[];
+/**
+ * A finalized model {@link Reply} -> old `AssistantMessage`.
+ *
+ * Useful for hosts that render the just-settled reply (with real usage) before
+ * it is folded into the snapshot's `messages`. Carries the reply's own usage and
+ * stop reason through, mapped to the old shapes.
+ */
+export declare function replyToAssistantMessage(reply: Reply, timestamp?: number): AssistantMessage;
+/**
+ * The core projection: a `RunSnapshot` -> the old `AgentMessage[]` the react-ink
+ * UI renders. Turns are emitted in order; tool turns fan out to one message per
+ * result. A synthetic per-turn timestamp is assigned (new turns carry none).
+ */
+export declare function toAgentMessages(snapshot: RunSnapshot): AgentMessage[];
+/**
+ * Convert a new gateway {@link GatewayUsage} into the old `indusagi/ai` `Usage`
+ * shape, computing `totalTokens` and best-effort `cost` from the catalog card
+ * for `model` (zeroed cost when the model is unknown).
+ */
+export declare function gatewayUsageToMl(usage: GatewayUsage, model: string): MlUsage;
+/**
+ * The shape the Footer / status line needs: the bound model id, its provider/
+ * display label, the token totals (in the old `tokens` sub-shape the Footer
+ * reads), the estimated cost, and the context-window utilization.
+ */
+export interface LiveUsage {
+    /** The model id this run is bound to (e.g. "claude-…"). */
+    readonly model: string;
+    /** Vendor of the bound model, or "unknown" when the id is not in the catalog. */
+    readonly provider: string;
+    /** Human-friendly model name, falling back to the id. */
+    readonly displayName: string;
+    /** Token totals in the old Footer sub-shape (`SessionStats.tokens`). */
+    readonly tokens: {
+        readonly input: number;
+        readonly output: number;
+        readonly cacheRead: number;
+        readonly cacheWrite: number;
+        readonly total: number;
+    };
+    /** Estimated USD cost of the run so far. */
+    readonly cost: number;
+    /** The model's context window in tokens (0 when unknown). */
+    readonly contextWindow: number;
+    /** Billable tokens currently occupying context (input + cache tiers). */
+    readonly contextTokens: number;
+    /** Context utilization as a percentage of `contextWindow` (0 when unknown). */
+    readonly contextPercent: number;
+}
+/**
+ * Derive the Footer-facing live usage from a snapshot: the bound model id, its
+ * catalog metadata, and the run's running token + cost totals. Pure projection
+ * — safe to call on every snapshot.
+ */
+export declare function liveUsage(snapshot: RunSnapshot): LiveUsage;

package/dist/types/ui-bridge/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The ui-bridge barrel.
+ *
+ * One import site for everything a host needs to put the new runtime on screen:
+ * the {@link InteractiveApp} component, the adapter projections that feed it
+ * ({@link toAgentMessages} and friends), and {@link mountInteractive} — the
+ * convenience that renders the app with Ink and resolves once the user leaves.
+ *
+ * The barrel is plain `.ts` (no JSX), so the interactive element is built with
+ * `createElement` from the react-host shim rather than JSX syntax; the component
+ * itself lives in `InteractiveApp.tsx`.
+ */
+import type { Agent } from "../runtime";
+export { InteractiveApp } from "./InteractiveApp";
+export type { InteractiveAppOptions } from "./InteractiveApp";
+export { toAgentMessages, turnToAgentMessages, replyToAssistantMessage, gatewayUsageToMl, liveUsage, type LiveUsage, } from "./adapter";
+/** The options {@link mountInteractive} needs beyond the agent itself. */
+export interface MountOptions {
+    /** The model id this run is bound to (rendered in the Footer). */
+    readonly model: string;
+    /** The working directory shown in the Footer's cwd line; defaults to cwd. */
+    readonly cwd?: string;
+}
+/**
+ * Mount the interactive Ink app over a live runtime {@link Agent} and resolve
+ * the process exit code once the user leaves.
+ *
+ * Ink owns the screen for the lifetime of the call: `render` paints the
+ * {@link InteractiveApp}, the component drives the agent in response to input,
+ * and `onExit` unmounts the tree. `waitUntilExit` resolves when the tree
+ * unmounts (an explicit exit, or Ctrl-C / Esc inside the app). Ctrl-C is handled
+ * inside the component, so Ink's own `exitOnCtrlC` is disabled to keep teardown
+ * in one place. The exit code is always `0` — a clean interactive leave is a
+ * success; run-level failures surface as faulted snapshots in the UI, not as a
+ * non-zero process code.
+ */
+export declare function mountInteractive(agent: Agent, opts: MountOptions): Promise<number>;