@cjhyy/code-shell 0.1.0-alpha.0

package/dist/ink/output.d.ts

@@ -0,0 +1,119 @@
+import { type Rectangle } from './layout/geometry.js';
+import { type Screen, type StylePool } from './screen.js';
+/**
+ * Collects write/blit/clear/clip operations from the render tree, then
+ * applies them to a Screen buffer in `get()`. The Screen is what gets
+ * diffed against the previous frame to produce terminal updates.
+ */
+type Options = {
+    width: number;
+    height: number;
+    stylePool: StylePool;
+    /**
+     * Screen to render into. Will be reset before use.
+     * For double-buffering, pass a reusable screen. Otherwise create a new one.
+     */
+    screen: Screen;
+};
+export type Operation = WriteOperation | ClipOperation | UnclipOperation | BlitOperation | ClearOperation | NoSelectOperation | ShiftOperation;
+type WriteOperation = {
+    type: 'write';
+    x: number;
+    y: number;
+    text: string;
+    /**
+     * Per-line soft-wrap flags, parallel to text.split('\n'). softWrap[i]=true
+     * means line i is a continuation of line i-1 (the `\n` before it was
+     * inserted by word-wrap, not in the source). Index 0 is always false.
+     * Undefined means the producer didn't track wrapping (e.g. fills,
+     * raw-ansi) — the screen's per-row bitmap is left untouched.
+     */
+    softWrap?: boolean[];
+};
+type ClipOperation = {
+    type: 'clip';
+    clip: Clip;
+};
+export type Clip = {
+    x1: number | undefined;
+    x2: number | undefined;
+    y1: number | undefined;
+    y2: number | undefined;
+};
+type UnclipOperation = {
+    type: 'unclip';
+};
+type BlitOperation = {
+    type: 'blit';
+    src: Screen;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+type ShiftOperation = {
+    type: 'shift';
+    top: number;
+    bottom: number;
+    n: number;
+};
+type ClearOperation = {
+    type: 'clear';
+    region: Rectangle;
+    /**
+     * Set when the clear is for an absolute-positioned node's old bounds.
+     * Absolute nodes overlay normal-flow siblings, so their stale paint is
+     * what an earlier sibling's clean-subtree blit wrongly restores from
+     * prevScreen. Normal-flow siblings' clears don't have this problem —
+     * their old position can't have been painted on top of a sibling.
+     */
+    fromAbsolute?: boolean;
+};
+type NoSelectOperation = {
+    type: 'noSelect';
+    region: Rectangle;
+};
+export default class Output {
+    width: number;
+    height: number;
+    private readonly stylePool;
+    private screen;
+    private readonly operations;
+    private charCache;
+    constructor(options: Options);
+    /**
+     * Reuse this Output for a new frame. Zeroes the screen buffer, clears
+     * the operation list (backing storage is retained), and caps charCache
+     * growth. Preserving charCache across frames is the main win — most
+     * lines don't change between renders, so tokenize + grapheme clustering
+     * becomes a cache hit.
+     */
+    reset(width: number, height: number, screen: Screen): void;
+    /**
+     * Copy cells from a source screen region (blit = block image transfer).
+     */
+    blit(src: Screen, x: number, y: number, width: number, height: number): void;
+    /**
+     * Shift full-width rows within [top, bottom] by n. n > 0 = up. Mirrors
+     * what DECSTBM + SU/SD does to the terminal. Paired with blit() to reuse
+     * prevScreen content during pure scroll, avoiding full child re-render.
+     */
+    shift(top: number, bottom: number, n: number): void;
+    /**
+     * Clear a region by writing empty cells. Used when a node shrinks to
+     * ensure stale content from the previous frame is removed.
+     */
+    clear(region: Rectangle, fromAbsolute?: boolean): void;
+    /**
+     * Mark a region as non-selectable (excluded from fullscreen text
+     * selection copy + highlight). Used by <NoSelect> to fence off
+     * gutters (line numbers, diff sigils). Applied AFTER blit/write so
+     * the mark wins regardless of what's blitted into the region.
+     */
+    noSelect(region: Rectangle): void;
+    write(x: number, y: number, text: string, softWrap?: boolean[]): void;
+    clip(clip: Clip): void;
+    unclip(): void;
+    get(): Screen;
+}
+export {};

package/dist/ink/parse-keypress.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Keyboard input parser - converts terminal input to key events
+ *
+ * Uses the termio tokenizer for escape sequence boundary detection,
+ * then interprets sequences as keypresses.
+ */
+import { Buffer } from 'buffer';
+import { type Tokenizer } from './termio/tokenize.js';
+/** DECRPM status values (response to DECRQM) */
+export declare const DECRPM_STATUS: {
+    readonly NOT_RECOGNIZED: 0;
+    readonly SET: 1;
+    readonly RESET: 2;
+    readonly PERMANENTLY_SET: 3;
+    readonly PERMANENTLY_RESET: 4;
+};
+/**
+ * A response sequence received from the terminal (not a keypress).
+ * Emitted in answer to queries like DECRQM, DA1, OSC 11, etc.
+ */
+export type TerminalResponse = 
+/** DECRPM: answer to DECRQM (request DEC private mode status) */
+{
+    type: 'decrpm';
+    mode: number;
+    status: number;
+}
+/** DA1: primary device attributes (used as a universal sentinel) */
+ | {
+    type: 'da1';
+    params: number[];
+}
+/** DA2: secondary device attributes (terminal version info) */
+ | {
+    type: 'da2';
+    params: number[];
+}
+/** Kitty keyboard protocol: current flags (answer to CSI ? u) */
+ | {
+    type: 'kittyKeyboard';
+    flags: number;
+}
+/** DSR: cursor position report (answer to CSI 6 n) */
+ | {
+    type: 'cursorPosition';
+    row: number;
+    col: number;
+}
+/** OSC response: generic operating-system-command reply (e.g. OSC 11 bg color) */
+ | {
+    type: 'osc';
+    code: number;
+    data: string;
+}
+/** XTVERSION: terminal name/version string (answer to CSI > 0 q).
+ *  Example values: "xterm.js(5.5.0)", "ghostty 1.2.0", "iTerm2 3.6". */
+ | {
+    type: 'xtversion';
+    name: string;
+};
+export type KeyParseState = {
+    mode: 'NORMAL' | 'IN_PASTE';
+    incomplete: string;
+    pasteBuffer: string;
+    _tokenizer?: Tokenizer;
+};
+export declare const INITIAL_STATE: KeyParseState;
+export declare function parseMultipleKeypresses(prevState: KeyParseState, input?: Buffer | string | null): [ParsedInput[], KeyParseState];
+export declare const nonAlphanumericKeys: string[];
+export type ParsedKey = {
+    kind: 'key';
+    fn: boolean;
+    name: string | undefined;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+    option: boolean;
+    super: boolean;
+    sequence: string | undefined;
+    raw: string | undefined;
+    code?: string;
+    isPasted: boolean;
+};
+/** A terminal response sequence (DECRPM, DA1, OSC reply, etc.) parsed
+ *  out of the input stream. Not user input — consumers should dispatch
+ *  to a response handler. */
+export type ParsedResponse = {
+    kind: 'response';
+    /** Raw escape sequence bytes, for debugging/logging */
+    sequence: string;
+    response: TerminalResponse;
+};
+/** SGR mouse event with coordinates. Emitted for clicks, drags, and
+ *  releases (wheel events remain ParsedKey). col/row are 1-indexed
+ *  from the terminal sequence (CSI < btn;col;row M/m). */
+export type ParsedMouse = {
+    kind: 'mouse';
+    /** Raw SGR button code. Low 2 bits = button (0=left,1=mid,2=right),
+     *  bit 5 (0x20) = drag/motion, bit 6 (0x40) = wheel. */
+    button: number;
+    /** 'press' for M terminator, 'release' for m terminator */
+    action: 'press' | 'release';
+    /** 1-indexed column (from terminal) */
+    col: number;
+    /** 1-indexed row (from terminal) */
+    row: number;
+    sequence: string;
+};
+/** Everything that can come out of the input parser: a user keypress/paste,
+ *  a mouse click/drag event, or a terminal response to a query we sent. */
+export type ParsedInput = ParsedKey | ParsedMouse | ParsedResponse;

package/dist/ink/reconciler.d.ts

@@ -0,0 +1,11 @@
+import { Dispatcher } from './events/dispatcher.js';
+export declare function getOwnerChain(fiber: unknown): string[];
+export declare function isDebugRepaintsEnabled(): boolean;
+export declare const dispatcher: Dispatcher;
+export declare function recordYogaMs(ms: number): void;
+export declare function getLastYogaMs(): number;
+export declare function markCommitStart(): void;
+export declare function getLastCommitMs(): number;
+export declare function resetProfileCounters(): void;
+declare const reconciler: any;
+export default reconciler;

package/dist/ink/render-border.d.ts

@@ -0,0 +1,24 @@
+import { type Boxes, type BoxStyle } from 'cli-boxes';
+import type { DOMNode } from './dom.js';
+import type Output from './output.js';
+export type BorderTextOptions = {
+    content: string;
+    position: 'top' | 'bottom';
+    align: 'start' | 'end' | 'center';
+    offset?: number;
+};
+export declare const CUSTOM_BORDER_STYLES: {
+    readonly dashed: {
+        readonly top: "╌";
+        readonly left: "╎";
+        readonly right: "╎";
+        readonly bottom: "╌";
+        readonly topLeft: " ";
+        readonly topRight: " ";
+        readonly bottomLeft: " ";
+        readonly bottomRight: " ";
+    };
+};
+export type BorderStyle = keyof Boxes | keyof typeof CUSTOM_BORDER_STYLES | BoxStyle;
+declare const renderBorder: (x: number, y: number, node: DOMNode, output: Output) => void;
+export default renderBorder;

package/dist/ink/render-node-to-output.d.ts

@@ -0,0 +1,45 @@
+import type { DOMElement } from './dom.js';
+import type Output from './output.js';
+import type { Screen } from './screen.js';
+import { type StyledSegment } from './squash-text-nodes.js';
+import type { Color } from './styles.js';
+export declare function resetLayoutShifted(): void;
+export declare function didLayoutShift(): boolean;
+export type ScrollHint = {
+    top: number;
+    bottom: number;
+    delta: number;
+};
+export declare function resetScrollHint(): void;
+export declare function getScrollHint(): ScrollHint | null;
+export declare function resetScrollDrainNode(): void;
+export declare function getScrollDrainNode(): DOMElement | null;
+export type FollowScroll = {
+    delta: number;
+    viewportTop: number;
+    viewportBottom: number;
+};
+export declare function consumeFollowScroll(): FollowScroll | null;
+/**
+ * Build a mapping from each character position in the plain text to its segment index.
+ * Returns an array where charToSegment[i] is the segment index for character i.
+ */
+declare function buildCharToSegmentMap(segments: StyledSegment[]): number[];
+/**
+ * Apply styles to wrapped text by mapping each character back to its original segment.
+ * This preserves per-segment styles even when text wraps across lines.
+ *
+ * @param trimEnabled - Whether whitespace trimming is enabled (wrap-trim mode).
+ *   When true, we skip whitespace in the original that was trimmed from the output.
+ *   When false (wrap mode), all whitespace is preserved so no skipping is needed.
+ */
+declare function applyStylesToWrappedText(wrappedPlain: string, segments: StyledSegment[], charToSegment: number[], originalPlain: string, trimEnabled?: boolean): string;
+declare function renderNodeToOutput(node: DOMElement, output: Output, { offsetX, offsetY, prevScreen, skipSelfBlit, inheritedBackgroundColor, }: {
+    offsetX?: number;
+    offsetY?: number;
+    prevScreen: Screen | undefined;
+    skipSelfBlit?: boolean;
+    inheritedBackgroundColor?: Color;
+}): void;
+export { buildCharToSegmentMap, applyStylesToWrappedText };
+export default renderNodeToOutput;

package/dist/ink/render-to-screen.d.ts

@@ -0,0 +1,46 @@
+import type { ReactElement } from 'react';
+import { type Screen, StylePool } from './screen.js';
+/** Position of a match within a rendered message, relative to the message's
+ *  own bounding box (row 0 = message top). Stable across scroll — to
+ *  highlight on the real screen, add the message's screen-row offset. */
+export type MatchPosition = {
+    row: number;
+    col: number;
+    /** Number of CELLS the match spans (= query.length for ASCII, more
+     *  for wide chars in the query). */
+    len: number;
+};
+/** Render a React element (wrapped in all contexts the component needs —
+ *  caller's job) to an isolated Screen buffer at the given width. Returns
+ *  the Screen + natural height (from yoga). Used for search: render ONE
+ *  message, scan its Screen for the query, get exact (row, col) positions.
+ *
+ *  ~1-3ms per call (yoga alloc + calculateLayout + paint). The
+ *  flushSyncWork cross-root leak measured ~0.0003ms/call growth — fine
+ *  for on-demand single-message rendering, pathological for render-all-
+ *  8k-upfront. Cache per (msg, query, width) upstream.
+ *
+ *  Unmounts between calls. Root/container/pools persist for reuse. */
+export declare function renderToScreen(el: ReactElement, width: number): {
+    screen: Screen;
+    height: number;
+};
+/** Scan a Screen buffer for all occurrences of query. Returns positions
+ *  relative to the buffer (row 0 = buffer top). Same cell-skip logic as
+ *  applySearchHighlight (SpacerTail/SpacerHead/noSelect) so positions
+ *  match what the overlay highlight would find. Case-insensitive.
+ *
+ *  For the side-render use: this Screen is the FULL message (natural
+ *  height, not viewport-clipped). Positions are stable — to highlight
+ *  on the real screen, add the message's screen offset (lo). */
+export declare function scanPositions(screen: Screen, query: string): MatchPosition[];
+/** Write CURRENT (yellow+bold+underline) at positions[currentIdx] +
+ *  rowOffset. OTHER positions are NOT styled here — the scan-highlight
+ *  (applySearchHighlight with null hint) does inverse for all visible
+ *  matches, including these. Two-layer: scan = 'you could go here',
+ *  position = 'you ARE here'. Writing inverse again here would be a
+ *  no-op (withInverse idempotent) but wasted work.
+ *
+ *  Positions are message-relative (row 0 = message top). rowOffset =
+ *  message's current screen-top (lo). Clips outside [0, height). */
+export declare function applyPositionedHighlight(screen: Screen, stylePool: StylePool, positions: MatchPosition[], rowOffset: number, currentIdx: number): boolean;

package/dist/ink/renderer.d.ts

@@ -0,0 +1,14 @@
+import { type DOMElement } from './dom.js';
+import type { Frame } from './frame.js';
+import { type StylePool } from './screen.js';
+export type RenderOptions = {
+    frontFrame: Frame;
+    backFrame: Frame;
+    isTTY: boolean;
+    terminalWidth: number;
+    terminalRows: number;
+    altScreen: boolean;
+    prevFrameContaminated: boolean;
+};
+export type Renderer = (options: RenderOptions) => Frame;
+export default function createRenderer(node: DOMElement, stylePool: StylePool): Renderer;

package/dist/ink/root.d.ts

@@ -0,0 +1,74 @@
+import type { ReactNode } from 'react';
+import type { FrameEvent } from './frame.js';
+import Ink from './ink.js';
+export type RenderOptions = {
+    /**
+     * Output stream where app will be rendered.
+     *
+     * @default process.stdout
+     */
+    stdout?: NodeJS.WriteStream;
+    /**
+     * Input stream where app will listen for input.
+     *
+     * @default process.stdin
+     */
+    stdin?: NodeJS.ReadStream;
+    /**
+     * Error stream.
+     * @default process.stderr
+     */
+    stderr?: NodeJS.WriteStream;
+    /**
+     * Configure whether Ink should listen to Ctrl+C keyboard input and exit the app. This is needed in case `process.stdin` is in raw mode, because then Ctrl+C is ignored by default and process is expected to handle it manually.
+     *
+     * @default true
+     */
+    exitOnCtrlC?: boolean;
+    /**
+     * Patch console methods to ensure console output doesn't mix with Ink output.
+     *
+     * @default true
+     */
+    patchConsole?: boolean;
+    /**
+     * Called after each frame render with timing and flicker information.
+     */
+    onFrame?: (event: FrameEvent) => void;
+};
+export type Instance = {
+    /**
+     * Replace previous root node with a new one or update props of the current root node.
+     */
+    rerender: Ink['render'];
+    /**
+     * Manually unmount the whole Ink app.
+     */
+    unmount: Ink['unmount'];
+    /**
+     * Returns a promise, which resolves when app is unmounted.
+     */
+    waitUntilExit: Ink['waitUntilExit'];
+    cleanup: () => void;
+};
+/**
+ * A managed Ink root, similar to react-dom's createRoot API.
+ * Separates instance creation from rendering so the same root
+ * can be reused for multiple sequential screens.
+ */
+export type Root = {
+    render: (node: ReactNode) => void;
+    unmount: () => void;
+    waitUntilExit: () => Promise<void>;
+};
+/**
+ * Mount a component and render the output.
+ */
+export declare const renderSync: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Instance;
+declare const wrappedRender: (node: ReactNode, options?: NodeJS.WriteStream | RenderOptions) => Promise<Instance>;
+export default wrappedRender;
+/**
+ * Create an Ink root without rendering anything yet.
+ * Like react-dom's createRoot — call root.render() to mount a tree.
+ */
+export declare function createRoot({ stdout, stdin, stderr, exitOnCtrlC, patchConsole, onFrame, }?: RenderOptions): Promise<Root>;