hoomanjs 1.18.0 → 1.18.1

package/src/chat/approvals.ts

@@ -1,97 +0,0 @@
-import { BeforeToolCallEvent } from "@strands-agents/sdk";
-import {
-  INTERNAL_ALWAYS_ALLOWED,
-  allowToolForSession,
-  isToolSessionAllowed,
-} from "../core/state/tool-approvals.ts";
-import type { ApprovalDecision, ApprovalRequest } from "./types.ts";
-const INPUT_PREVIEW_LIMIT = 256;
-
-function previewInput(input: unknown): string {
-  try {
-    const text = JSON.stringify(input, null, 2) ?? "null";
-    return text.length > INPUT_PREVIEW_LIMIT
-      ? `${text.slice(0, INPUT_PREVIEW_LIMIT)}\n... (truncated)`
-      : text;
-  } catch {
-    return String(input);
-  }
-}
-
-type QueueItem = {
-  request: ApprovalRequest;
-  resolve: (decision: ApprovalDecision) => void;
-};
-
-export class ChatApprovalController {
-  private readonly queue: QueueItem[] = [];
-  private readonly listeners = new Set<() => void>();
-  private nextId = 0;
-
-  public subscribe(listener: () => void): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  public get pending(): ApprovalRequest | null {
-    return this.queue[0]?.request ?? null;
-  }
-
-  public request(event: BeforeToolCallEvent): Promise<ApprovalDecision> {
-    const request: ApprovalRequest = {
-      id: String(this.nextId++),
-      toolName: event.toolUse.name,
-      description: event.tool?.description?.trim(),
-      inputPreview: previewInput(event.toolUse.input),
-    };
-    return new Promise<ApprovalDecision>((resolve) => {
-      this.queue.push({ request, resolve });
-      this.emit();
-    });
-  }
-
-  public decide(decision: ApprovalDecision): void {
-    const item = this.queue.shift();
-    if (!item) {
-      return;
-    }
-    item.resolve(decision);
-    this.emit();
-  }
-
-  private emit(): void {
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-}
-
-export function createChatApprovalHandler(
-  controller: ChatApprovalController,
-  options?: { yolo?: boolean },
-): (event: BeforeToolCallEvent) => Promise<void> {
-  return async (event: BeforeToolCallEvent) => {
-    const toolName = event.toolUse.name;
-    if (options?.yolo) {
-      return;
-    }
-    if (
-      INTERNAL_ALWAYS_ALLOWED.has(toolName) ||
-      isToolSessionAllowed(event.agent, toolName)
-    ) {
-      return;
-    }
-
-    const decision = await controller.request(event);
-    if (decision === "allow") {
-      return;
-    }
-    if (decision === "always") {
-      allowToolForSession(event.agent, toolName);
-      return;
-    }
-    event.cancel = `Tool "${toolName}" was rejected by the user.`;
-  };
-}

package/src/chat/components/ApprovalPrompt.tsx

@@ -1,25 +0,0 @@
-import { Box, Text } from "ink";
-import SelectInput from "ink-select-input";
-import type { ApprovalDecision } from "../types.ts";
-
-type ApprovalPromptProps = {
-  onDecision: (decision: ApprovalDecision) => void;
-};
-
-export function ApprovalPrompt({ onDecision }: ApprovalPromptProps) {
-  return (
-    <Box flexDirection="column">
-      <SelectInput<ApprovalDecision>
-        items={[
-          { label: "Allow", value: "allow" },
-          { label: "Always", value: "always" },
-          { label: "Deny", value: "reject" },
-        ]}
-        onSelect={(item) => onDecision(item.value)}
-      />
-      <Box marginTop={1}>
-        <Text color="gray">up/down - choose - enter select</Text>
-      </Box>
-    </Box>
-  );
-}

package/src/chat/components/ChatMessage.tsx

@@ -1,50 +0,0 @@
-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";
-
-type ChatMessageProps = {
-  line: ChatLine;
-  liveReasoning?: string;
-};
-
-export function ChatMessage({ line, liveReasoning = "" }: ChatMessageProps) {
-  const roleName =
-    line.role === "user"
-      ? "You"
-      : line.role === "assistant"
-        ? "Assistant"
-        : (line.title ?? "System");
-  const isPendingAssistant = line.role === "assistant" && !line.done;
-  const rawText =
-    line.role === "assistant" ? line.content : line.content.trim();
-  const text = rawText || (line.done ? "(empty)" : "");
-  const shouldShowBody = Boolean(text) || !isPendingAssistant;
-
-  return (
-    <Box flexDirection="column" marginBottom={1}>
-      <Box flexDirection="row">
-        <Text bold color={lineColor(line)}>
-          {roleName}
-        </Text>
-        {isPendingAssistant ? <ThinkingStatus /> : null}
-      </Box>
-      {isPendingAssistant && liveReasoning ? (
-        <ReasoningStrip text={liveReasoning} maxVisibleLines={2} />
-      ) : null}
-      {shouldShowBody ? (
-        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,45 +0,0 @@
-import { Box, Text } from "ink";
-import { PromptInput } from "./PromptInput.tsx";
-import type { PromptSubmission } from "./prompt-input/hooks/usePromptInputController.ts";
-
-type ComposerProps = {
-  input: string;
-  running: boolean;
-  disabled: boolean;
-  hint: string;
-  onChange: (value: string) => void;
-  onSubmit: (value: PromptSubmission) => void;
-};
-
-export function Composer({
-  input,
-  running,
-  disabled,
-  hint,
-  onChange,
-  onSubmit,
-}: ComposerProps) {
-  return (
-    <>
-      <Box borderStyle="round" borderColor="gray" paddingX={1}>
-        <Text color="gray">{"> "}</Text>
-        <PromptInput
-          value={input}
-          onChange={onChange}
-          onSubmit={onSubmit}
-          placeholder={
-            running
-              ? "Type a message (queued after current turn)"
-              : "Type a message"
-          }
-          focus={!disabled}
-          maxVisibleLines={4}
-        />
-      </Box>
-
-      <Box>
-        <Text color="gray">{hint}</Text>
-      </Box>
-    </>
-  );
-}

package/src/chat/components/EmptyChatBanner.tsx

@@ -1,26 +0,0 @@
-import React from "react";
-import { Box, Text, useWindowSize } from "ink";
-import { ASCII_ART } from "./ascii-logo.ts";
-
-export function EmptyChatBanner(): React.JSX.Element {
-  const { columns } = useWindowSize();
-
-  return (
-    <Box flexDirection="column" width={columns}>
-      <Box
-        width={columns}
-        flexDirection="row"
-        justifyContent="center"
-        paddingY={2}
-      >
-        <Box flexDirection="column">
-          {ASCII_ART.map((line, i) => (
-            <Text key={i} color="cyan" bold>
-              {line}
-            </Text>
-          ))}
-        </Box>
-      </Box>
-    </Box>
-  );
-}

package/src/chat/components/PromptInput.tsx

@@ -1,62 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import { splitLineAtCursor } from "./prompt-input/render.ts";
-import {
-  usePromptInputController,
-  type PromptSubmission,
-} from "./prompt-input/hooks/usePromptInputController.ts";
-
-export type PromptInputProps = {
-  value: string;
-  onChange: (value: string) => void;
-  onSubmit: (value: PromptSubmission) => void;
-  placeholder?: string;
-  focus?: boolean;
-  maxVisibleLines?: number;
-};
-
-export function PromptInput({
-  value,
-  onChange,
-  onSubmit,
-  placeholder = "",
-  focus = true,
-  maxVisibleLines = 4,
-}: PromptInputProps): React.JSX.Element {
-  const { view } = usePromptInputController({
-    value,
-    onChange,
-    onSubmit,
-    focus,
-    maxVisibleLines,
-  });
-
-  if (view.showPlaceholder) {
-    return (
-      <Text>
-        {focus ? <Text inverse> </Text> : null}
-        {placeholder ? <Text color="gray">{placeholder}</Text> : null}
-      </Text>
-    );
-  }
-
-  return (
-    <Box flexDirection="column">
-      {view.visibleLines.map((line, index) => {
-        const isCursorLine = focus && index === view.cursorLineInView;
-        if (!isCursorLine) {
-          return <Text key={`${view.lineOffset + index}`}>{line}</Text>;
-        }
-        const safeColumn = Math.min(Math.max(0, view.cursorCol), line.length);
-        const parts = splitLineAtCursor(line, safeColumn);
-        return (
-          <Text key={`${view.lineOffset + index}`}>
-            {parts.left}
-            <Text inverse>{parts.at}</Text>
-            {parts.right}
-          </Text>
-        );
-      })}
-    </Box>
-  );
-}

package/src/chat/components/QueuedPrompts.tsx

@@ -1,76 +0,0 @@
-import React from "react";
-import { Box, Text, useStdout } from "ink";
-import type { PromptSubmission } from "./prompt-input/hooks/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/ReasoningStrip.tsx

@@ -1,30 +0,0 @@
-import { Box, Text, useWindowSize } from "ink";
-import { wrapTextToLines } from "./shared.ts";
-
-type ReasoningStripProps = {
-  text: string;
-  maxVisibleLines?: number;
-};
-
-export function ReasoningStrip({
-  text,
-  maxVisibleLines = 2,
-}: ReasoningStripProps) {
-  const { columns } = useWindowSize();
-  const wrapped = wrapTextToLines(text, Math.max(20, columns - 6));
-  const visibleLines = wrapped.slice(-maxVisibleLines);
-
-  if (visibleLines.length === 0) {
-    return null;
-  }
-
-  return (
-    <Box flexDirection="column">
-      {visibleLines.map((line, index) => (
-        <Text key={index} color="gray" wrap="wrap">
-          {line || " "}
-        </Text>
-      ))}
-    </Box>
-  );
-}

package/src/chat/components/Spinner.tsx

@@ -1,34 +0,0 @@
-import { useEffect, useState } from "react";
-import { Text } from "ink";
-import cliSpinners, { type SpinnerName } from "cli-spinners";
-
-type SpinnerProps = {
-  type?: SpinnerName;
-  color?: string;
-  bold?: boolean;
-};
-
-export function Spinner({
-  type = "star",
-  color = "cyan",
-  bold = true,
-}: SpinnerProps) {
-  const spinner = cliSpinners[type] || cliSpinners.dots;
-  const { frames, interval } = spinner;
-  const [index, setIndex] = useState(0);
-
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setIndex((value) => (value + 1) % frames.length);
-    }, interval);
-    return () => {
-      clearInterval(timer);
-    };
-  }, [frames.length, interval]);
-
-  return (
-    <Text color={color} bold={bold}>
-      {frames[index]}
-    </Text>
-  );
-}

package/src/chat/components/StatusBar.tsx

@@ -1,67 +0,0 @@
-import { Box, Text } from "ink";
-import type { Manager as McpManager } from "../../core/mcp/index.ts";
-
-type StatusBarProps = {
-  running: boolean;
-  status: string;
-  statusLabel?: string;
-  sessionId: string;
-  elapsedLabel: string;
-  turnCount: number;
-  totalTools: number;
-  skillsFound: number;
-  manager: McpManager;
-  usage: {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-    latencyMs: number;
-  };
-};
-
-/** Ink color for the live status token only (labels stay `gray`). */
-function statusValueColor(status: string): string {
-  switch (status) {
-    case "ready":
-      return "green";
-    case "thinking":
-    case "streaming":
-    case "running tool":
-    case "cancel requested":
-      return "yellow";
-    default:
-      return "gray";
-  }
-}
-
-export function StatusBar({
-  running,
-  status,
-  statusLabel,
-  sessionId,
-  elapsedLabel,
-  turnCount,
-  totalTools,
-  skillsFound,
-  manager,
-  usage,
-}: StatusBarProps) {
-  return (
-    <Box marginTop={1} flexDirection="column">
-      <Text>
-        <Text color="gray">status: </Text>
-        <Text color={statusValueColor(status)}>{statusLabel ?? status}</Text>
-        <Text color="gray"> • session: {sessionId}</Text>
-      </Text>
-      <Text color="gray">
-        turns: {turnCount} • tokens in/out/total: {usage.inputTokens}/
-        {usage.outputTokens}/{usage.totalTokens}
-        {usage.latencyMs > 0 ? ` • latency: ${usage.latencyMs}ms` : ""}
-        {running ? <Text color="gray"> • elapsed {elapsedLabel}</Text> : null}
-      </Text>
-      <Text color="gray">
-        {`mcp servers: ${manager.clients.size} • tools: ${totalTools} • skills: ${skillsFound}`}
-      </Text>
-    </Box>
-  );
-}

package/src/chat/components/ThinkingStatus.tsx

@@ -1,128 +0,0 @@
-import { useEffect, useState } from "react";
-import { Box, Text } from "ink";
-import { Spinner } from "./Spinner.tsx";
-
-const THINKING_VERBS = [
-  "is thinking",
-  "is analyzing contextual data",
-  "is pondering",
-  "is exploring possibilities",
-  "is synthesizing ideas",
-  "is computing paths",
-  "is resolving logic",
-  "is parsing semantics",
-  "is constructing responses",
-  "is interpreting intent",
-  "is weaving thoughts",
-  "is processing inputs",
-  "is evaluating constraints",
-  "is assembling paradigms",
-  "is calibrating tensors",
-  "is indexing memories",
-  "is extrapolating vectors",
-  "is connecting dots",
-  "is deciphering queries",
-  "is aligning objectives",
-  "is routing thoughts",
-  "is optimizing heuristic bounds",
-  "is unrolling loops",
-  "is querying knowledge graphs",
-  "is bridging concepts",
-  "is formulating strategies",
-  "is reviewing context windows",
-  "is distilling facts",
-  "is structuring syntax",
-  "is generating potential worlds",
-  "is rendering concepts",
-  "is simulating outcomes",
-  "is drafting narratives",
-  "is tracing execution flows",
-  "is projecting scenarios",
-  "is expanding context networks",
-  "is cross-referencing archives",
-  "is mapping algorithms",
-  "is building semantic bridges",
-  "is decoding symbols",
-  "is unwinding recursive thoughts",
-  "is fetching relevant insights",
-  "is analyzing edge cases",
-  "is establishing connections",
-  "is evaluating syntax trees",
-  "is navigating logical gates",
-  "is deducing conclusions",
-  "is searching the latent space",
-  "is inferring implicit meaning",
-  "is mapping dimensions",
-  "is assessing probability",
-  "is calculating next steps",
-  "is traversing conceptual graphs",
-  "is examining edge variables",
-  "is verifying constraints",
-  "is scanning mental databases",
-  "is aggregating ideas",
-  "is refining logic structures",
-  "is projecting logic",
-  "is analyzing potential solutions",
-  "is calculating vector spaces",
-  "is synthesizing paradigms",
-  "is reviewing previous statements",
-  "is mapping causal links",
-  "is deriving corollaries",
-  "is simulating dialogue",
-  "is mapping logical spaces",
-  "is assembling puzzle pieces",
-  "is generating possibilities",
-  "is weighing alternatives",
-  "is constructing arguments",
-  "is decoding ambiguity",
-  "is inferring patterns",
-  "is clustering relevant topics",
-  "is exploring latent variables",
-  "is extracting semantic cores",
-  "is balancing equations",
-  "is translating concepts",
-  "is modeling realities",
-  "is connecting synapses",
-  "is activating neural pathways",
-  "is fine-tuning outputs",
-  "is tracing linguistic roots",
-  "is measuring semantic proximity",
-  "is formulating plans",
-  "is constructing frameworks",
-  "is organizing thought streams",
-  "is linking references",
-  "is analyzing tone",
-  "is scanning knowledge bases",
-  "is piecing together models",
-  "is building cognitive structures",
-  "is generating insights",
-  "is forecasting responses",
-  "is evaluating trade-offs",
-  "is mapping inference paths",
-  "is predicting user intent",
-  "is resolving paradoxes",
-  "is unpacking meaning",
-  "is tracing references",
-];
-
-export function ThinkingStatus() {
-  const [verbIndex, setVerbIndex] = useState(() =>
-    Math.floor(Math.random() * THINKING_VERBS.length),
-  );
-
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setVerbIndex((value) => (value + 1) % THINKING_VERBS.length);
-    }, 1500);
-    return () => {
-      clearInterval(timer);
-    };
-  }, []);
-
-  return (
-    <Box marginLeft={1}>
-      <Spinner type="star" color="cyan" />
-      <Text color="gray">{` ${THINKING_VERBS[verbIndex]}...`}</Text>
-    </Box>
-  );
-}

package/src/chat/components/TodoPanel.tsx

@@ -1,49 +0,0 @@
-import { Box, Text } from "ink";
-import type { TodoItem } from "../../core/state/todos.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>
-  );
-}