hoomanjs 1.18.0 → 1.18.1

package/src/chat/components/markdown/hooks/useMarkdownTableLayout.ts

@@ -1,242 +0,0 @@
-import { useMemo } from "react";
-import type { Token, Tokens } from "marked";
-import { inlineToPlainText } from "../InlineRenderer.tsx";
-
-const MIN_COLUMN_WIDTH = 3;
-const MAX_ROW_LINES = 4;
-const SAFETY_MARGIN = 4;
-
-type TableLayout = {
-  mode: "horizontal" | "vertical";
-  lines: string[];
-};
-
-function displayWidth(value: string): number {
-  return Array.from(value).length;
-}
-
-function longestWordWidth(value: string): number {
-  const words = value.split(/\s+/).filter(Boolean);
-  if (words.length === 0) {
-    return MIN_COLUMN_WIDTH;
-  }
-  return Math.max(...words.map((word) => displayWidth(word)), MIN_COLUMN_WIDTH);
-}
-
-function wrapText(value: string, width: number): string[] {
-  if (width <= 0) {
-    return [value];
-  }
-  const normalized = value.replace(/\r\n/g, "\n").trimEnd();
-  const sourceLines = normalized.length > 0 ? normalized.split("\n") : [""];
-  const wrapped = sourceLines.flatMap((line) => {
-    const words = line.split(/\s+/).filter(Boolean);
-    if (words.length === 0) {
-      return [""];
-    }
-    const output: string[] = [];
-    let current = "";
-    for (const word of words) {
-      const candidate = current ? `${current} ${word}` : word;
-      if (displayWidth(candidate) <= width) {
-        current = candidate;
-        continue;
-      }
-      if (current) {
-        output.push(current);
-      }
-      if (displayWidth(word) <= width) {
-        current = word;
-        continue;
-      }
-      let remaining = word;
-      while (displayWidth(remaining) > width) {
-        output.push(Array.from(remaining).slice(0, width).join(""));
-        remaining = Array.from(remaining).slice(width).join("");
-      }
-      current = remaining;
-    }
-    if (current) {
-      output.push(current);
-    }
-    return output.length > 0 ? output : [""];
-  });
-  return wrapped.length > 0 ? wrapped : [""];
-}
-
-function padAligned(
-  value: string,
-  width: number,
-  align: "left" | "center" | "right" | null | undefined,
-): string {
-  const padding = Math.max(0, width - displayWidth(value));
-  if (align === "center") {
-    const leftPad = Math.floor(padding / 2);
-    return `${" ".repeat(leftPad)}${value}${" ".repeat(padding - leftPad)}`;
-  }
-  if (align === "right") {
-    return `${" ".repeat(padding)}${value}`;
-  }
-  return `${value}${" ".repeat(padding)}`;
-}
-
-function rowToCells(row: Array<{ tokens?: Token[] }>): string[] {
-  return row.map((cell) => inlineToPlainText(cell.tokens).trim());
-}
-
-function getVerticalLayout(
-  header: string[],
-  rows: string[][],
-  terminalWidth: number,
-): TableLayout {
-  const lines: string[] = [];
-  const separator = "─".repeat(Math.min(Math.max(terminalWidth - 1, 10), 40));
-  rows.forEach((row, rowIndex) => {
-    if (rowIndex > 0) {
-      lines.push(separator);
-    }
-    row.forEach((cell, columnIndex) => {
-      const label = header[columnIndex] || `Column ${columnIndex + 1}`;
-      const compact = cell.replace(/\s+/g, " ").trim();
-      const wrapped = wrapText(
-        compact,
-        Math.max(10, terminalWidth - displayWidth(label) - 3),
-      );
-      lines.push(`${label}: ${wrapped[0] ?? ""}`);
-      for (let index = 1; index < wrapped.length; index += 1) {
-        lines.push(`  ${wrapped[index]}`);
-      }
-    });
-  });
-  return { mode: "vertical", lines };
-}
-
-export function useMarkdownTableLayout(
-  token: Tokens.Table,
-  terminalWidth: number,
-): TableLayout {
-  return useMemo(() => {
-    const header = rowToCells(token.header);
-    const rows = token.rows.map((row) => rowToCells(row));
-    const columnCount = header.length;
-    if (columnCount === 0) {
-      return { mode: "horizontal", lines: [] };
-    }
-
-    const minWidths = header.map((_, columnIndex) => {
-      let max = longestWordWidth(header[columnIndex] ?? "");
-      for (const row of rows) {
-        max = Math.max(max, longestWordWidth(row[columnIndex] ?? ""));
-      }
-      return max;
-    });
-    const idealWidths = header.map((_, columnIndex) => {
-      let max = Math.max(
-        displayWidth(header[columnIndex] ?? ""),
-        MIN_COLUMN_WIDTH,
-      );
-      for (const row of rows) {
-        max = Math.max(max, displayWidth(row[columnIndex] ?? ""));
-      }
-      return max;
-    });
-
-    const borderOverhead = 1 + columnCount * 3;
-    const availableWidth = Math.max(
-      terminalWidth - borderOverhead - SAFETY_MARGIN,
-      columnCount * MIN_COLUMN_WIDTH,
-    );
-    const totalMin = minWidths.reduce((sum, width) => sum + width, 0);
-    const totalIdeal = idealWidths.reduce((sum, width) => sum + width, 0);
-
-    let columnWidths: number[];
-    if (totalIdeal <= availableWidth) {
-      columnWidths = idealWidths;
-    } else if (totalMin <= availableWidth) {
-      const remaining = availableWidth - totalMin;
-      const overflows = idealWidths.map(
-        (ideal, index) => ideal - minWidths[index]!,
-      );
-      const totalOverflow = overflows.reduce(
-        (sum, overflow) => sum + overflow,
-        0,
-      );
-      columnWidths = minWidths.map((minWidth, index) => {
-        if (totalOverflow === 0) {
-          return minWidth;
-        }
-        const extra = Math.floor(
-          (overflows[index]! / totalOverflow) * remaining,
-        );
-        return minWidth + extra;
-      });
-    } else {
-      const ratio = availableWidth / totalMin;
-      columnWidths = minWidths.map((width) =>
-        Math.max(Math.floor(width * ratio), MIN_COLUMN_WIDTH),
-      );
-    }
-
-    const maxRowLines = [header, ...rows]
-      .map((row) =>
-        row.reduce((max, cell, index) => {
-          const wrapped = wrapText(cell, columnWidths[index]!);
-          return Math.max(max, wrapped.length);
-        }, 1),
-      )
-      .reduce((max, count) => Math.max(max, count), 1);
-
-    if (maxRowLines > MAX_ROW_LINES) {
-      return getVerticalLayout(header, rows, terminalWidth);
-    }
-
-    function border(type: "top" | "middle" | "bottom"): string {
-      const chars = {
-        top: ["┌", "─", "┬", "┐"],
-        middle: ["├", "─", "┼", "┤"],
-        bottom: ["└", "─", "┴", "┘"],
-      }[type] as [string, string, string, string];
-      const [left, line, cross, right] = chars;
-      return `${left}${columnWidths
-        .map((width) => line.repeat(width + 2))
-        .join(cross)}${right}`;
-    }
-
-    function renderRow(
-      row: string[],
-      isHeader: boolean,
-      align: Array<"left" | "center" | "right" | null | undefined>,
-    ): string[] {
-      const cells = row.map((cell, index) =>
-        wrapText(cell, columnWidths[index]!),
-      );
-      const lineCount = Math.max(...cells.map((lines) => lines.length), 1);
-      const output: string[] = [];
-      for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
-        let line = "│";
-        for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
-          const value = cells[columnIndex]?.[lineIndex] ?? "";
-          const cellAlign = isHeader ? "center" : align[columnIndex];
-          line += ` ${padAligned(value, columnWidths[columnIndex]!, cellAlign)} │`;
-        }
-        output.push(line);
-      }
-      return output;
-    }
-
-    const alignments = token.align ?? [];
-    const lines: string[] = [
-      border("top"),
-      ...renderRow(header, true, alignments),
-      border("middle"),
-    ];
-    rows.forEach((row, rowIndex) => {
-      lines.push(...renderRow(row, false, alignments));
-      if (rowIndex < rows.length - 1) {
-        lines.push(border("middle"));
-      }
-    });
-    lines.push(border("bottom"));
-    return { mode: "horizontal", lines };
-  }, [terminalWidth, token]);
-}

package/src/chat/components/markdown/hooks/useMarkdownTokens.ts

@@ -1,46 +0,0 @@
-import { useMemo, useRef } from "react";
-import { type Token } from "marked";
-import { lexMarkdown, splitStreamingMarkdown } from "../lexer.ts";
-
-export type MarkdownTokenPlan = {
-  fullTokens: Token[];
-  stablePrefix: string;
-  unstableSuffix: string;
-  stableTokens: Token[];
-  unstableTokens: Token[];
-};
-
-export function useMarkdownTokens(
-  content: string,
-  streaming: boolean,
-): MarkdownTokenPlan {
-  const stablePrefixRef = useRef("");
-  const fullTokens = useMemo(() => lexMarkdown(content), [content]);
-
-  const streamSegments = streaming
-    ? splitStreamingMarkdown(content, stablePrefixRef.current)
-    : { stablePrefix: "", unstableSuffix: "" };
-
-  const stableTokens = useMemo(
-    () => lexMarkdown(streamSegments.stablePrefix),
-    [streamSegments.stablePrefix],
-  );
-  const unstableTokens = useMemo(
-    () => lexMarkdown(streamSegments.unstableSuffix),
-    [streamSegments.unstableSuffix],
-  );
-
-  if (!streaming) {
-    stablePrefixRef.current = "";
-  } else {
-    stablePrefixRef.current = streamSegments.stablePrefix;
-  }
-
-  return {
-    fullTokens,
-    stablePrefix: streamSegments.stablePrefix,
-    unstableSuffix: streamSegments.unstableSuffix,
-    stableTokens,
-    unstableTokens,
-  };
-}

package/src/chat/components/markdown/lexer.ts

@@ -1,100 +0,0 @@
-import { marked, type Token } from "marked";
-
-const TOKEN_CACHE_MAX = 500;
-const tokenCache = new Map<string, Token[]>();
-let markedConfigured = false;
-
-const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
-
-function hashContent(input: string): string {
-  let hash = 5381;
-  for (let index = 0; index < input.length; index += 1) {
-    hash = (hash * 33) ^ input.charCodeAt(index);
-  }
-  return (hash >>> 0).toString(36);
-}
-
-function hasMarkdownSyntax(value: string): boolean {
-  const sample = value.length > 500 ? value.slice(0, 500) : value;
-  return MD_SYNTAX_RE.test(sample);
-}
-
-function paragraphToken(value: string): Token[] {
-  return [
-    {
-      type: "paragraph",
-      raw: value,
-      text: value,
-      tokens: [
-        {
-          type: "text",
-          raw: value,
-          text: value,
-        },
-      ],
-    } as Token,
-  ];
-}
-
-function lexer(content: string): Token[] {
-  configureMarked();
-  if (!hasMarkdownSyntax(content)) {
-    return paragraphToken(content);
-  }
-  return marked.lexer(content);
-}
-
-export function configureMarked(): void {
-  if (markedConfigured) {
-    return;
-  }
-  markedConfigured = true;
-  marked.use({ gfm: true, breaks: false });
-}
-
-export function lexMarkdown(content: string): Token[] {
-  const key = hashContent(content);
-  const hit = tokenCache.get(key);
-  if (hit) {
-    tokenCache.delete(key);
-    tokenCache.set(key, hit);
-    return hit;
-  }
-  const tokens = lexer(content);
-  if (tokenCache.size >= TOKEN_CACHE_MAX) {
-    const oldest = tokenCache.keys().next().value;
-    if (oldest !== undefined) {
-      tokenCache.delete(oldest);
-    }
-  }
-  tokenCache.set(key, tokens);
-  return tokens;
-}
-
-export function splitStreamingMarkdown(
-  content: string,
-  stablePrefix: string,
-): { stablePrefix: string; unstableSuffix: string } {
-  configureMarked();
-  let currentStablePrefix = stablePrefix;
-  if (!content.startsWith(currentStablePrefix)) {
-    currentStablePrefix = "";
-  }
-  const boundary = currentStablePrefix.length;
-  const tokens = lexer(content.slice(boundary));
-  let lastContentIndex = tokens.length - 1;
-  while (lastContentIndex >= 0 && tokens[lastContentIndex]?.type === "space") {
-    lastContentIndex -= 1;
-  }
-  let advance = 0;
-  for (let index = 0; index < lastContentIndex; index += 1) {
-    advance += tokens[index]?.raw.length ?? 0;
-  }
-  if (advance > 0) {
-    currentStablePrefix = content.slice(0, boundary + advance);
-  }
-  return {
-    stablePrefix: currentStablePrefix,
-    unstableSuffix: content.slice(currentStablePrefix.length),
-  };
-}

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

@@ -1,119 +0,0 @@
-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/hooks/usePromptInputController.ts

@@ -1,4 +0,0 @@
-export {
-  usePromptInputController,
-  type PromptSubmission,
-} from "../usePromptInputController.ts";