hoomanjs 1.12.0 → 1.13.0

package/src/chat/components/QueuedPrompts.tsx

@@ -0,0 +1,76 @@
+import React from "react";
+import { Box, Text, useStdout } from "ink";
+import type { PromptSubmission } from "./prompt-input/usePromptInputController.ts";
+
+type QueuedPromptsProps = {
+  prompts: readonly { id: string; prompt: PromptSubmission }[];
+};
+
+const MIN_PROMPT_PREVIEW_CHARS = 16;
+const MAX_PROMPT_PREVIEW_CHARS = 120;
+const ELLIPSIS = "...";
+
+function normalizePrompt(prompt: string): string {
+  return prompt.replace(/\s+/g, " ").trim();
+}
+
+function promptPreview(prompt: PromptSubmission): string {
+  const text = normalizePrompt(prompt.text);
+  if (prompt.attachments.length === 0) {
+    return text;
+  }
+  const suffix = `${prompt.attachments.length} attachment${
+    prompt.attachments.length === 1 ? "" : "s"
+  }`;
+  return text ? `${text} (${suffix})` : suffix;
+}
+
+function truncatePrompt(prompt: string, maxChars: number): string {
+  if (prompt.length <= maxChars) {
+    return prompt;
+  }
+  if (maxChars <= ELLIPSIS.length) {
+    return ELLIPSIS.slice(0, maxChars);
+  }
+  return `${prompt.slice(0, maxChars - ELLIPSIS.length)}${ELLIPSIS}`;
+}
+
+export function QueuedPrompts({
+  prompts,
+}: QueuedPromptsProps): React.JSX.Element | null {
+  const { stdout } = useStdout();
+  if (prompts.length === 0) {
+    return null;
+  }
+
+  const columns = stdout?.columns ?? 80;
+  const maxPromptChars = Math.max(
+    MIN_PROMPT_PREVIEW_CHARS,
+    Math.min(MAX_PROMPT_PREVIEW_CHARS, columns - 8),
+  );
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="gray"
+      paddingX={1}
+    >
+      <Text color="gray">
+        queued {prompts.length === 1 ? "prompt" : "prompts"}
+      </Text>
+      {prompts.map((item) => {
+        const preview = truncatePrompt(
+          promptPreview(item.prompt),
+          maxPromptChars,
+        );
+        return (
+          <Text key={item.id} color="gray">
+            {"\u25cb "}
+            {preview}
+          </Text>
+        );
+      })}
+    </Box>
+  );
+}

package/src/chat/components/StatusBar.tsx

@@ -4,6 +4,7 @@ import type { Manager as McpManager } from "../../core/mcp/index.ts";
 type StatusBarProps = {
   running: boolean;
   status: string;
+  statusLabel?: string;
   sessionId: string;
   elapsedLabel: string;
   turnCount: number;
@@ -36,6 +37,7 @@ function statusValueColor(status: string): string {
 export function StatusBar({
   running,
   status,
+  statusLabel,
   sessionId,
   elapsedLabel,
   turnCount,
@@ -48,7 +50,7 @@ export function StatusBar({
     <Box marginTop={1} flexDirection="column">
       <Text>
         <Text color="gray">status: </Text>
-        <Text color={statusValueColor(status)}>{status}</Text>
+        <Text color={statusValueColor(status)}>{statusLabel ?? status}</Text>
         <Text color="gray"> • session: {sessionId}</Text>
       </Text>
       <Text color="gray">

package/src/chat/components/TodoPanel.tsx

@@ -0,0 +1,49 @@
+import { Box, Text } from "ink";
+import type { TodoItem } from "../../core/tools/todo.ts";
+
+type TodoPanelProps = {
+  todos: TodoItem[];
+};
+
+function markerForStatus(status: TodoItem["status"]): string {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[~]";
+    case "pending":
+      return "[ ]";
+  }
+}
+
+export function TodoPanel({ todos }: TodoPanelProps) {
+  if (todos.length === 0) {
+    return null;
+  }
+
+  return (
+    <Box flexDirection="column" marginTop={1}>
+      <Text bold color="cyan">
+        Todos
+      </Text>
+      {todos.map((todo, index) => {
+        const completed = todo.status === "completed";
+        const inProgress = todo.status === "in_progress";
+        const marker = markerForStatus(todo.status);
+        const suffix =
+          inProgress && todo.activeForm.trim().length > 0
+            ? ` — ${todo.activeForm}`
+            : "";
+        return (
+          <Text
+            key={`${index}-${todo.content}`}
+            dimColor={completed}
+            bold={inProgress}
+          >
+            {`${index + 1}. ${marker} ${todo.content}${suffix}`}
+          </Text>
+        );
+      })}
+    </Box>
+  );
+}

package/src/chat/components/prompt-input/clipboard-image.ts

@@ -0,0 +1,119 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { attachmentsPath } from "../../../core/utils/paths.ts";
+
+const execFileAsync = promisify(execFile);
+
+function appleScriptString(value: string): string {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+async function createClipboardImagePath(): Promise<string> {
+  const root = attachmentsPath();
+  await mkdir(root, { recursive: true });
+  return join(root, `${randomUUID()}-clipboard.png`);
+}
+
+async function fileHasContent(path: string): Promise<boolean> {
+  try {
+    const data = await readFile(path);
+    return data.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function saveMacClipboardImage(): Promise<string | null> {
+  const outputPath = await createClipboardImagePath();
+  const outputPathLiteral = appleScriptString(outputPath);
+
+  try {
+    await execFileAsync("osascript", [
+      "-e",
+      "set png_data to (the clipboard as «class PNGf»)",
+      "-e",
+      `set fp to open for access POSIX file ${outputPathLiteral} with write permission`,
+      "-e",
+      "set eof fp to 0",
+      "-e",
+      "write png_data to fp",
+      "-e",
+      "close access fp",
+    ]);
+    return (await fileHasContent(outputPath)) ? outputPath : null;
+  } catch {
+    await unlink(outputPath).catch(() => undefined);
+    return null;
+  }
+}
+
+async function saveLinuxClipboardImage(): Promise<string | null> {
+  const outputPath = await createClipboardImagePath();
+  const candidates: Array<[string, string[]]> = [
+    ["wl-paste", ["--type", "image/png"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/jpeg", "-o"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/webp", "-o"]],
+    ["xsel", ["--clipboard", "--output"]],
+  ];
+
+  for (const [command, args] of candidates) {
+    try {
+      const { stdout } = await execFileAsync(command, args, {
+        encoding: "buffer",
+        maxBuffer: 20 * 1024 * 1024,
+      });
+      if (!Buffer.isBuffer(stdout) || stdout.length === 0) {
+        continue;
+      }
+      await writeFile(outputPath, stdout);
+      return outputPath;
+    } catch {
+      // Try the next clipboard utility.
+    }
+  }
+
+  await unlink(outputPath).catch(() => undefined);
+  return null;
+}
+
+async function saveWindowsClipboardImage(): Promise<string | null> {
+  const outputPath = await createClipboardImagePath();
+  const escapedPath = outputPath.replace(/'/g, "''");
+  const script = [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "Add-Type -AssemblyName System.Drawing",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+    "if ($null -eq $img) { exit 1 }",
+    `$img.Save('${escapedPath}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+  ].join("; ");
+
+  try {
+    await execFileAsync("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      script,
+    ]);
+    return (await fileHasContent(outputPath)) ? outputPath : null;
+  } catch {
+    await unlink(outputPath).catch(() => undefined);
+    return null;
+  }
+}
+
+export async function saveClipboardImageAsAttachment(): Promise<string | null> {
+  switch (process.platform) {
+    case "darwin":
+      return saveMacClipboardImage();
+    case "linux":
+      return saveLinuxClipboardImage();
+    case "win32":
+      return saveWindowsClipboardImage();
+    default:
+      return null;
+  }
+}

package/src/chat/components/prompt-input/input-model.ts

@@ -0,0 +1,294 @@
+export type InputState = {
+  value: string;
+  cursor: number;
+};
+
+const TOKEN_AT_END = /(^|\s)\[(?:paste|attachment) #\d+\]$/;
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+
+const graphemeSegmenter =
+  typeof Intl !== "undefined" && "Segmenter" in Intl
+    ? new Intl.Segmenter(undefined, { granularity: "grapheme" })
+    : null;
+
+export function clampCursor(value: string, cursor: number): number {
+  const n = Number.isFinite(cursor) ? Math.trunc(cursor) : 0;
+  if (n < 0) {
+    return 0;
+  }
+  if (n > value.length) {
+    return value.length;
+  }
+  return n;
+}
+
+function replaceRange(
+  value: string,
+  start: number,
+  end: number,
+  replacement: string,
+): string {
+  return value.slice(0, start) + replacement + value.slice(end);
+}
+
+function deleteRange(
+  state: InputState,
+  start: number,
+  end: number,
+): InputState {
+  const safeStart = clampCursor(state.value, start);
+  const safeEnd = clampCursor(state.value, end);
+  return {
+    value: replaceRange(state.value, safeStart, safeEnd, ""),
+    cursor: safeStart,
+  };
+}
+
+function isWhitespace(char: string): boolean {
+  return /\s/.test(char);
+}
+
+function isWordChar(char: string): boolean {
+  return WORD_CHAR.test(char);
+}
+
+function moveToPrevGrapheme(text: string, at: number): number {
+  const n = clampCursor(text, at);
+  if (n <= 0) {
+    return 0;
+  }
+  if (!graphemeSegmenter) {
+    const cp = text.codePointAt(n - 1) ?? 0;
+    return n - (cp > 0xffff ? 2 : 1);
+  }
+  let last = 0;
+  for (const seg of graphemeSegmenter.segment(text)) {
+    if (seg.index >= n) {
+      break;
+    }
+    last = seg.index;
+  }
+  return last;
+}
+
+function moveToNextGrapheme(text: string, at: number): number {
+  const n = clampCursor(text, at);
+  if (n >= text.length) {
+    return text.length;
+  }
+  if (!graphemeSegmenter) {
+    const cp = text.codePointAt(n) ?? 0;
+    return n + (cp > 0xffff ? 2 : 1);
+  }
+  for (const seg of graphemeSegmenter.segment(text)) {
+    if (seg.index > n) {
+      return seg.index;
+    }
+  }
+  return text.length;
+}
+
+function graphemeLeftOfCursor(text: string, at: number): string {
+  const p = moveToPrevGrapheme(text, at);
+  const n = clampCursor(text, at);
+  return text.slice(p, n);
+}
+
+function graphemeRightOfCursor(text: string, at: number): string {
+  const n = clampCursor(text, at);
+  const x = moveToNextGrapheme(text, n);
+  return text.slice(n, x);
+}
+
+type CharKind = "space" | "word" | "other";
+
+function getCharKind(char: string): CharKind {
+  if (isWhitespace(char)) {
+    return "space";
+  }
+  if (isWordChar(char)) {
+    return "word";
+  }
+  return "other";
+}
+
+export function insertText(state: InputState, text: string): InputState {
+  return {
+    value: replaceRange(state.value, state.cursor, state.cursor, text),
+    cursor: state.cursor + text.length,
+  };
+}
+
+export function moveCursorLeft(state: InputState): InputState {
+  return {
+    ...state,
+    cursor: moveToPrevGrapheme(state.value, state.cursor),
+  };
+}
+
+export function moveCursorRight(state: InputState): InputState {
+  return {
+    ...state,
+    cursor: moveToNextGrapheme(state.value, state.cursor),
+  };
+}
+
+export function moveCursorWordLeft(state: InputState): InputState {
+  let next = state.cursor;
+  while (
+    next > 0 &&
+    getCharKind(graphemeLeftOfCursor(state.value, next)) === "space"
+  ) {
+    next = moveToPrevGrapheme(state.value, next);
+  }
+  if (next === 0) {
+    return { ...state, cursor: 0 };
+  }
+
+  const kind = getCharKind(graphemeLeftOfCursor(state.value, next));
+  while (
+    next > 0 &&
+    getCharKind(graphemeLeftOfCursor(state.value, next)) === kind
+  ) {
+    next = moveToPrevGrapheme(state.value, next);
+  }
+  return { ...state, cursor: next };
+}
+
+export function moveCursorWordRight(state: InputState): InputState {
+  const { value } = state;
+  let next = state.cursor;
+  while (
+    next < value.length &&
+    getCharKind(graphemeRightOfCursor(value, next)) === "space"
+  ) {
+    next = moveToNextGrapheme(value, next);
+  }
+  if (next >= value.length) {
+    return { ...state, cursor: value.length };
+  }
+
+  const kind = getCharKind(graphemeRightOfCursor(value, next));
+  while (
+    next < value.length &&
+    getCharKind(graphemeRightOfCursor(value, next)) === kind
+  ) {
+    next = moveToNextGrapheme(value, next);
+  }
+  return { ...state, cursor: next };
+}
+
+export function findLineStart(value: string, cursor: number): number {
+  const index = value.lastIndexOf("\n", Math.max(0, cursor - 1));
+  return index === -1 ? 0 : index + 1;
+}
+
+export function findLineEnd(value: string, cursor: number): number {
+  const index = value.indexOf("\n", cursor);
+  return index === -1 ? value.length : index;
+}
+
+export function moveCursorLineStart(state: InputState): InputState {
+  return { ...state, cursor: findLineStart(state.value, state.cursor) };
+}
+
+export function moveCursorLineEnd(state: InputState): InputState {
+  return { ...state, cursor: findLineEnd(state.value, state.cursor) };
+}
+
+export function moveCursorUp(
+  state: InputState,
+  targetColumn?: number,
+): { state: InputState; targetColumn: number } {
+  const currentStart = findLineStart(state.value, state.cursor);
+  if (currentStart === 0) {
+    return { state, targetColumn: targetColumn ?? state.cursor };
+  }
+  const previousLineEnd = currentStart - 1;
+  const previousLineStart = findLineStart(state.value, previousLineEnd);
+  const currentColumn = state.cursor - currentStart;
+  const preferred = targetColumn ?? currentColumn;
+  const previousLength = previousLineEnd - previousLineStart;
+  const nextCursor = previousLineStart + Math.min(preferred, previousLength);
+  return { state: { ...state, cursor: nextCursor }, targetColumn: preferred };
+}
+
+export function moveCursorDown(
+  state: InputState,
+  targetColumn?: number,
+): { state: InputState; targetColumn: number } {
+  const currentEnd = findLineEnd(state.value, state.cursor);
+  if (currentEnd >= state.value.length) {
+    const currentStart = findLineStart(state.value, state.cursor);
+    return {
+      state,
+      targetColumn: targetColumn ?? state.cursor - currentStart,
+    };
+  }
+  const nextLineStart = currentEnd + 1;
+  const nextLineEnd = findLineEnd(state.value, nextLineStart);
+  const currentStart = findLineStart(state.value, state.cursor);
+  const currentColumn = state.cursor - currentStart;
+  const preferred = targetColumn ?? currentColumn;
+  const nextLength = nextLineEnd - nextLineStart;
+  const nextCursor = nextLineStart + Math.min(preferred, nextLength);
+  return { state: { ...state, cursor: nextCursor }, targetColumn: preferred };
+}
+
+function findPasteTokenStart(value: string, cursor: number): number | null {
+  if (cursor === 0) {
+    return null;
+  }
+  const charAfter = value[cursor];
+  if (charAfter !== undefined && !isWhitespace(charAfter)) {
+    return null;
+  }
+  const before = value.slice(0, cursor);
+  const match = before.match(TOKEN_AT_END);
+  if (!match || match.index === undefined) {
+    return null;
+  }
+  return match.index + (match[1] ?? "").length;
+}
+
+export function deleteBackward(state: InputState): InputState {
+  if (state.cursor === 0) {
+    return state;
+  }
+
+  const tokenStart = findPasteTokenStart(state.value, state.cursor);
+  if (tokenStart !== null) {
+    return deleteRange(state, tokenStart, state.cursor);
+  }
+
+  const from = moveToPrevGrapheme(state.value, state.cursor);
+  return deleteRange(state, from, state.cursor);
+}
+
+export function deleteForward(state: InputState): InputState {
+  if (state.cursor >= state.value.length) {
+    return state;
+  }
+  const to = moveToNextGrapheme(state.value, state.cursor);
+  return deleteRange(state, state.cursor, to);
+}
+
+export function deleteWordBackward(state: InputState): InputState {
+  const moved = moveCursorWordLeft(state);
+  return deleteRange(state, moved.cursor, state.cursor);
+}
+
+export function deleteWordForward(state: InputState): InputState {
+  const moved = moveCursorWordRight(state);
+  return deleteRange(state, state.cursor, moved.cursor);
+}
+
+export function deleteToLineStart(state: InputState): InputState {
+  const lineStart = findLineStart(state.value, state.cursor);
+  return deleteRange(state, lineStart, state.cursor);
+}
+
+export function deleteToLineEnd(state: InputState): InputState {
+  const lineEnd = findLineEnd(state.value, state.cursor);
+  return deleteRange(state, state.cursor, lineEnd);
+}

package/src/chat/components/prompt-input/paste.ts

@@ -0,0 +1,105 @@
+export const PASTE_THRESHOLD_CHARS = 800;
+export const PASTE_THRESHOLD_LINE_BREAKS = 2;
+
+const ANSI_ESCAPE_PATTERN =
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+const PASTE_REF_PATTERN = /\[paste #(\d+)\]/g;
+const ATTACHMENT_REF_PATTERN = /\[attachment #(\d+)\]/g;
+
+function toPasteId(raw: string | undefined): number | null {
+  if (!raw) {
+    return null;
+  }
+  const id = Number.parseInt(raw, 10);
+  return Number.isFinite(id) && id > 0 ? id : null;
+}
+
+export function normalizePastedText(input: string): string {
+  return input
+    .replace(ANSI_ESCAPE_PATTERN, "")
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .replaceAll("\t", "    ");
+}
+
+export function countLineBreaks(text: string): number {
+  let count = 0;
+  for (const ch of text) {
+    if (ch === "\n") {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+export function formatPasteRef(id: number): string {
+  return `[paste #${id}]`;
+}
+
+export function formatAttachmentRef(id: number): string {
+  return `[attachment #${id}]`;
+}
+
+export function parsePasteRefs(input: string): number[] {
+  const ids: number[] = [];
+  for (const match of input.matchAll(PASTE_REF_PATTERN)) {
+    const id = toPasteId(match[1]);
+    if (id !== null) {
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+
+export function parseAttachmentRefs(input: string): number[] {
+  const ids: number[] = [];
+  for (const match of input.matchAll(ATTACHMENT_REF_PATTERN)) {
+    const id = toPasteId(match[1]);
+    if (id !== null) {
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+
+export function shouldCollapsePaste(
+  text: string,
+  maxChars = PASTE_THRESHOLD_CHARS,
+  maxLineBreaks = PASTE_THRESHOLD_LINE_BREAKS,
+): boolean {
+  return text.length > maxChars || countLineBreaks(text) > maxLineBreaks;
+}
+
+export function expandPasteRefs(
+  input: string,
+  pastedContents: Readonly<Record<number, string>>,
+): string {
+  return input.replace(PASTE_REF_PATTERN, (match, rawId: string) => {
+    const id = toPasteId(rawId);
+    if (id === null) {
+      return match;
+    }
+    return pastedContents[id] ?? match;
+  });
+}
+
+function removeOuterQuotes(text: string): string {
+  return text.replace(/^["']+/, "").replace(/["']+$/, "");
+}
+
+function stripBackslashEscapes(text: string): string {
+  if (process.platform === "win32") {
+    return text;
+  }
+  return text.replace(/\\(.)/g, "$1");
+}
+
+export function parsePastedFilePathCandidates(input: string): string[] {
+  const text = normalizePastedText(input);
+  const parts = text
+    .split(/ (?=\/|~\/|\.{1,2}\/|[A-Za-z]:\\)/)
+    .flatMap((part) => part.split("\n"))
+    .map((part) => stripBackslashEscapes(removeOuterQuotes(part.trim())))
+    .filter(Boolean);
+  return [...new Set(parts)];
+}