@jun133/kitty 0.0.8 → 0.0.9

package/dist/interactive-KLW4JL7R.mjs

@@ -0,0 +1,340 @@
+import {
+  InteractiveSessionDriver,
+  createTerminalLogWriter,
+  formatLocalCommandHelpLine,
+  listIntroLocalCommands,
+  mirrorInteractionShellToTerminalLog,
+  mirrorProcessOutputToTerminalLog,
+  renderKittyBanner,
+  ui
+} from "./chunk-6NJJLOY3.mjs";
+import "./chunk-4BN45TQG.mjs";
+import {
+  createRuntimeUiAgentCallbacks
+} from "./chunk-YSWK3BGL.mjs";
+import {
+  colorRuntimeUiText,
+  loadProjectContext,
+  writeStdout
+} from "./chunk-ELBEXOR7.mjs";
+import "./chunk-3KMC6H5K.mjs";
+
+// src/shell/cli/intro.ts
+import chalk from "chalk";
+function writeCliInteractiveIntro(options) {
+  options.output.plain(chalk.bold(chalk.greenBright(renderKittyBanner())));
+  options.output.dim(`session: ${options.session.id}`);
+  options.output.dim(`cwd: ${options.cwd}`);
+  if (options.toolsLabel) {
+    options.output.dim(`Tools: ${options.toolsLabel}`);
+  }
+  options.output.dim("Commands:");
+  for (const command of listIntroLocalCommands()) {
+    options.output.dim(formatLocalCommandHelpLine(command.id));
+  }
+  options.output.dim("");
+}
+
+// src/shell/cli/output.ts
+function createCliOutputPort() {
+  let lastInterruptAt = 0;
+  return {
+    plain: ui.plain,
+    info: ui.info,
+    warn: ui.warn,
+    error: ui.error,
+    dim: ui.dim,
+    heading: ui.heading,
+    interrupt(message) {
+      const now = Date.now();
+      if (now - lastInterruptAt < 150) {
+        return;
+      }
+      lastInterruptAt = now;
+      writeStdout("\n");
+      ui.warn(message);
+    }
+  };
+}
+
+// src/shell/cli/readlineInput.ts
+import readline from "readline";
+import process2 from "process";
+async function readPersistentInput(promptLabel, onInterrupt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process2.stdin,
+      output: process2.stdout,
+      terminal: true
+    });
+    let settled = false;
+    const cleanup = () => {
+      rl.removeAllListeners("line");
+      rl.removeAllListeners("close");
+      rl.removeAllListeners("SIGINT");
+    };
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      rl.close();
+      resolve(value);
+    };
+    rl.on("line", (line) => {
+      finish(line);
+    });
+    rl.on("SIGINT", () => {
+      onInterrupt();
+      rl.prompt();
+    });
+    rl.on("close", () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve(null);
+    });
+    rl.setPrompt(promptLabel);
+    rl.prompt();
+  });
+}
+function createReadlineInputPort() {
+  const listeners = /* @__PURE__ */ new Set();
+  let releaseProcessInterrupt = null;
+  const notifyInterrupt = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const ensureProcessInterruptBinding = () => {
+    if (releaseProcessInterrupt) {
+      return;
+    }
+    const handler = () => {
+      notifyInterrupt();
+    };
+    process2.on("SIGINT", handler);
+    releaseProcessInterrupt = () => {
+      process2.off("SIGINT", handler);
+      releaseProcessInterrupt = null;
+    };
+  };
+  const maybeReleaseProcessInterruptBinding = () => {
+    if (listeners.size > 0) {
+      return;
+    }
+    releaseProcessInterrupt?.();
+  };
+  return {
+    async readInput(promptLabel = "> ") {
+      const value = await readPersistentInput(promptLabel, notifyInterrupt);
+      return value === null ? { kind: "closed" } : { kind: "submit", value };
+    },
+    bindInterrupt(handler) {
+      listeners.add(handler);
+      ensureProcessInterruptBinding();
+      return () => {
+        listeners.delete(handler);
+        maybeReleaseProcessInterruptBinding();
+      };
+    }
+  };
+}
+
+// src/shell/cli/spinner.ts
+var ASCII_BLOCK_FRAMES = ["[\u25A0   ]", "[ \u25A0  ]", "[  \u25A0 ]", "[   \u25A0]", "[  \u25A0 ]", "[ \u25A0  ]"];
+function createWaitingSpinner(options = {}) {
+  const label = options.label ?? "thinking";
+  const intervalMs = Math.max(40, options.intervalMs ?? 80);
+  const enabled = options.enabled ?? process.stdout.isTTY;
+  const frames = ASCII_BLOCK_FRAMES;
+  const write = options.write ?? ((text) => {
+    writeStdout(text);
+  });
+  let frameIndex = 0;
+  let timer = null;
+  let active = false;
+  let lastLength = 0;
+  const render = () => {
+    const frame = `${frames[frameIndex]} ${label}`;
+    frameIndex = (frameIndex + 1) % frames.length;
+    lastLength = frame.length;
+    write(`\r${colorRuntimeUiText("system", frame)}`);
+  };
+  const clear = () => {
+    if (lastLength <= 0) {
+      return;
+    }
+    write(`\r${" ".repeat(lastLength)}\r`);
+    lastLength = 0;
+  };
+  return {
+    start() {
+      if (!enabled || active) {
+        return;
+      }
+      active = true;
+      render();
+      timer = setInterval(render, intervalMs);
+      timer.unref?.();
+    },
+    stop() {
+      if (!active) {
+        return;
+      }
+      active = false;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      clear();
+    },
+    isActive() {
+      return active;
+    }
+  };
+}
+function wrapCallbacksWithSpinnerStop(callbacks, stopSpinner) {
+  return {
+    onStatus(text) {
+      stopSpinner();
+      callbacks.onStatus?.(text);
+    },
+    onAssistantDelta(delta) {
+      stopSpinner();
+      callbacks.onAssistantDelta?.(delta);
+    },
+    onAssistantStage(text) {
+      stopSpinner();
+      callbacks.onAssistantStage?.(text);
+    },
+    onAssistantDone(fullText) {
+      stopSpinner();
+      callbacks.onAssistantDone?.(fullText);
+    },
+    onAssistantText(text) {
+      stopSpinner();
+      callbacks.onAssistantText?.(text);
+    },
+    onReasoningDelta(delta) {
+      stopSpinner();
+      callbacks.onReasoningDelta?.(delta);
+    },
+    onReasoning(text) {
+      stopSpinner();
+      callbacks.onReasoning?.(text);
+    },
+    onToolCall(name, args) {
+      stopSpinner();
+      callbacks.onToolCall?.(name, args);
+    },
+    onToolResult(name, output) {
+      stopSpinner();
+      callbacks.onToolResult?.(name, output);
+    },
+    onToolError(name, error) {
+      stopSpinner();
+      callbacks.onToolError?.(name, error);
+    }
+  };
+}
+
+// src/shell/cli/turnDisplay.ts
+function createCliTurnDisplay(options) {
+  const runtimeUi = createRuntimeUiAgentCallbacks({
+    channel: "lead",
+    config: options.config,
+    cwd: options.cwd,
+    assistantLeadingBlankLine: true,
+    assistantTrailingNewlines: "\n\n",
+    reasoningLeadingBlankLine: true,
+    toolArgsMaxChars: 200,
+    abortSignal: options.abortSignal
+  });
+  const waitingSpinner = createWaitingSpinner({ label: "thinking" });
+  const callbacks = wrapCallbacksWithSpinnerStop(runtimeUi.callbacks, () => {
+    waitingSpinner.stop();
+  });
+  callbacks.onModelWaitStart = () => {
+    waitingSpinner.start();
+  };
+  callbacks.onModelWaitStop = () => {
+    waitingSpinner.stop();
+  };
+  return {
+    callbacks,
+    flush() {
+      waitingSpinner.stop();
+      runtimeUi.flush();
+    },
+    dispose() {
+      waitingSpinner.stop();
+    }
+  };
+}
+
+// src/shell/cli/shell.ts
+function createReadlineInteractionShell() {
+  return {
+    input: createReadlineInputPort(),
+    output: createCliOutputPort(),
+    createTurnDisplay(options) {
+      return createCliTurnDisplay(options);
+    }
+  };
+}
+function createCliInteractionShell() {
+  return createReadlineInteractionShell();
+}
+
+// src/shell/cli/interactive.ts
+async function startInteractiveChat(options, dependencies = {}) {
+  const shell = resolveInteractiveShell(dependencies);
+  const projectContext = await loadProjectContext(options.cwd, {
+    projectDocMaxBytes: options.config.projectDocMaxBytes
+  });
+  const terminalLogWriter = createTerminalLogWriter(projectContext.stateRootDir, options.session.id);
+  const disposeTerminalOutputMirror = mirrorProcessOutputToTerminalLog(terminalLogWriter);
+  const terminalShell = mirrorInteractionShellToTerminalLog(
+    shell,
+    terminalLogWriter
+  );
+  (dependencies.writeIntro ?? ((context) => {
+    writeCliInteractiveIntro({
+      cwd: context.cwd,
+      session: context.session,
+      output: context.shell.output
+    });
+  }))({
+    cwd: options.cwd,
+    config: options.config,
+    session: options.session,
+    shell: terminalShell
+  });
+  const driver = dependencies.createDriver?.({
+    ...options,
+    shell: terminalShell
+  }) ?? new InteractiveSessionDriver({
+    ...options,
+    shell: terminalShell
+  });
+  try {
+    await driver.run();
+  } finally {
+    disposeTerminalOutputMirror();
+    terminalShell.dispose?.();
+  }
+}
+function resolveInteractiveShell(dependencies) {
+  if (dependencies.shell) {
+    return dependencies.shell;
+  }
+  const createShell = dependencies.createShell ?? createCliInteractionShell;
+  return createShell();
+}
+export {
+  startInteractiveChat
+};

package/dist/oneShot-YHDMPFQM.mjs

@@ -0,0 +1,54 @@
+import {
+  createRuntimeUiAgentCallbacks
+} from "./chunk-YSWK3BGL.mjs";
+import {
+  runHostTurn
+} from "./chunk-ELBEXOR7.mjs";
+import "./chunk-3KMC6H5K.mjs";
+
+// src/cli/oneShot.ts
+async function runOneShotPrompt(prompt, cwd, config, session, sessionStore, options = {}) {
+  void options;
+  const runtimeUi = createRuntimeUiAgentCallbacks({
+    channel: "lead",
+    config,
+    cwd,
+    assistantLeadingBlankLine: false,
+    assistantTrailingNewlines: "\n",
+    reasoningLeadingBlankLine: false,
+    toolArgsMaxChars: 160
+  });
+  const outcome = await runHostTurn({
+    host: "cli",
+    input: prompt,
+    cwd,
+    config,
+    session,
+    sessionStore,
+    callbacks: runtimeUi.callbacks
+  });
+  if (outcome.status === "failed" || outcome.status === "aborted") {
+    runtimeUi.flush();
+  }
+  return {
+    session: outcome.session,
+    closeout: buildOneShotCloseoutReport(
+      outcome.session,
+      outcome.result?.transition ?? null,
+      outcome.status === "failed" || outcome.status === "aborted" ? outcome.errorMessage : void 0
+    )
+  };
+}
+function buildOneShotCloseoutReport(session, terminalTransition, defaultUnfinishedReason) {
+  const completed = terminalTransition?.action === "finalize";
+  return {
+    sessionId: session.id,
+    completed,
+    unfinishedReason: completed ? void 0 : terminalTransition?.reason.code ?? defaultUnfinishedReason ?? "unfinished",
+    terminalTransition
+  };
+}
+export {
+  buildOneShotCloseoutReport,
+  runOneShotPrompt
+};

package/dist/session-XKWJHRVY.mjs

@@ -0,0 +1,66 @@
+import {
+  InProcessSessionStore,
+  SessionStore,
+  createSessionRecord
+} from "./chunk-4BN45TQG.mjs";
+import {
+  applyCurrentTurnFrame,
+  buildChatMessages,
+  collapseContentParts,
+  createEmptySessionDiff,
+  createEmptyTaskState,
+  createInternalReminder,
+  createMessage,
+  createToolMessage,
+  deriveTaskState,
+  expandStartToToolBoundary,
+  findLatestUserIndex,
+  findLatestUserInputIndex,
+  formatTaskStateBlock,
+  isAssistantMessageInLatestTurn,
+  isInternalMessage,
+  modelUsesReasoningContent,
+  normalizeSessionDiff,
+  normalizeSessionDiffState,
+  normalizeSessionRecord,
+  normalizeTaskState,
+  noteSessionDiff,
+  oneLine,
+  readReasoningContent,
+  readUserInput,
+  shouldIncludeStoredAssistantReasoning,
+  sliceCurrentUserInputFrame,
+  toChatMessage
+} from "./chunk-3KMC6H5K.mjs";
+export {
+  InProcessSessionStore,
+  SessionStore,
+  applyCurrentTurnFrame,
+  buildChatMessages,
+  collapseContentParts,
+  createEmptySessionDiff,
+  createEmptyTaskState,
+  createInternalReminder,
+  createMessage,
+  createSessionRecord,
+  createToolMessage,
+  deriveTaskState,
+  expandStartToToolBoundary,
+  findLatestUserIndex,
+  findLatestUserInputIndex,
+  formatTaskStateBlock,
+  isAssistantMessageInLatestTurn,
+  isInternalMessage,
+  modelUsesReasoningContent,
+  normalizeSessionDiff,
+  normalizeSessionDiffState,
+  normalizeSessionRecord,
+  normalizeTaskState,
+  noteSessionDiff,
+  oneLine,
+  readReasoningContent,
+  readUserInput,
+  shouldIncludeStoredAssistantReasoning,
+  sliceCurrentUserInputFrame,
+  toChatMessage
+};