@jun133/kitty 0.0.8 → 0.0.9

package/dist/tui.mjs

@@ -0,0 +1,728 @@
+import {
+  InteractiveSessionDriver,
+  createHostSession,
+  createTerminalLogWriter,
+  formatRelativeSessionTime,
+  formatSessionPickerTitle,
+  mirrorInteractionShellToTerminalLog,
+  parseSessionPickerChoice,
+  renderKittyBanner
+} from "./chunk-6NJJLOY3.mjs";
+import "./chunk-4BN45TQG.mjs";
+import {
+  loadProjectContext
+} from "./chunk-ELBEXOR7.mjs";
+import "./chunk-3KMC6H5K.mjs";
+import {
+  TUI_COLORS,
+  appendTranscriptEntry,
+  appendTranscriptText,
+  applyViewportResize,
+  createInitialTuiState,
+  formatContextBudget,
+  parseSubmittedInputEcho,
+  scrollTuiTranscript,
+  scrollTuiTranscriptToBottom,
+  scrollTuiTranscriptToTop,
+  updateComposerState,
+  updateRuntimeDock
+} from "./chunk-DFDOKON5.mjs";
+
+// src/shell/tui/input/scroll.ts
+var ENABLE_MOUSE_TRACKING = "\x1B[?1000h\x1B[?1002h\x1B[?1006h";
+var DISABLE_MOUSE_TRACKING = "\x1B[?1006l\x1B[?1002l\x1B[?1000l";
+function enableMouseWheelTracking(output = process.stdout) {
+  output.write(ENABLE_MOUSE_TRACKING);
+  let active = true;
+  return () => {
+    if (!active) {
+      return;
+    }
+    active = false;
+    output.write(DISABLE_MOUSE_TRACKING);
+  };
+}
+function parseMouseWheelDelta(input) {
+  let delta = 0;
+  for (const match of input.matchAll(SGR_MOUSE_PATTERN)) {
+    const code = Number(match[1]);
+    if (Number.isNaN(code)) {
+      continue;
+    }
+    if ((code & 64) !== 64) {
+      continue;
+    }
+    delta += (code & 1) === 1 ? 3 : -3;
+  }
+  for (let index = 0; index < input.length - 5; index += 1) {
+    if (input.charCodeAt(index) !== 27 || input[index + 1] !== "[" || input[index + 2] !== "M") {
+      continue;
+    }
+    const code = input.charCodeAt(index + 3) - 32;
+    if ((code & 64) !== 64) {
+      continue;
+    }
+    delta += (code & 1) === 1 ? 3 : -3;
+  }
+  return delta;
+}
+function stripMouseInputSequences(input) {
+  return input.replace(SGR_MOUSE_PATTERN, "").replace(X10_MOUSE_PATTERN, "");
+}
+var SGR_MOUSE_PATTERN = /\x1b\[<(\d+);(\d+);(\d+)([mM])/g;
+var X10_MOUSE_PATTERN = /\x1b\[M[\s-\x7f]{3}/g;
+
+// src/shell/tui/input/gateway.ts
+import { PassThrough } from "stream";
+function createTuiInputGateway(options) {
+  const source = options.source ?? process.stdin;
+  const filtered = new PassThrough();
+  mirrorTtyFacts(source, filtered);
+  const onData = (chunk) => {
+    const text = chunk.toString();
+    const delta = parseMouseWheelDelta(text);
+    if (delta !== 0) {
+      options.onMouseWheel(delta);
+    }
+    const keyboardInput = stripMouseInputSequences(text);
+    if (keyboardInput.length > 0) {
+      filtered.write(keyboardInput);
+    }
+  };
+  source.on("data", onData);
+  return {
+    stdin: filtered,
+    dispose() {
+      source.off("data", onData);
+      filtered.end();
+    }
+  };
+}
+function mirrorTtyFacts(source, target) {
+  const tty = source;
+  const output = target;
+  output.isTTY = Boolean(tty.isTTY);
+  output.setRawMode = (mode) => {
+    tty.setRawMode?.(mode);
+    return output;
+  };
+  output.ref = () => {
+    tty.ref?.();
+    return output;
+  };
+  output.unref = () => {
+    tty.unref?.();
+    return output;
+  };
+}
+
+// src/shell/tui/controller.ts
+var DEFAULT_VIEWPORT = {
+  width: 80,
+  height: 18
+};
+var TuiController = class {
+  state;
+  viewport = DEFAULT_VIEWPORT;
+  listeners = /* @__PURE__ */ new Set();
+  pendingInput = null;
+  interruptHandler;
+  disposed = false;
+  constructor(session) {
+    this.state = createInitialTuiState(session);
+    this.state = applyViewportResize(this.state, this.viewport);
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  setViewport(viewport) {
+    const nextViewport = {
+      width: Math.max(20, Math.floor(viewport.width)),
+      height: Math.max(1, Math.floor(viewport.height))
+    };
+    this.viewport = nextViewport;
+    this.setState(applyViewportResize(this.state, nextViewport));
+  }
+  readInput(promptLabel = "> ") {
+    return this.openInput(promptLabel);
+  }
+  submitInput(value) {
+    const pending = this.pendingInput;
+    if (!pending || this.disposed) {
+      return;
+    }
+    this.pendingInput = null;
+    this.setState(updateComposerState(this.state, {
+      promptLabel: "> "
+    }));
+    pending.resolve({ kind: "submit", value });
+  }
+  closeInput() {
+    const pending = this.pendingInput;
+    this.pendingInput = null;
+    if (pending) {
+      pending.resolve({ kind: "closed" });
+    }
+  }
+  bindInterrupt(handler) {
+    this.interruptHandler = handler;
+    return () => {
+      if (this.interruptHandler === handler) {
+        this.interruptHandler = void 0;
+      }
+    };
+  }
+  interrupt() {
+    this.interruptHandler?.();
+  }
+  append(role, text) {
+    if (!text) {
+      return;
+    }
+    this.setState(appendTranscriptEntry(this.state, { role, text }, this.viewport));
+  }
+  appendStreaming(role, text) {
+    if (!text) {
+      return;
+    }
+    this.setState(appendTranscriptText(this.state, role, text, this.viewport));
+  }
+  appendOutput(text, role = "system") {
+    const submitted = parseSubmittedInputEcho(text);
+    if (submitted !== void 0) {
+      this.append("user", submitted);
+      return;
+    }
+    this.append(role, text);
+  }
+  updateDock(dock) {
+    this.setState(updateRuntimeDock(this.state, dock));
+  }
+  updateSessionFacts(session) {
+    this.updateDock({
+      context: formatContextBudget(session)
+    });
+  }
+  updateComposerVisibleRows(visibleRows) {
+    const normalized = Math.max(1, Math.floor(visibleRows));
+    if (this.state.composer.visibleRows === normalized) {
+      return;
+    }
+    this.setState(updateComposerState(this.state, {
+      visibleRows: normalized
+    }));
+  }
+  scrollBy(delta) {
+    this.setState(scrollTuiTranscript(this.state, this.viewport, delta));
+  }
+  pageUp() {
+    this.scrollBy(-Math.max(1, this.viewport.height - 2));
+  }
+  pageDown() {
+    this.scrollBy(Math.max(1, this.viewport.height - 2));
+  }
+  scrollTop() {
+    this.setState(scrollTuiTranscriptToTop(this.state));
+  }
+  scrollBottom() {
+    this.setState(scrollTuiTranscriptToBottom(this.state, this.viewport));
+  }
+  dispose() {
+    this.disposed = true;
+    this.closeInput();
+    this.listeners.clear();
+  }
+  openInput(promptLabel) {
+    if (this.disposed) {
+      return Promise.resolve({ kind: "closed" });
+    }
+    this.closeInput();
+    this.setState(updateComposerState(this.state, {
+      promptLabel
+    }));
+    return new Promise((resolve) => {
+      this.pendingInput = {
+        resolve
+      };
+    });
+  }
+  setState(state) {
+    this.state = state;
+    for (const listener of this.listeners) {
+      listener(this.state);
+    }
+  }
+};
+
+// src/shell/tui/turnDisplay.ts
+function createTuiTurnDisplay(options) {
+  let aborted = false;
+  const isAborted = () => aborted || options.abortSignal.aborted;
+  const updateWork = (active, label, detail) => {
+    if (!isAborted()) {
+      options.controller.updateDock({
+        work: {
+          active,
+          label,
+          detail
+        }
+      });
+    }
+  };
+  options.abortSignal.addEventListener("abort", () => {
+    aborted = true;
+    updateWork(false, "\u5DF2\u4E2D\u65AD", "\u5F53\u524D\u8F6E\u5DF2\u4E2D\u65AD");
+  });
+  const callbacks = {
+    onModelWaitStart() {
+      updateWork(true, "\u601D\u8003\u4E2D", "\u7B49\u5F85\u6A21\u578B\u56DE\u590D");
+    },
+    onModelWaitStop() {
+      updateWork(false, "\u7A7A\u95F2", "\u6A21\u578B\u7B49\u5F85\u7ED3\u675F");
+    },
+    onReasoningDelta(delta) {
+      if (options.config.showReasoning && !isAborted()) {
+        options.controller.appendStreaming("reasoning", delta);
+      }
+    },
+    onReasoning(text) {
+      if (options.config.showReasoning && !isAborted()) {
+        options.controller.appendStreaming("reasoning", text);
+      }
+    },
+    onAssistantDelta(delta) {
+      if (!isAborted()) {
+        options.controller.appendStreaming("assistant", delta);
+      }
+    },
+    onAssistantText(text) {
+      if (!isAborted()) {
+        options.controller.append("assistant", text);
+      }
+    },
+    onAssistantStage(text) {
+      if (!isAborted()) {
+        options.controller.append("assistant", text);
+      }
+    },
+    onAssistantDone() {
+      updateWork(false, "\u7A7A\u95F2", "\u56DE\u590D\u5B8C\u6210");
+    },
+    onToolCall(name) {
+      if (isAborted()) {
+        return;
+      }
+      const lane = classifyToolLane(name);
+      options.controller.updateDock({
+        work: {
+          active: true,
+          label: "\u6267\u884C\u5DE5\u5177",
+          detail: name
+        },
+        ...lane
+      });
+    },
+    onToolResult(name) {
+      if (isAborted()) {
+        return;
+      }
+      const lane = classifyToolLane(name, "\u5B8C\u6210");
+      options.controller.updateDock({
+        work: {
+          active: false,
+          label: "\u5DE5\u5177\u5B8C\u6210",
+          detail: name
+        },
+        ...lane
+      });
+    },
+    onToolError(name, error) {
+      if (isAborted()) {
+        return;
+      }
+      const lane = classifyToolLane(name, "\u5931\u8D25");
+      options.controller.updateDock({
+        work: {
+          active: false,
+          label: "\u5DE5\u5177\u5931\u8D25",
+          detail: `${name}: ${shorten(error)}`
+        },
+        ...lane
+      });
+      options.controller.append("system", `\u5DE5\u5177\u5931\u8D25\uFF1A${name}`);
+    },
+    onStatus(text) {
+      if (isAborted()) {
+        return;
+      }
+      options.controller.updateDock({
+        work: {
+          active: text.trim().length > 0,
+          label: text.trim() ? "\u72B6\u6001" : "\u7A7A\u95F2",
+          detail: text.trim() || "\u7A7A\u95F2"
+        }
+      });
+    }
+  };
+  return {
+    callbacks,
+    flush() {
+      options.controller.updateDock({
+        work: {
+          active: false,
+          label: "\u7A7A\u95F2",
+          detail: "\u5F53\u524D\u8F6E\u5DF2\u6536\u53E3"
+        }
+      });
+    },
+    dispose() {
+      options.controller.updateDock({
+        work: {
+          active: false,
+          label: "\u7A7A\u95F2",
+          detail: "\u6CA1\u6709\u4EFB\u52A1\u6B63\u5728\u6267\u884C"
+        }
+      });
+    }
+  };
+}
+function classifyToolLane(name, suffix = "\u8FD0\u884C\u4E2D") {
+  const normalized = name.toLowerCase();
+  if (normalized.includes("background")) {
+    return { background: `${name} ${suffix}` };
+  }
+  if (normalized.includes("subagent")) {
+    return { subagent: `${name} ${suffix}` };
+  }
+  return {};
+}
+function shorten(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= 80) {
+    return normalized;
+  }
+  return `${normalized.slice(0, 77)}...`;
+}
+
+// src/shell/tui/shell.ts
+function createTuiInteractionShell(controller) {
+  return {
+    input: createTuiInputPort(controller),
+    output: createTuiOutputPort(controller),
+    createTurnDisplay(options) {
+      return createTuiTurnDisplay({
+        controller,
+        config: options.config,
+        abortSignal: options.abortSignal
+      });
+    },
+    dispose() {
+      controller.dispose();
+    }
+  };
+}
+function createTuiInputPort(controller) {
+  return {
+    readInput(promptLabel) {
+      return controller.readInput(promptLabel);
+    },
+    bindInterrupt(handler) {
+      return controller.bindInterrupt(handler);
+    }
+  };
+}
+function createTuiOutputPort(controller) {
+  return {
+    plain(text) {
+      controller.appendOutput(text, "system");
+    },
+    info(text) {
+      controller.appendOutput(text, "system");
+    },
+    warn(text) {
+      controller.appendOutput(text, "system");
+      controller.updateDock({
+        work: {
+          active: false,
+          label: "\u63D0\u9192",
+          detail: text
+        }
+      });
+    },
+    error(text) {
+      controller.appendOutput(text, "system");
+      controller.updateDock({
+        work: {
+          active: false,
+          label: "\u9519\u8BEF",
+          detail: text
+        }
+      });
+    },
+    dim(text) {
+      controller.appendOutput(text, "system");
+    },
+    heading(text) {
+      controller.appendOutput(text, "system");
+    },
+    interrupt(text) {
+      controller.appendOutput(text, "system");
+      controller.updateDock({
+        work: {
+          active: false,
+          label: "\u4E2D\u65AD",
+          detail: text
+        }
+      });
+    }
+  };
+}
+
+// src/shell/tui/lifecycle.ts
+function createCleanupStack() {
+  const cleanups = [];
+  let disposed = false;
+  return {
+    add(cleanup) {
+      if (!cleanup) {
+        return;
+      }
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    run() {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      for (const cleanup of cleanups.splice(0).reverse()) {
+        cleanup();
+      }
+    }
+  };
+}
+
+// src/shell/tui/sessionPicker.ts
+async function selectTuiSession(options) {
+  const sessions = await options.sessionStore.list(options.limit ?? 10);
+  if (sessions.length === 0) {
+    return {
+      session: await createHostSession(options.sessionStore, options.cwd),
+      cwd: options.cwd
+    };
+  }
+  return new Promise((resolve) => {
+    let app;
+    const finish = async (choice) => {
+      app?.unmount();
+      await app?.waitUntilExit().catch(() => void 0);
+      if (choice === null) {
+        resolve(null);
+        return;
+      }
+      if (choice === 0) {
+        resolve({
+          session: await createHostSession(options.sessionStore, options.cwd),
+          cwd: options.cwd
+        });
+        return;
+      }
+      const session = sessions[choice - 1];
+      if (!session) {
+        resolve(null);
+        return;
+      }
+      resolve({
+        session,
+        cwd: options.cwdOverridden ? options.cwd : session.cwd
+      });
+    };
+    const Picker = createTuiSessionPickerComponent({
+      React: options.React,
+      Box: options.ink.Box,
+      Text: options.ink.Text,
+      useInput: options.ink.useInput,
+      useStdout: options.ink.useStdout
+    });
+    app = options.ink.render(
+      options.React.createElement(Picker, {
+        sessions,
+        now: /* @__PURE__ */ new Date(),
+        onSelect: (choice) => {
+          void finish(choice);
+        },
+        onCancel: () => {
+          void finish(null);
+        }
+      }),
+      {
+        exitOnCtrlC: false,
+        alternateScreen: true
+      }
+    );
+  });
+}
+function createTuiSessionPickerComponent(kit) {
+  const { React, Box, Text, useInput, useStdout } = kit;
+  return function TuiSessionPicker(props) {
+    const [cursor, setCursor] = React.useState(1);
+    const { stdout } = useStdout();
+    const width = Math.max(40, stdout.columns ?? 80);
+    const choices = props.sessions.length + 1;
+    useInput((input, key) => {
+      if (key.ctrl && input === "c") {
+        props.onCancel();
+        return;
+      }
+      if (key.escape) {
+        props.onCancel();
+        return;
+      }
+      if (key.upArrow) {
+        setCursor((value) => wrapChoice(value - 1, choices));
+        return;
+      }
+      if (key.downArrow) {
+        setCursor((value) => wrapChoice(value + 1, choices));
+        return;
+      }
+      if (key.return) {
+        props.onSelect(cursor);
+        return;
+      }
+      const parsed = parseSessionPickerChoice(input, props.sessions.length);
+      if (parsed.kind === "new") {
+        props.onSelect(0);
+      } else if (parsed.kind === "existing") {
+        props.onSelect(parsed.index + 1);
+      }
+    });
+    return React.createElement(
+      Box,
+      {
+        flexDirection: "column",
+        width,
+        minHeight: 16,
+        paddingX: 3,
+        paddingY: 1,
+        backgroundColor: TUI_COLORS.background
+      },
+      React.createElement(Text, { color: TUI_COLORS.user, bold: true }, "Kitty Agent"),
+      React.createElement(Text, { color: TUI_COLORS.user, bold: true }, renderKittyBanner()),
+      React.createElement(Text, { color: TUI_COLORS.muted }, "\u9009\u62E9\u4F1A\u8BDD\u3002Enter \u8FDB\u5165\uFF0C\u2191/\u2193 \u5207\u6362\uFF0C0 \u65B0\u5EFA\uFF0CEsc \u9000\u51FA\u3002"),
+      React.createElement(
+        Box,
+        { marginTop: 1, flexDirection: "column" },
+        renderChoiceLine(React, Text, cursor === 0, "0", "\u65B0\u5EFA\u4F1A\u8BDD", ""),
+        ...props.sessions.map((session, index) => renderChoiceLine(
+          React,
+          Text,
+          cursor === index + 1,
+          String(index + 1),
+          formatSessionPickerTitle(session),
+          formatRelativeSessionTime(session.updatedAt, props.now)
+        ))
+      )
+    );
+  };
+}
+function renderChoiceLine(React, Text, selected, index, title, meta) {
+  return React.createElement(
+    Text,
+    { color: selected ? TUI_COLORS.user : TUI_COLORS.text, bold: selected },
+    `${selected ? "\u2503" : " "} ${index}. ${title}${meta ? `  ${meta}` : ""}`
+  );
+}
+function wrapChoice(value, count) {
+  if (value < 0) {
+    return count - 1;
+  }
+  if (value >= count) {
+    return 0;
+  }
+  return value;
+}
+
+// src/shell/tui/start.ts
+async function startTuiChat(options) {
+  const cleanup = createCleanupStack();
+  const [{ default: React }, ink, { createTuiAppComponent }] = await Promise.all([
+    import("react"),
+    import("ink"),
+    import("./App-6FETP3LH.mjs")
+  ]);
+  const selected = await selectTuiSession({
+    cwd: options.cwd,
+    cwdOverridden: Boolean(options.cwdOverridden),
+    sessionStore: options.sessionStore,
+    React,
+    ink
+  });
+  if (!selected) {
+    return;
+  }
+  const projectContext = await loadProjectContext(selected.cwd, {
+    projectDocMaxBytes: options.config.projectDocMaxBytes
+  });
+  const controller = new TuiController(selected.session);
+  const shell = createTuiInteractionShell(controller);
+  const terminalLogWriter = createTerminalLogWriter(projectContext.stateRootDir, selected.session.id);
+  const terminalShell = mirrorInteractionShellToTerminalLog(shell, terminalLogWriter);
+  const inputGateway = createTuiInputGateway({
+    onMouseWheel: (delta) => {
+      controller.scrollBy(delta);
+    }
+  });
+  const TuiApp = createTuiAppComponent({
+    React,
+    Box: ink.Box,
+    Text: ink.Text,
+    useInput: ink.useInput,
+    useBoxMetrics: ink.useBoxMetrics,
+    useCursor: ink.useCursor,
+    useStdout: ink.useStdout
+  });
+  const app = ink.render(
+    React.createElement(TuiApp, {
+      controller,
+      enableMouseTracking: () => enableMouseWheelTracking(process.stdout)
+    }),
+    {
+      stdin: inputGateway.stdin,
+      exitOnCtrlC: false,
+      alternateScreen: true
+    }
+  );
+  cleanup.add(() => inputGateway.dispose());
+  cleanup.add(() => terminalShell.dispose?.());
+  cleanup.add(() => app.unmount());
+  const driver = new InteractiveSessionDriver({
+    cwd: selected.cwd,
+    config: options.config,
+    session: selected.session,
+    sessionStore: options.sessionStore,
+    shell: terminalShell,
+    onSessionUpdated(session) {
+      controller.updateSessionFacts(session);
+    }
+  });
+  try {
+    await driver.run();
+  } finally {
+    cleanup.run();
+    await app.waitUntilExit().catch(() => void 0);
+  }
+}
+export {
+  startTuiChat
+};