@cjhyy/code-shell 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,336 @@
+import {
+  defineProduct
+} from "./chunk-6JOOLG6F.js";
+import {
+  createRunManager
+} from "./chunk-BHGIJ2DJ.js";
+import {
+  ArtifactTracker,
+  AutoApprovalBackend,
+  BUILTIN_AGENT_PRESETS,
+  BUILTIN_TOOLS,
+  CheckpointWriter,
+  CompositeEvaluator,
+  ContextManager,
+  DEFAULT_AGENT_PRESET,
+  DEFAULT_CLI_PRESET,
+  Engine,
+  EngineRunner,
+  FileRunStore,
+  HeadlessApprovalBackend,
+  Heartbeat,
+  HookRegistry,
+  NoopEvaluator,
+  PermissionClassifier,
+  PromptComposer,
+  RunApprovalBackend,
+  RunLock,
+  RunManager,
+  RunQueue,
+  SectionCache,
+  ToolExecutor,
+  ToolRegistry,
+  VALID_TRANSITIONS,
+  availableSections,
+  buildPresetSystemPrompt,
+  combineInstructions,
+  createRunAskUserFn,
+  listPresetNames,
+  loadSection,
+  loadSections,
+  registerPreset,
+  registerSection,
+  resolveAgentPreset,
+  resolveBuiltinToolNames,
+  scanInstructions,
+  taskManager
+} from "./chunk-7RMAR2Y3.js";
+import {
+  FileHistory
+} from "./chunk-SK62UVS6.js";
+import {
+  ModelPool
+} from "./chunk-KO2FPF7G.js";
+import {
+  SettingsManager,
+  SettingsSchema,
+  init_manager,
+  init_schema,
+  validateSettings
+} from "./chunk-6ZIROYXX.js";
+import "./chunk-OG4MIQJ6.js";
+import {
+  MCPManager
+} from "./chunk-BE6IPRDM.js";
+import {
+  applySummaryCompaction,
+  buildSummarizationPrompt,
+  estimateTokens,
+  init_compaction,
+  microcompact,
+  truncateToolResult,
+  windowCompact
+} from "./chunk-J5XW6UYL.js";
+import "./chunk-4RRUP4MM.js";
+import {
+  MemoryManager
+} from "./chunk-4PKZPFCD.js";
+import {
+  buildSkillListing,
+  matchSkillsByInput,
+  matchSkillsByTool,
+  scanSkills
+} from "./chunk-4SFPFHMG.js";
+import {
+  SessionManager,
+  Transcript
+} from "./chunk-S74VVJBF.js";
+import {
+  IterativeArena,
+  codeFormat,
+  defaultConvergence,
+  diffRatio,
+  documentFormat,
+  getFormat
+} from "./chunk-ZXYDDJEJ.js";
+import {
+  Arena,
+  ArenaLedger,
+  DiscussionStrategy,
+  MODEL_PRESETS,
+  PlanningStrategy,
+  ReviewStrategy,
+  applyReviewResult,
+  buildDigest,
+  collectEvidence,
+  createLLMClient,
+  formatDigest,
+  getMaxOutputTokens,
+  getStrategy,
+  getStrategyForPlan,
+  hasTools,
+  isTerminal,
+  markUnderReview,
+  markUnresolved,
+  planArena,
+  registerClaims,
+  registerProvider,
+  resolveClaimStatus,
+  selectClaimsForReview,
+  selectTools,
+  transitionClaim,
+  validTransitions
+} from "./chunk-SQZHPD3S.js";
+import {
+  logger
+} from "./chunk-X4HAERTQ.js";
+import {
+  AnthropicClient
+} from "./chunk-YZ25SSWJ.js";
+import {
+  OpenAIClient
+} from "./chunk-VKGNCYRL.js";
+import {
+  LLMClientBase
+} from "./chunk-O6F2EF2Z.js";
+import {
+  ConfigError,
+  ContextLimitError,
+  FrameworkError,
+  LLMError,
+  LLMRateLimitError,
+  PermissionDeniedError,
+  SessionError,
+  ToolError,
+  ToolExecutionError,
+  ToolNotFoundError,
+  ToolTimeoutError,
+  TranscriptError
+} from "./chunk-FUOKLKR2.js";
+import "./chunk-C7JBCO5V.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/index.ts
+init_esm_shims();
+init_compaction();
+
+// src/arena/detect-mode.ts
+init_esm_shims();
+var MODE_SIGNALS = {
+  review: [
+    { patterns: [/\breview\b/i, /\baudit\b/i, /\binspect\b/i, /\bcheck\b/i], weight: 2 },
+    { patterns: [/\bcode\s*quality\b/i, /\bbug\b/i, /\bvulnerab/i, /\bsecur/i] },
+    { patterns: [/\bpr\b/i, /\bpull\s*request\b/i, /\bdiff\b/i, /\bchanges?\b/i] },
+    { patterns: [/\brefactor/i, /\bclean\s*up\b/i, /\bimprove\b/i] }
+  ],
+  discussion: [
+    { patterns: [/\bdiscuss\b/i, /\bdebate\b/i, /\bcompare\b/i], weight: 2 },
+    { patterns: [/\bpros?\s*(and|&|\/)\s*cons?\b/i, /\btrade\s*-?\s*offs?\b/i] },
+    { patterns: [/\bshould\s+we\b/i, /\bwhich\s+(is|approach|way)\b/i, /\bvs\.?\b/i] },
+    { patterns: [/\bopinion\b/i, /\bthoughts?\b/i, /\badvice\b/i] }
+  ],
+  planning: [
+    { patterns: [/\bplan\b/i, /\bplanning\b/i, /\broadmap\b/i, /\bstrategy\b/i], weight: 2 },
+    { patterns: [/\barchitect/i, /\bdesign\b/i, /\bproposal\b/i] },
+    { patterns: [/\bimplement(ation)?\s+(plan|strategy|approach)\b/i], weight: 2 },
+    { patterns: [/\bphase\b/i, /\bmilestone\b/i, /\btimeline\b/i, /\bprioritiz/i] },
+    { patterns: [/\bbuild\b/i, /\bcreate\b/i, /\bsetup\b/i, /\bbootstrap\b/i] }
+  ]
+};
+var HIGH_CONFIDENCE_THRESHOLD = 3;
+var MIN_LEAD = 2;
+function detectArenaMode(topic) {
+  const scores = { review: 0, discussion: 0, planning: 0 };
+  for (const [mode, signals] of Object.entries(MODE_SIGNALS)) {
+    for (const signal of signals) {
+      const weight = signal.weight ?? 1;
+      for (const pattern of signal.patterns) {
+        if (pattern.test(topic)) {
+          scores[mode] += weight;
+        }
+      }
+    }
+  }
+  const ranked = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+  const [bestMode, bestScore] = ranked[0];
+  const [, runnerUpScore] = ranked[1];
+  const lead = bestScore - runnerUpScore;
+  if (bestScore >= HIGH_CONFIDENCE_THRESHOLD && lead >= MIN_LEAD) {
+    return {
+      mode: bestMode,
+      confidence: "high",
+      reason: `Topic strongly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`
+    };
+  }
+  if (bestScore > 0 && lead > 0) {
+    return {
+      mode: bestMode,
+      confidence: "low",
+      reason: `Topic weakly matches "${bestMode}" (score: ${bestScore}, lead: +${lead})`
+    };
+  }
+  return {
+    mode: "review",
+    confidence: "low",
+    reason: "No strong mode signal detected, defaulting to review"
+  };
+}
+
+// src/index.ts
+init_manager();
+init_schema();
+var VERSION = "0.1.0";
+export {
+  AnthropicClient,
+  Arena,
+  ArenaLedger,
+  ArtifactTracker,
+  AutoApprovalBackend,
+  BUILTIN_AGENT_PRESETS,
+  BUILTIN_TOOLS,
+  CheckpointWriter,
+  CompositeEvaluator,
+  ConfigError,
+  ContextLimitError,
+  ContextManager,
+  DEFAULT_AGENT_PRESET,
+  DEFAULT_CLI_PRESET,
+  DiscussionStrategy,
+  Engine,
+  EngineRunner,
+  FileHistory,
+  FileRunStore,
+  FrameworkError,
+  HeadlessApprovalBackend,
+  Heartbeat,
+  HookRegistry,
+  IterativeArena,
+  LLMClientBase,
+  LLMError,
+  LLMRateLimitError,
+  MCPManager,
+  MODEL_PRESETS,
+  MemoryManager,
+  ModelPool,
+  NoopEvaluator,
+  OpenAIClient,
+  PermissionClassifier,
+  PermissionDeniedError,
+  PlanningStrategy,
+  PromptComposer,
+  ReviewStrategy,
+  RunApprovalBackend,
+  RunLock,
+  RunManager,
+  RunQueue,
+  SectionCache,
+  SessionError,
+  SessionManager,
+  SettingsManager,
+  SettingsSchema,
+  ToolError,
+  ToolExecutionError,
+  ToolExecutor,
+  ToolNotFoundError,
+  ToolRegistry,
+  ToolTimeoutError,
+  Transcript,
+  TranscriptError,
+  VALID_TRANSITIONS,
+  VERSION,
+  applyReviewResult,
+  applySummaryCompaction,
+  availableSections,
+  buildDigest,
+  buildPresetSystemPrompt,
+  buildSkillListing,
+  buildSummarizationPrompt,
+  collectEvidence,
+  combineInstructions,
+  createLLMClient,
+  createRunAskUserFn,
+  createRunManager,
+  defaultConvergence as defaultIterateConvergence,
+  defineProduct,
+  detectArenaMode,
+  estimateTokens,
+  formatDigest,
+  getFormat as getIterateFormat,
+  getMaxOutputTokens,
+  getStrategy,
+  getStrategyForPlan,
+  hasTools,
+  isTerminal,
+  codeFormat as iterateCodeFormat,
+  diffRatio as iterateDiffRatio,
+  documentFormat as iterateDocumentFormat,
+  listPresetNames,
+  loadSection,
+  loadSections,
+  logger,
+  markUnderReview,
+  markUnresolved,
+  matchSkillsByInput,
+  matchSkillsByTool,
+  microcompact,
+  planArena,
+  registerClaims,
+  registerPreset,
+  registerProvider,
+  registerSection,
+  resolveAgentPreset,
+  resolveBuiltinToolNames,
+  resolveClaimStatus,
+  scanInstructions,
+  scanSkills,
+  selectClaimsForReview,
+  selectTools,
+  taskManager,
+  transitionClaim,
+  truncateToolResult,
+  validTransitions,
+  validateSettings,
+  windowCompact
+};

package/dist/ink/Ansi.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * Component that parses ANSI escape codes and renders them using Text components.
+ *
+ * Use this as an escape hatch when you have pre-formatted ANSI strings from
+ * external tools (like cli-highlight) that need to be rendered in Ink.
+ *
+ * Memoized to prevent re-renders when parent changes but children string is the same.
+ */
+export declare const Ansi: React.NamedExoticComponent<object>;

package/dist/ink/bidi.d.ts

@@ -0,0 +1,15 @@
+type ClusteredChar = {
+    value: string;
+    width: number;
+    styleId: number;
+    hyperlink: string | undefined;
+};
+/**
+ * Reorder an array of ClusteredChars from logical order to visual order
+ * using the Unicode Bidi Algorithm. Active on terminals that lack native
+ * bidi support (Windows Terminal, conhost, WSL).
+ *
+ * Returns the same array on bidi-capable terminals (no-op).
+ */
+export declare function reorderBidi(characters: ClusteredChar[]): ClusteredChar[];
+export {};

package/dist/ink/clearTerminal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Cross-platform terminal clearing with scrollback support.
+ * Detects modern terminals that support ESC[3J for clearing scrollback.
+ */
+/**
+ * Returns the ANSI escape sequence to clear the terminal including scrollback.
+ * Automatically detects terminal capabilities.
+ */
+export declare function getClearTerminalSequence(): string;
+/**
+ * Clears the terminal screen. On supported terminals, also clears scrollback.
+ */
+export declare const clearTerminal: string;

package/dist/ink/colorize.d.ts

@@ -0,0 +1,16 @@
+import type { Color, TextStyles } from './styles.js';
+export declare const CHALK_BOOSTED_FOR_XTERMJS: boolean;
+export declare const CHALK_CLAMPED_FOR_TMUX: boolean;
+export type ColorType = 'foreground' | 'background';
+export declare const colorize: (str: string, color: string | undefined, type: ColorType) => string;
+/**
+ * Apply TextStyles to a string using chalk.
+ * This is the inverse of parsing ANSI codes - we generate them from structured styles.
+ * Theme resolution happens at component layer, not here.
+ */
+export declare function applyTextStyles(text: string, styles: TextStyles): string;
+/**
+ * Apply a raw color value to text.
+ * Theme resolution should happen at component layer, not here.
+ */
+export declare function applyColor(text: string, color: Color | undefined): string;

package/dist/ink/components/AlternateScreen.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Run children in the terminal's alternate screen buffer, constrained to
+ * the viewport height. While mounted:
+ *
+ * - Enters the alt screen (DEC 1049), clears it, homes the cursor
+ * - Constrains its own height to the terminal row count, so overflow must
+ *   be handled via `overflow: scroll` / flexbox (no native scrollback)
+ * - Optionally enables SGR mouse tracking (wheel + click/drag) — events
+ *   surface as `ParsedKey` (wheel) and update the Ink instance's
+ *   selection state (click/drag)
+ *
+ * On unmount, disables mouse tracking and exits the alt screen, restoring
+ * the main screen's content. Safe for use in ctrl-o transcript overlays
+ * and similar temporary fullscreen views — the main screen is preserved.
+ *
+ * Notifies the Ink instance via `setAltScreenActive()` so the renderer
+ * keeps the cursor inside the viewport (preventing the cursor-restore LF
+ * from scrolling content) and so signal-exit cleanup can exit the alt
+ * screen if the component's own unmount doesn't run.
+ */
+export declare function AlternateScreen(t0: any): any;

package/dist/ink/components/App.d.ts

@@ -0,0 +1,70 @@
+import { PureComponent, type ReactNode } from 'react';
+import { EventEmitter } from '../events/emitter.js';
+import { type ParsedKey, type ParsedMouse } from '../parse-keypress.js';
+import { type SelectionState } from '../selection.js';
+import { TerminalQuerier } from '../terminal-querier.js';
+import { type CursorDeclarationSetter } from './CursorDeclarationContext.js';
+type Props = {
+    readonly children: ReactNode;
+    readonly stdin: NodeJS.ReadStream;
+    readonly stdout: NodeJS.WriteStream;
+    readonly stderr: NodeJS.WriteStream;
+    readonly exitOnCtrlC: boolean;
+    readonly onExit: (error?: Error) => void;
+    readonly terminalColumns: number;
+    readonly terminalRows: number;
+    readonly selection: SelectionState;
+    readonly onSelectionChange: () => void;
+    readonly onClickAt: (col: number, row: number) => boolean;
+    readonly onHoverAt: (col: number, row: number) => void;
+    readonly getHyperlinkAt: (col: number, row: number) => string | undefined;
+    readonly onOpenHyperlink: (url: string) => void;
+    readonly onMultiClick: (col: number, row: number, count: 2 | 3) => void;
+    readonly onSelectionDrag: (col: number, row: number) => void;
+    readonly onStdinResume?: () => void;
+    readonly onCursorDeclaration?: CursorDeclarationSetter;
+    readonly dispatchKeyboardEvent: (parsedKey: ParsedKey) => void;
+};
+type State = {
+    readonly error?: Error;
+};
+export default class App extends PureComponent<Props, State> {
+    static displayName: string;
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    state: {
+        error: undefined;
+    };
+    rawModeEnabledCount: number;
+    internal_eventEmitter: EventEmitter;
+    keyParseState: import("../parse-keypress.js").KeyParseState;
+    incompleteEscapeTimer: NodeJS.Timeout | null;
+    readonly NORMAL_TIMEOUT = 50;
+    readonly PASTE_TIMEOUT = 500;
+    querier: TerminalQuerier;
+    lastClickTime: number;
+    lastClickCol: number;
+    lastClickRow: number;
+    clickCount: number;
+    pendingHyperlinkTimer: ReturnType<typeof setTimeout> | null;
+    lastHoverCol: number;
+    lastHoverRow: number;
+    lastStdinTime: number;
+    isRawModeSupported(): boolean;
+    render(): import("react/jsx-runtime").JSX.Element;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidCatch(error: Error): void;
+    handleSetRawMode: (isEnabled: boolean) => void;
+    flushIncomplete: () => void;
+    processInput: (input: string | Buffer | null) => void;
+    handleReadable: () => void;
+    handleInput: (input: string | undefined) => void;
+    handleExit: (error?: Error) => void;
+    handleTerminalFocus: (isFocused: boolean) => void;
+    handleSuspend: () => void;
+}
+/** Exported for testing. Mutates app.props.selection and click/hover state. */
+export declare function handleMouseEvent(app: App, m: ParsedMouse): void;
+export {};

package/dist/ink/components/AppContext.d.ts

@@ -0,0 +1,11 @@
+export type Props = {
+    /**
+     * Exit (unmount) the whole Ink app.
+     */
+    readonly exit: (error?: Error) => void;
+};
+/**
+ * `AppContext` is a React context, which exposes a method to manually exit the app (unmount).
+ */
+declare const AppContext: import("react").Context<Props>;
+export default AppContext;

package/dist/ink/components/Box.d.ts

@@ -0,0 +1,49 @@
+import '../global.d.ts';
+import { type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { ClickEvent } from '../events/click-event.js';
+import type { FocusEvent } from '../events/focus-event.js';
+import type { KeyboardEvent } from '../events/keyboard-event.js';
+import type { Styles } from '../styles.js';
+export type Props = Except<Styles, 'textWrap'> & {
+    ref?: Ref<DOMElement>;
+    /**
+     * Tab order index. Nodes with `tabIndex >= 0` participate in
+     * Tab/Shift+Tab cycling; `-1` means programmatically focusable only.
+     */
+    tabIndex?: number;
+    /**
+     * Focus this element when it mounts. Like the HTML `autofocus`
+     * attribute — the FocusManager calls `focus(node)` during the
+     * reconciler's `commitMount` phase.
+     */
+    autoFocus?: boolean;
+    /**
+     * Fired on left-button click (press + release without drag). Only works
+     * inside `<AlternateScreen>` where mouse tracking is enabled — no-op
+     * otherwise. The event bubbles from the deepest hit Box up through
+     * ancestors; call `event.stopImmediatePropagation()` to stop bubbling.
+     */
+    onClick?: (event: ClickEvent) => void;
+    onFocus?: (event: FocusEvent) => void;
+    onFocusCapture?: (event: FocusEvent) => void;
+    onBlur?: (event: FocusEvent) => void;
+    onBlurCapture?: (event: FocusEvent) => void;
+    onKeyDown?: (event: KeyboardEvent) => void;
+    onKeyDownCapture?: (event: KeyboardEvent) => void;
+    /**
+     * Fired when the mouse moves into this Box's rendered rect. Like DOM
+     * `mouseenter`, does NOT bubble — moving between children does not
+     * re-fire on the parent. Only works inside `<AlternateScreen>` where
+     * mode-1003 mouse tracking is enabled.
+     */
+    onMouseEnter?: () => void;
+    /** Fired when the mouse moves out of this Box's rendered rect. */
+    onMouseLeave?: () => void;
+};
+/**
+ * `<Box>` is an essential Ink component to build your layout. It's like `<div style="display: flex">` in the browser.
+ */
+declare function Box(t0: any): any;
+export default Box;

package/dist/ink/components/Button.d.ts

@@ -0,0 +1,36 @@
+import React, { type Ref } from 'react';
+import type { Except } from 'type-fest';
+import type { DOMElement } from '../dom.js';
+import type { Styles } from '../styles.js';
+type ButtonState = {
+    focused: boolean;
+    hovered: boolean;
+    active: boolean;
+};
+export type Props = Except<Styles, 'textWrap'> & {
+    ref?: Ref<DOMElement>;
+    /**
+     * Called when the button is activated via Enter, Space, or click.
+     */
+    onAction: () => void;
+    /**
+     * Tab order index. Defaults to 0 (in tab order).
+     * Set to -1 for programmatically focusable only.
+     */
+    tabIndex?: number;
+    /**
+     * Focus this button when it mounts.
+     */
+    autoFocus?: boolean;
+    /**
+     * Render prop receiving the interactive state. Use this to
+     * style children based on focus/hover/active — Button itself
+     * is intentionally unstyled.
+     *
+     * If not provided, children render as-is (no state-dependent styling).
+     */
+    children: ((state: ButtonState) => React.ReactNode) | React.ReactNode;
+};
+declare function Button(t0: any): any;
+export default Button;
+export type { ButtonState };

package/dist/ink/components/ClockContext.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type Clock = {
+    subscribe: (onChange: () => void, keepAlive: boolean) => () => void;
+    now: () => number;
+    setTickInterval: (ms: number) => void;
+};
+export declare function createClock(tickIntervalMs: number): Clock;
+export declare const ClockContext: React.Context<Clock | null>;
+export declare function ClockProvider(t0: any): any;

package/dist/ink/components/CursorDeclarationContext.d.ts

@@ -0,0 +1,22 @@
+import type { DOMElement } from '../dom.js';
+export type CursorDeclaration = {
+    /** Display column (terminal cell width) within the declared node */
+    readonly relativeX: number;
+    /** Line number within the declared node */
+    readonly relativeY: number;
+    /** The ink-box DOMElement whose yoga layout provides the absolute origin */
+    readonly node: DOMElement;
+};
+/**
+ * Setter for the declared cursor position.
+ *
+ * The optional second argument makes `null` a conditional clear: the
+ * declaration is only cleared if the currently-declared node matches
+ * `clearIfNode`. This makes the hook safe for sibling components
+ * (e.g. list items) that transfer focus among themselves — without the
+ * node check, a newly-unfocused item's clear could clobber a
+ * newly-focused sibling's set depending on layout-effect order.
+ */
+export type CursorDeclarationSetter = (declaration: CursorDeclaration | null, clearIfNode?: DOMElement | null) => void;
+declare const CursorDeclarationContext: import("react").Context<CursorDeclarationSetter>;
+export default CursorDeclarationContext;

package/dist/ink/components/ErrorOverview.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    readonly error: Error;
+};
+export default function ErrorOverview({ error }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ink/components/Link.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from 'react';
+export type Props = {
+    readonly children?: ReactNode;
+    readonly url: string;
+    readonly fallback?: ReactNode;
+};
+export default function Link(t0: any): any;

package/dist/ink/components/Newline.d.ts

@@ -0,0 +1,12 @@
+export type Props = {
+    /**
+     * Number of newlines to insert.
+     *
+     * @default 1
+     */
+    readonly count?: number;
+};
+/**
+ * Adds one or more newline (\n) characters. Must be used within <Text> components.
+ */
+export default function Newline(t0: any): any;

package/dist/ink/components/NoSelect.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Marks its contents as non-selectable in fullscreen text selection.
+ * Cells inside this box are skipped by both the selection highlight and
+ * the copied text — the gutter stays visually unchanged while the user
+ * drags, making it clear what will be copied.
+ *
+ * Use to fence off gutters (line numbers, diff +/- sigils, list bullets)
+ * so click-drag over rendered code yields clean pasteable content:
+ *
+ *   <Box flexDirection="row">
+ *     <NoSelect fromLeftEdge><Text dimColor> 42 +</Text></NoSelect>
+ *     <Text>const x = 1</Text>
+ *   </Box>
+ *
+ * Only affects alt-screen text selection (<AlternateScreen> with mouse
+ * tracking). No-op in the main-screen scrollback render where the
+ * terminal's native selection is used instead.
+ */
+export declare function NoSelect(t0: any): any;

package/dist/ink/components/RawAnsi.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Bypass the <Ansi> → React tree → Yoga → squash → re-serialize roundtrip for
+ * content that is already terminal-ready.
+ *
+ * Use this when an external renderer (e.g. the ColorDiff NAPI module) has
+ * already produced ANSI-escaped, width-wrapped output. A normal <Ansi> mount
+ * reparses that output into one React <Text> per style span, lays out each
+ * span as a Yoga flex child, then walks the tree to re-emit the same escape
+ * codes it was given. For a long transcript full of syntax-highlighted diffs
+ * that roundtrip is the dominant cost of the render.
+ *
+ * This component emits a single Yoga leaf with a constant-time measure func
+ * (width × lines.length) and hands the joined string straight to output.write(),
+ * which already splits on '\n' and parses ANSI into the screen buffer.
+ */
+export declare function RawAnsi(t0: any): any;