mirai-cli 1.0.0

package/src/renderers/register-builtins.ts

@@ -0,0 +1,27 @@
+import { registerRenderer } from './registry.js';
+
+export async function registerBuiltinRenderers(): Promise<void> {
+  const [
+    { ReadFileResult },
+    { WriteFileResult },
+    { EditFileResult },
+    { GlobSearchResult },
+    { GrepSearchResult },
+    { BashResult },
+  ] = await Promise.all([
+    import('./builtins/ReadFileResult.js'),
+    import('./builtins/WriteFileResult.js'),
+    import('./builtins/EditFileResult.js'),
+    import('./builtins/GlobSearchResult.js'),
+    import('./builtins/GrepSearchResult.js'),
+    import('./builtins/BashResult.js'),
+  ]);
+
+  registerRenderer('read_file', ReadFileResult);
+  registerRenderer('write_file', WriteFileResult);
+  registerRenderer('edit_file', EditFileResult);
+  registerRenderer('glob_search', GlobSearchResult);
+  registerRenderer('grep_search', GrepSearchResult);
+  registerRenderer('bash', BashResult);
+  registerRenderer('shell', BashResult);
+}

package/src/renderers/registry.ts

@@ -0,0 +1,37 @@
+import type { ComponentType } from 'react';
+import type { ToolResultBlock } from '@mirai/core/types';
+import { GenericToolResult } from './builtins/GenericToolResult.js';
+
+export type ToolRenderer = ComponentType<{ block: ToolResultBlock }>;
+
+const rendererRegistry = new Map<string, ToolRenderer>();
+
+export function registerRenderer(
+  toolName: string,
+  renderer: ToolRenderer
+): void {
+  if (rendererRegistry.has(toolName)) {
+    console.warn(
+      `[renderer] Overwriting existing renderer for "${toolName}"`
+    );
+  }
+  rendererRegistry.set(toolName, renderer);
+}
+
+export function getRenderer(
+  toolName: string
+): ToolRenderer | undefined {
+  return rendererRegistry.get(toolName);
+}
+
+export function resolveRenderer(
+  toolName: string
+): ToolRenderer {
+  return rendererRegistry.get(toolName) ?? GenericToolResult;
+}
+
+export function hasRenderer(
+  toolName: string
+): boolean {
+  return rendererRegistry.has(toolName);
+}

package/src/renderers/status.ts

@@ -0,0 +1,22 @@
+import { theme } from "../theme.js";
+
+export const STATUS_CONFIG = {
+  success: {
+    icon: '✓',
+    color: theme.success.primary,
+  },
+  error: {
+    icon: '✗',
+    color: theme.error.primary,
+  },
+  timeout: {
+    icon: '⏱',
+    color: theme.warning.primary,
+  },
+  cancelled: {
+    icon: '⊘',
+    color: theme.info.primary,
+  },
+} as const;
+
+export type ToolStatus = keyof typeof STATUS_CONFIG;

package/src/renderers/utils.ts

@@ -0,0 +1,70 @@
+export interface TruncatedOutput {
+  content: string;
+  truncated: boolean;
+}
+
+export function truncateOutputSimple(
+  content: string,
+  maxLines: number,
+  maxChars: number
+): TruncatedOutput {
+  const original = content.trimEnd();
+  if (original.length === 0) {
+    return { content: '', truncated: false };
+  }
+
+  const lines = original.split('\n');
+  const previewLines: string[] = [];
+  let usedChars = 0;
+  let truncated = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    if (i >= maxLines) {
+      truncated = true;
+      break;
+    }
+
+    const line = lines[i];
+    const newlineCost = i > 0 ? 1 : 0;
+    const available = maxChars - usedChars - newlineCost;
+
+    if (available <= 0) {
+      truncated = true;
+      break;
+    }
+
+    if (line.length > available) {
+      previewLines.push(line.slice(0, available) + '\u2026');
+      truncated = true;
+      break;
+    }
+
+    previewLines.push(line);
+    usedChars += newlineCost + line.length;
+  }
+
+  if (lines.length > maxLines || usedChars >= maxChars) {
+    truncated = true;
+  }
+
+  return {
+    content: previewLines.join('\n'),
+    truncated,
+  };
+}
+
+export function truncateForSummary(content: string, limit: number): string {
+  const trimmed = content.trim();
+  if (trimmed.length <= limit) {
+    return trimmed;
+  }
+  return trimmed.slice(0, limit) + '\u2026';
+}
+
+export function safeParseJson(content: string): unknown {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return content;
+  }
+}

package/src/services/hit-test.ts

@@ -0,0 +1,49 @@
+export interface Rect {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+export function inRect(x: number, y: number, rect: Rect): boolean {
+  return (
+    x >= rect.left &&
+    x < rect.left + rect.width &&
+    y >= rect.top &&
+    y < rect.top + rect.height
+  );
+}
+
+export interface HitTestEntry {
+  id: string;
+  zIndex: number;
+  order: number;
+  getRect: () => Rect | null;
+}
+
+export function hitTest(
+  x: number,
+  y: number,
+  entries: HitTestEntry[],
+  skipId?: string,
+): string | null {
+  let best: HitTestEntry | null = null;
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.id === skipId) continue;
+
+    const rect = entry.getRect();
+    if (!rect || !inRect(x, y, rect)) continue;
+
+    if (
+      !best ||
+      entry.zIndex > best.zIndex ||
+      (entry.zIndex === best.zIndex && entry.order > best.order)
+    ) {
+      best = entry;
+    }
+  }
+
+  return best?.id ?? null;
+}

package/src/services/mouse-input.ts

@@ -0,0 +1,237 @@
+import { PassThrough } from "stream";
+
+// ─── State machine ──────────────────────────────────────────
+// Only tracks the states needed for filtering SGR mouse sequences.
+// GROUND → ESC → CSI is the only path we need to intercept.
+const enum SeqState {
+  /** Normal text bytes, passed through immediately */
+  GROUND,
+  /** After receiving \x1b (ESC), waiting for next byte */
+  ESC,
+  /** After receiving \x1b[ (CSI prefix), accumulating params until final byte */
+  CSI,
+}
+
+// ─── SGR mouse regex (matches complete CSI sequences only) ──
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+
+// CSI final bytes are in range 0x40-0x7e
+const isFinal = (b: number) => b >= 0x40 && b <= 0x7e;
+
+export interface MouseState {
+  x: number;
+  y: number;
+  button: "left" | "middle" | "right" | "none";
+  isPressed: boolean;
+  wheelDelta: number;
+}
+
+type Listener = (state: MouseState) => void;
+
+class MouseInputService {
+  private onExitHandler: (() => void) | null = null;
+  private pass = new PassThrough();
+  private listeners = new Set<Listener>();
+  private _enabled = false;
+  private _state: MouseState = { x: 0, y: 0, button: "none", isPressed: false, wheelDelta: 0 };
+
+  // ── Tokenizer state ──
+  private seqState = SeqState.GROUND;
+  /** Buffer for the current escape sequence bytes (ESC + subsequent) */
+  private escSeq: number[] = [];
+  /** Buffer for normal text bytes accumulated between escapes */
+  private textBuf: number[] = [];
+
+  // ── Watchdog ──
+  private watchdogTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly WATCHDOUT_MS = 50;
+
+  readonly stdin = this.pass;
+
+  get isTTY(): boolean {
+    return process.stdin.isTTY === true;
+  }
+
+  get state(): MouseState {
+    return this._state;
+  }
+
+  on(cb: Listener): () => void {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+
+  onExit(cb: () => void): void {
+    this.onExitHandler = cb;
+  }
+
+  enable() {
+    if (this._enabled || !process.stdin.isTTY) return;
+    this._enabled = true;
+
+    process.stdin.setRawMode?.(true);
+    process.stdin.on("readable", this.onReadable);
+    process.stdout.write("\x1b[?1002h\x1b[?1006h");
+  }
+
+  disable() {
+    if (!this._enabled) return;
+    this._enabled = false;
+
+    this.stopWatchdog();
+    process.stdin.off("readable", this.onReadable);
+    process.stdin.setRawMode?.(false);
+    process.stdout.write("\x1b[?1002l\x1b[?1006l");
+  }
+
+  // ── Readable handler ──
+  private onReadable = () => {
+    let chunk: Buffer;
+    while ((chunk = process.stdin.read()) !== null) {
+      for (let i = 0; i < chunk.length; i++) {
+        this.feedByte(chunk[i]!);
+      }
+    }
+    // Flush any text still in buffer so it reaches Ink promptly
+    this.flushText();
+  };
+
+  // ── Byte-at-a-time tokenizer ──
+  private feedByte(byte: number) {
+    if (byte === 0x03) {
+      this.disable();
+      this.onExitHandler?.();
+      return;
+    }
+
+    switch (this.seqState) {
+      // ──── GROUND ────
+      case SeqState.GROUND: {
+        if (byte === 0x1b) {
+          this.flushText();
+          this.seqState = SeqState.ESC;
+          this.escSeq = [byte];
+          this.startWatchdog();
+        } else {
+          this.textBuf.push(byte);
+        }
+        break;
+      }
+
+      // ──── ESC ────
+      case SeqState.ESC: {
+        this.escSeq.push(byte);
+        if (byte === 0x5b /* [ */) {
+          this.seqState = SeqState.CSI;
+          // Watchdog already armed from ESC
+        } else {
+          this.flushEscSeq();
+          this.seqState = SeqState.GROUND;
+          this.stopWatchdog();
+        }
+        break;
+      }
+
+      // ──── CSI ────
+      case SeqState.CSI: {
+        this.escSeq.push(byte);
+        // Restart watchdog on each byte so the timeout is measured from
+        // the most recent byte, not from when CSI was entered.
+        this.restartWatchdog();
+        if (isFinal(byte)) {
+          const seq = Buffer.from(this.escSeq);
+          const s = seq.toString("utf8");
+          const match = SGR_MOUSE_RE.exec(s);
+
+          if (match) {
+            const btn = parseInt(match[1]!, 10);
+            const x = parseInt(match[2]!, 10) - 1;
+            const y = parseInt(match[3]!, 10) - 1;
+            const isRelease = match[4] === "m";
+            const wheel = btn & 0b11000000;
+
+            if (wheel) {
+              if (isRelease) {
+                // skip wheel release events (no listener dispatch)
+              } else {
+                this._state = {
+                  x,
+                  y,
+                  button: "none",
+                  isPressed: false,
+                  wheelDelta: btn === 64 ? 1 : -1,
+                };
+                for (const cb of this.listeners) cb(this._state);
+              }
+            } else {
+              const btnId = btn & 0b11;
+              this._state = {
+                x,
+                y,
+                button:
+                  btnId === 0 ? "left" : btnId === 1 ? "middle" : "right",
+                isPressed: !isRelease,
+                wheelDelta: 0,
+              };
+              for (const cb of this.listeners) cb(this._state);
+            }
+          } else {
+            this.pass.write(seq);
+          }
+
+          this.escSeq = [];
+          this.seqState = SeqState.GROUND;
+          this.stopWatchdog();
+        }
+        break;
+      }
+    }
+  }
+
+  // ── Buffered writes ──
+  private flushText() {
+    if (this.textBuf.length > 0) {
+      this.pass.write(Buffer.from(this.textBuf));
+      this.textBuf = [];
+    }
+  }
+
+  private flushEscSeq() {
+    if (this.escSeq.length > 0) {
+      this.pass.write(Buffer.from(this.escSeq));
+      this.escSeq = [];
+    }
+  }
+
+  // ── Watchdog (ESCDELAY) ──
+  private startWatchdog() {
+    if (this.watchdogTimer) clearTimeout(this.watchdogTimer);
+    this.watchdogTimer = setTimeout(this.onWatchdog, this.WATCHDOUT_MS);
+  }
+
+  private restartWatchdog() {
+    if (this.watchdogTimer) clearTimeout(this.watchdogTimer);
+    this.watchdogTimer = setTimeout(this.onWatchdog, this.WATCHDOUT_MS);
+  }
+
+  private stopWatchdog() {
+    if (this.watchdogTimer) {
+      clearTimeout(this.watchdogTimer);
+      this.watchdogTimer = null;
+    }
+  }
+
+  /** Fires when stdin has been quiet for WATCHDOG_MS while in ESC or CSI.
+   *  Flushes the incomplete sequence as raw bytes (ESCDELAY handling)
+   *  so a lone \x1b (Escape key) reaches Ink as a keypress. */
+  private onWatchdog = () => {
+    this.watchdogTimer = null;
+
+    if (this.seqState === SeqState.ESC || this.seqState === SeqState.CSI) {
+      this.flushEscSeq();
+      this.seqState = SeqState.GROUND;
+    }
+  };
+}
+
+export const mouseInput = new MouseInputService();

package/src/services/scroll-registry.ts

@@ -0,0 +1,64 @@
+import { hitTest, type Rect, type HitTestEntry } from "./hit-test.js";
+
+type ScrollHandler = (delta: number) => boolean;
+
+export interface Region {
+  id: string;
+  zIndex?: number;
+  getRect: () => Rect | null;
+  onScroll: ScrollHandler;
+}
+
+interface InternalRegion extends Region {
+  zIndex: number;
+  order: number;
+}
+
+class ScrollRegistryService {
+  private regions = new Map<string, InternalRegion>();
+  private nextOrder = 0;
+
+  register(region: Region): () => void {
+    const entry: InternalRegion = {
+      ...region,
+      zIndex: region.zIndex ?? 0,
+      order: this.nextOrder++,
+    };
+    this.regions.set(region.id, entry);
+    return () => this.regions.delete(region.id);
+  }
+
+  unregister(id: string): void {
+    this.regions.delete(id);
+  }
+
+  dispatch(x: number, y: number, delta: number): boolean {
+    const entries: HitTestEntry[] = [];
+    for (const region of this.regions.values()) {
+      entries.push({
+        id: region.id,
+        zIndex: region.zIndex,
+        order: region.order,
+        getRect: region.getRect,
+      });
+    }
+
+    let skipId: string | undefined;
+    let handled = false;
+
+    for (;;) {
+      const id = hitTest(x, y, entries, skipId);
+      if (!id) break;
+      handled = true;
+
+      const region = this.regions.get(id)!;
+      const shouldBubble = region.onScroll(delta);
+      if (!shouldBubble) break;
+      skipId = id;
+    }
+
+    return handled;
+  }
+}
+
+export const scrollRegistry = new ScrollRegistryService();

package/src/services/tui-permission-provider.ts

@@ -0,0 +1,35 @@
+import type { PermissionProvider, PermissionRequest, PermissionResponse } from "@mirai/permission";
+
+export type PermissionListener = (request: PermissionRequest | null) => void;
+
+export class TuiPermissionProvider implements PermissionProvider {
+  private pendingResolve: ((response: PermissionResponse) => void) | null = null;
+  private currentRequest: PermissionRequest | null = null;
+  private listener: PermissionListener | null = null;
+
+  onRequest(listener: PermissionListener): void {
+    this.listener = listener;
+  }
+
+  async requestPermission(req: PermissionRequest): Promise<PermissionResponse> {
+    this.currentRequest = req;
+    this.listener?.(req);
+
+    return new Promise<PermissionResponse>((resolve) => {
+      this.pendingResolve = resolve;
+    });
+  }
+
+  resolve(response: PermissionResponse): void {
+    if (this.pendingResolve) {
+      this.pendingResolve(response);
+      this.pendingResolve = null;
+      this.currentRequest = null;
+      this.listener?.(null);
+    }
+  }
+
+  getCurrentRequest(): PermissionRequest | null {
+    return this.currentRequest;
+  }
+}

package/src/theme.ts

@@ -0,0 +1,38 @@
+/* ═══════════════════════════════════════
+   Mirai Theme — Neon Matrix color tokens
+   ═══════════════════════════════════════ */
+
+import { NEON_COLORS } from "@mirai/core/constants";
+
+const [g1, g2, g3, g4] = NEON_COLORS;
+// g1=#39ff14 (bright), g2=#00ff41, g3=#00d936, g4=#a3ff12 (yellow-green)
+
+export const theme = {
+  /** Surfaces & backgrounds */
+  bg: {
+    surface: "#1a1b26",
+    alt: "#16161e",
+    code: "#24283b",
+    overlay: "#000000",
+  },
+
+  /** Text hierarchy */
+  text: {
+    primary: "#c0caf5",
+    dim: "#565f89",
+    muted: "#3b4261",
+  },
+
+  /** Semantic role colors */
+  role: {
+    user: "#7aa2f7",
+    assistant: "#9ece6a",
+    thinking: "#bb9af7",
+  },
+
+  /** Semantic status colors */
+  success: { primary: "#9ece6a", dim: "#1e3b2a" },
+  error: { primary: "#f7768e", dim: "#3a1620" },
+  warning: { primary: "#e0af68", dim: "#3d2e1a" },
+  info: { primary: "#2ac3de", dim: "#143a42" },
+} as const;

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "preserve",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": false,
+    "outDir": "dist",
+    "rootDir": "../..",
+    "baseUrl": ".",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "typeRoots": ["../../node_modules/@types"],
+  },
+  "include": [
+    "src",
+    "bin",
+    "../core",
+    "../protocol",
+    "../llm",
+    "../runtime",
+    "../tools",
+  ],
+  "exclude": ["node_modules", "dist"],
+}