hoomanjs 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoomanjs",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Hackable Bun-powered AI agent toolkit for building local CLI, ACP, MCP, and channel-driven workflows.",
   "author": {
     "name": "Vaibhav Pandey",
@@ -61,17 +61,20 @@
     "@mozilla/readability": "^0.6.0",
     "@strands-agents/sdk": "^1.0.0-rc.3",
     "chromadb": "^3.4.3",
+    "cli-highlight": "^2.1.11",
     "cli-spinners": "^3.4.0",
     "commander": "^14.0.3",
     "fastq": "^1.20.1",
     "gray-matter": "^4.0.3",
     "handlebars": "^4.7.9",
     "ink": "^7.0.0",
+    "ink-ansi": "^1.0.0",
     "ink-select-input": "^6.2.0",
     "ink-text-input": "^6.0.0",
     "jsdom": "^29.0.2",
     "lodash": "^4.18.1",
     "luxon": "^3.7.2",
+    "marked": "^18.0.2",
     "ollama": "^0.6.3",
     "openai": "^6.34.0",
     "react": "^19.2.5",

package/src/acp/utils/tool-kind.ts

@@ -14,6 +14,7 @@ const KNOWN_TOOL_KINDS = new Map<string, ToolKind>([
   ["search_files", "search"],
   ["get_file_info", "read"],
   ["shell", "execute"],
+  ["sleep", "other"],
   ["fetch", "fetch"],
   ["wiki_list_files", "read"],
   ["wiki_read_file", "read"],
@@ -22,9 +23,23 @@ const KNOWN_TOOL_KINDS = new Map<string, ToolKind>([
   ["wiki_stats", "read"],
   ["wiki_search", "search"],
   ["think", "think"],
+  ["run_agents", "other"],
   ["update_todos", "other"],
   ["get_current_time", "other"],
   ["convert_time", "other"],
+  ["list_skills", "read"],
+  ["search_skills", "search"],
+  ["install_skill", "edit"],
+  ["delete_skill", "edit"],
+  ["store_memory", "edit"],
+  ["search_memory", "search"],
+  ["update_memory", "edit"],
+  ["archive_memory", "edit"],
+  ["list_mcp_servers", "read"],
+  ["get_mcp_server", "read"],
+  ["add_mcp_server", "edit"],
+  ["update_mcp_server", "edit"],
+  ["delete_mcp_server", "edit"],
 ]);
 
 export { INTERNAL_ALWAYS_ALLOWED };

package/src/chat/app.tsx

@@ -30,7 +30,7 @@ import { Transcript } from "./components/Transcript.tsx";
 import type { ApprovalRequest, ChatLine } from "./types.ts";
 import { getTodoViewState, type TodoViewState } from "../core/tools/todo.ts";
 import { attachmentPathsToPromptBlocks } from "../core/utils/attachments.ts";
-import type { PromptSubmission } from "./components/prompt-input/usePromptInputController.ts";
+import type { PromptSubmission } from "./components/prompt-input/hooks/usePromptInputController.ts";
 
 type ChatAppProps = {
   agent: Agent;

package/src/chat/components/ChatMessage.tsx

@@ -1,6 +1,7 @@
 import { Box, Text } from "ink";
 import type { ChatLine } from "../types.ts";
 import { lineColor } from "./shared.ts";
+import { MarkdownMessage } from "./markdown/MarkdownMessage.tsx";
 import { ReasoningStrip } from "./ReasoningStrip.tsx";
 import { ThinkingStatus } from "./ThinkingStatus.tsx";
 
@@ -17,7 +18,9 @@ export function ChatMessage({ line, liveReasoning = "" }: ChatMessageProps) {
         ? "Assistant"
         : (line.title ?? "System");
   const isPendingAssistant = line.role === "assistant" && !line.done;
-  const text = line.content.trim() || (line.done ? "(empty)" : "");
+  const rawText =
+    line.role === "assistant" ? line.content : line.content.trim();
+  const text = rawText || (line.done ? "(empty)" : "");
   const shouldShowBody = Boolean(text) || !isPendingAssistant;
 
   return (
@@ -32,15 +35,15 @@ export function ChatMessage({ line, liveReasoning = "" }: ChatMessageProps) {
         <ReasoningStrip text={liveReasoning} maxVisibleLines={2} />
       ) : null}
       {shouldShowBody ? (
-        <Text
-          color={
-            line.role === "user" || line.role === "assistant"
-              ? undefined
-              : lineColor(line)
-          }
-        >
-          {text}
-        </Text>
+        line.role === "assistant" ? (
+          <MarkdownMessage streaming={isPendingAssistant}>
+            {text}
+          </MarkdownMessage>
+        ) : (
+          <Text color={line.role === "user" ? undefined : lineColor(line)}>
+            {text}
+          </Text>
+        )
       ) : null}
     </Box>
   );

package/src/chat/components/Composer.tsx

@@ -1,6 +1,6 @@
 import { Box, Text } from "ink";
 import { PromptInput } from "./PromptInput.tsx";
-import type { PromptSubmission } from "./prompt-input/usePromptInputController.ts";
+import type { PromptSubmission } from "./prompt-input/hooks/usePromptInputController.ts";
 
 type ComposerProps = {
   input: string;

package/src/chat/components/PromptInput.tsx

@@ -4,7 +4,7 @@ import { splitLineAtCursor } from "./prompt-input/render.ts";
 import {
   usePromptInputController,
   type PromptSubmission,
-} from "./prompt-input/usePromptInputController.ts";
+} from "./prompt-input/hooks/usePromptInputController.ts";
 
 export type PromptInputProps = {
   value: string;

package/src/chat/components/QueuedPrompts.tsx

@@ -1,6 +1,6 @@
 import React from "react";
 import { Box, Text, useStdout } from "ink";
-import type { PromptSubmission } from "./prompt-input/usePromptInputController.ts";
+import type { PromptSubmission } from "./prompt-input/hooks/usePromptInputController.ts";
 
 type QueuedPromptsProps = {
   prompts: readonly { id: string; prompt: PromptSubmission }[];

package/src/chat/components/markdown/BlockRenderer.tsx

@@ -0,0 +1,207 @@
+import React from "react";
+import { Box, Text, useWindowSize } from "ink";
+import type { Token, Tokens } from "marked";
+import { CodeBlock } from "./CodeBlock.tsx";
+import { inlineToPlainText, renderInlineTokens } from "./InlineRenderer.tsx";
+import { MarkdownTable } from "./MarkdownTable.tsx";
+
+type BlockRendererProps = {
+  tokens: Token[];
+  streaming?: boolean;
+  depth?: number;
+};
+
+function blockToPlainText(token: Token): string {
+  switch (token.type) {
+    case "paragraph":
+      return inlineToPlainText(token.tokens);
+    case "text":
+      return token.text ?? "";
+    case "code":
+      return token.text ?? "";
+    case "heading":
+      return inlineToPlainText(token.tokens);
+    case "blockquote":
+      return (token.tokens ?? [])
+        .map((child) => blockToPlainText(child))
+        .join("\n");
+    case "list":
+      return token.items
+        .map((item: Tokens.ListItem) =>
+          (item.tokens ?? [])
+            .map((child: Token) => blockToPlainText(child))
+            .join(" "),
+        )
+        .join("\n");
+    default:
+      return token.raw ?? "";
+  }
+}
+
+function renderBlock(
+  token: Token,
+  key: string,
+  depth: number,
+  columns: number,
+  streaming: boolean,
+): React.ReactNode | null {
+  switch (token.type) {
+    case "paragraph":
+      return (
+        <Box key={key} marginBottom={1}>
+          <Text wrap="wrap">
+            {renderInlineTokens(token.tokens, { keyPrefix: key })}
+          </Text>
+        </Box>
+      );
+    case "heading": {
+      const headingColor = token.depth <= 2 ? "cyan" : "white";
+      return (
+        <Box key={key} marginBottom={1}>
+          <Text bold color={headingColor} wrap="wrap">
+            {renderInlineTokens(token.tokens, { keyPrefix: key })}
+          </Text>
+        </Box>
+      );
+    }
+    case "code":
+      return (
+        <CodeBlock
+          key={key}
+          code={token.text ?? ""}
+          language={token.lang}
+          streaming={streaming}
+        />
+      );
+    case "blockquote": {
+      const lines = (token.tokens ?? [])
+        .map((child) => blockToPlainText(child))
+        .join("\n")
+        .split("\n");
+      return (
+        <Box key={key} flexDirection="column" marginBottom={1}>
+          {lines.map((line, index) => (
+            <Text key={`${key}-${index}`} color="gray" italic>
+              {`│ ${line || " "}`}
+            </Text>
+          ))}
+        </Box>
+      );
+    }
+    case "list":
+      return (
+        <Box key={key} flexDirection="column" marginBottom={1}>
+          {token.items.map((item: Tokens.ListItem, index: number) => {
+            const marker = token.ordered
+              ? `${(token.start ?? 1) + index}.`
+              : "-";
+            const checkbox =
+              item.task === true ? (item.checked ? "[x] " : "[ ] ") : "";
+            const itemTokens = item.tokens ?? [];
+            const [head, ...tail] = itemTokens as Token[];
+            const isInlineHead =
+              head?.type === "text" || head?.type === "paragraph";
+            const headNode =
+              head && isInlineHead ? (
+                <Text wrap="wrap">
+                  {head.type === "paragraph"
+                    ? renderInlineTokens(head.tokens, {
+                        keyPrefix: `${key}-item-${index}-paragraph`,
+                      })
+                    : (head.text ??
+                      renderInlineTokens(head.tokens, {
+                        keyPrefix: `${key}-item-${index}-text`,
+                      }))}
+                </Text>
+              ) : head ? (
+                renderBlock(
+                  head,
+                  `${key}-item-${index}-head`,
+                  depth + 1,
+                  columns,
+                  streaming,
+                )
+              ) : (
+                <Text> </Text>
+              );
+            return (
+              <Box key={`${key}-item-${index}`} flexDirection="column">
+                <Box flexDirection="row">
+                  <Text>{`${"  ".repeat(depth)}${marker} ${checkbox}`}</Text>
+                  <Box flexDirection="column" flexGrow={1}>
+                    {headNode}
+                  </Box>
+                </Box>
+                {tail.length > 0 ? (
+                  <Box
+                    marginLeft={Math.max(2, depth * 2 + 4)}
+                    flexDirection="column"
+                  >
+                    {tail.map((nestedToken: Token, nestedIndex: number) =>
+                      renderBlock(
+                        nestedToken,
+                        `${key}-item-${index}-tail-${nestedIndex}`,
+                        depth + 1,
+                        columns,
+                        streaming,
+                      ),
+                    )}
+                  </Box>
+                ) : null}
+              </Box>
+            );
+          })}
+        </Box>
+      );
+    case "table":
+      return <MarkdownTable key={key} token={token as Tokens.Table} />;
+    case "hr":
+      return (
+        <Box key={key} marginBottom={1}>
+          <Text color="gray">
+            {"─".repeat(Math.max(8, Math.min(columns - 4, 48)))}
+          </Text>
+        </Box>
+      );
+    case "space":
+      return null;
+    case "text":
+    case "escape":
+      return (
+        <Box key={key} marginBottom={1}>
+          <Text wrap="wrap">{token.text ?? token.raw ?? ""}</Text>
+        </Box>
+      );
+    case "html":
+    case "def":
+    case "del":
+      return null;
+    default:
+      return (
+        <Box key={key} marginBottom={1}>
+          <Text wrap="wrap">{token.raw ?? ""}</Text>
+        </Box>
+      );
+  }
+}
+
+export function BlockRenderer({
+  tokens,
+  streaming = false,
+  depth = 0,
+}: BlockRendererProps) {
+  const { columns } = useWindowSize();
+  return (
+    <Box flexDirection="column">
+      {tokens.map((token, index) =>
+        renderBlock(
+          token,
+          `block-${depth}-${index}`,
+          depth,
+          columns,
+          streaming,
+        ),
+      )}
+    </Box>
+  );
+}

package/src/chat/components/markdown/CodeBlock.tsx

@@ -0,0 +1,100 @@
+import { createRequire } from "node:module";
+import type React from "react";
+import { useMemo } from "react";
+import { Box, Text } from "ink";
+import { highlight, supportsLanguage } from "cli-highlight";
+
+type CodeBlockProps = {
+  code: string;
+  language?: string;
+  streaming?: boolean;
+};
+
+type InkAnsiComponent = React.ComponentType<{
+  children?: React.ReactNode;
+}>;
+
+const localRequire = createRequire(import.meta.url);
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+let cachedInkAnsi: InkAnsiComponent | null | undefined;
+
+function stripAnsi(value: string): string {
+  return value.replace(ANSI_RE, "");
+}
+
+function getInkAnsi(): InkAnsiComponent | null {
+  if (cachedInkAnsi !== undefined) {
+    return cachedInkAnsi;
+  }
+  try {
+    const moduleValue = localRequire("ink-ansi") as
+      | InkAnsiComponent
+      | { default?: InkAnsiComponent };
+    cachedInkAnsi =
+      typeof moduleValue === "function"
+        ? moduleValue
+        : (moduleValue.default ?? null);
+  } catch {
+    cachedInkAnsi = null;
+  }
+  return cachedInkAnsi;
+}
+
+function renderCodeLines(lines: string[], color?: string) {
+  return lines.map((line, index) => (
+    <Text key={index} color={color}>
+      {line || " "}
+    </Text>
+  ));
+}
+
+export function CodeBlock({
+  code,
+  language,
+  streaming = false,
+}: CodeBlockProps) {
+  const trimmedLanguage = language?.trim() || undefined;
+  const normalizedCode = useMemo(() => code.replace(/\r\n/g, "\n"), [code]);
+  const plainLines = useMemo(
+    () => normalizedCode.split("\n"),
+    [normalizedCode],
+  );
+  const highlightedLines = useMemo(() => {
+    if (streaming || !trimmedLanguage || !supportsLanguage(trimmedLanguage)) {
+      return null;
+    }
+    try {
+      return highlight(normalizedCode, {
+        language: trimmedLanguage,
+        ignoreIllegals: true,
+      }).split("\n");
+    } catch {
+      return null;
+    }
+  }, [normalizedCode, streaming, trimmedLanguage]);
+
+  if (highlightedLines) {
+    const InkAnsiText = getInkAnsi();
+    return (
+      <Box flexDirection="column" marginBottom={1}>
+        <Text color="gray">{`\`\`\`${trimmedLanguage}`}</Text>
+        {highlightedLines.map((line, index) =>
+          InkAnsiText ? (
+            <InkAnsiText key={index}>{line || " "}</InkAnsiText>
+          ) : (
+            <Text key={index}>{stripAnsi(line) || " "}</Text>
+          ),
+        )}
+        <Text color="gray">```</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      <Text color="gray">{`\`\`\`${trimmedLanguage ?? ""}`}</Text>
+      {renderCodeLines(plainLines, "white")}
+      <Text color="gray">```</Text>
+    </Box>
+  );
+}

package/src/chat/components/markdown/InlineRenderer.tsx

@@ -0,0 +1,122 @@
+import React from "react";
+import { Text } from "ink";
+import type { Token } from "marked";
+
+function plainFromToken(token: Token): string {
+  switch (token.type) {
+    case "text":
+      return token.text ?? "";
+    case "codespan":
+      return token.text ?? "";
+    case "escape":
+      return token.text ?? "";
+    case "link": {
+      const label = inlineToPlainText(token.tokens);
+      return label || token.href || "";
+    }
+    case "strong":
+    case "em":
+    case "del":
+      return inlineToPlainText(token.tokens);
+    case "image":
+      return token.text || token.href || "";
+    case "br":
+      return "\n";
+    default:
+      return token.raw ?? "";
+  }
+}
+
+export function inlineToPlainText(tokens: Token[] | undefined): string {
+  if (!tokens || tokens.length === 0) {
+    return "";
+  }
+  return tokens.map((token) => plainFromToken(token)).join("");
+}
+
+type RenderInlineOptions = {
+  keyPrefix?: string;
+};
+
+export function renderInlineTokens(
+  tokens: Token[] | undefined,
+  options: RenderInlineOptions = {},
+): React.ReactNode[] {
+  if (!tokens || tokens.length === 0) {
+    return [];
+  }
+  const prefix = options.keyPrefix ?? "inline";
+  return tokens.flatMap((token, index) => {
+    const key = `${prefix}-${index}`;
+    switch (token.type) {
+      case "text":
+        return [token.text ?? ""];
+      case "escape":
+        return [token.text ?? token.raw ?? ""];
+      case "codespan":
+        return [
+          <Text key={key} color="green">
+            {token.text ?? ""}
+          </Text>,
+        ];
+      case "strong":
+        return [
+          <Text key={key} bold>
+            {renderInlineTokens(token.tokens, { keyPrefix: key })}
+          </Text>,
+        ];
+      case "em":
+        return [
+          <Text key={key} italic>
+            {renderInlineTokens(token.tokens, { keyPrefix: key })}
+          </Text>,
+        ];
+      case "del":
+        return [
+          <Text key={key} dimColor>
+            {renderInlineTokens(token.tokens, { keyPrefix: key })}
+          </Text>,
+        ];
+      case "link": {
+        const href = token.href ?? "";
+        const text = inlineToPlainText(token.tokens).trim();
+        const label = text || href;
+        const shouldShowHref = Boolean(href) && label !== href;
+        return [
+          <Text key={`${key}-label`} color="blue" underline>
+            {label}
+          </Text>,
+          ...(shouldShowHref
+            ? [
+                <Text key={`${key}-href`} color="gray">
+                  {` (${href})`}
+                </Text>,
+              ]
+            : []),
+        ];
+      }
+      case "image": {
+        const label = token.text?.trim() || "image";
+        const href = token.href ?? "";
+        return [
+          <Text key={`${key}-img-label`} color="magenta">
+            {`[${label}]`}
+          </Text>,
+          ...(href
+            ? [
+                <Text key={`${key}-img-href`} color="gray">
+                  {` (${href})`}
+                </Text>,
+              ]
+            : []),
+        ];
+      }
+      case "br":
+        return [<Text key={key}>{"\n"}</Text>];
+      default: {
+        const fallback = plainFromToken(token);
+        return fallback ? [fallback] : [];
+      }
+    }
+  });
+}

package/src/chat/components/markdown/MarkdownMessage.tsx

@@ -0,0 +1,35 @@
+import { Box } from "ink";
+import { BlockRenderer } from "./BlockRenderer.tsx";
+import { useMarkdownTokens } from "./hooks/useMarkdownTokens.ts";
+
+type MarkdownMessageProps = {
+  children: string;
+  streaming?: boolean;
+};
+
+export function MarkdownMessage({
+  children,
+  streaming = false,
+}: MarkdownMessageProps) {
+  const content = children ?? "";
+  const {
+    fullTokens,
+    stablePrefix,
+    unstableSuffix,
+    stableTokens,
+    unstableTokens,
+  } = useMarkdownTokens(content, streaming);
+
+  if (!streaming) {
+    return <BlockRenderer tokens={fullTokens} />;
+  }
+
+  return (
+    <Box flexDirection="column">
+      {stablePrefix ? <BlockRenderer tokens={stableTokens} /> : null}
+      {unstableSuffix ? (
+        <BlockRenderer tokens={unstableTokens} streaming />
+      ) : null}
+    </Box>
+  );
+}

package/src/chat/components/markdown/MarkdownTable.tsx

@@ -0,0 +1,23 @@
+import { Box, Text, useWindowSize } from "ink";
+import type { Tokens } from "marked";
+import { useMarkdownTableLayout } from "./hooks/useMarkdownTableLayout.ts";
+
+type MarkdownTableProps = {
+  token: Tokens.Table;
+};
+
+export function MarkdownTable({ token }: MarkdownTableProps) {
+  const { columns } = useWindowSize();
+  const layout = useMarkdownTableLayout(token, columns);
+  if (layout.lines.length === 0) {
+    return null;
+  }
+
+  return (
+    <Box flexDirection="column" marginBottom={1}>
+      {layout.lines.map((line, index) => (
+        <Text key={index}>{line}</Text>
+      ))}
+    </Box>
+  );
+}