hoomanjs 1.17.4 → 1.18.0

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

@@ -34,6 +34,7 @@ import {
 import { getPromptView, type PromptView } from "./render.ts";
 import { getCwd } from "../../../core/utils/cwd-context.ts";
 import { saveClipboardImageAsAttachment } from "./clipboard-image.ts";
+import { isMouseInput } from "../../mouse.ts";
 
 export type PromptSubmission = {
   text: string;
@@ -355,6 +356,10 @@ export function usePromptInputController({
 
   useInput(
     (input, key) => {
+      if (isMouseInput(input)) {
+        return;
+      }
+
       const state = getState();
 
       if (key.return) {

package/src/chat/mouse.ts

@@ -0,0 +1,17 @@
+import { parseMouseEvents } from "ink-use-mouse";
+
+const STRIPPED_SGR_MOUSE_RE = /\[?<\d+;\d+;\d+[mM]/;
+
+export const MOUSE_REPORTING_ENABLE =
+  "\x1b[?1003l\x1b[?1002l\x1b[?1000h\x1b[?1006h";
+
+export const MOUSE_REPORTING_DISABLE =
+  "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l";
+
+export function isMouseInput(input: string): boolean {
+  return (
+    parseMouseEvents(input).length > 0 || STRIPPED_SGR_MOUSE_RE.test(input)
+  );
+}
+
+export { parseMouseEvents };

package/src/chat/types.ts

@@ -1,3 +1,5 @@
+import type { FileToolDisplay } from "../core/state/file-tool-display.ts";
+
 export type ChatRole = "user" | "assistant" | "tool" | "system";
 
 export interface ChatLine {
@@ -9,6 +11,7 @@ export interface ChatLine {
   toolName?: string;
   phase?: "running" | "done";
   resultContent?: string;
+  fileToolDisplay?: FileToolDisplay;
 }
 
 export type ApprovalDecision = "allow" | "reject" | "always";

package/src/core/agent/index.ts

@@ -30,7 +30,7 @@ import {
   createWikiTools,
   createWebSearchTools,
 } from "../tools";
-import { clearTodoState } from "../tools/todo.ts";
+import { clearTodoState } from "../state/todos.ts";
 
 const SECTION_BREAK = "\n\n---\n\n";
 

package/src/core/agents/registry.ts

@@ -32,8 +32,8 @@ function validateConfigs(configs: readonly AgentConfig[]): void {
     if (!config.description.trim()) {
       throw new Error(`Agent '${config.id}' description cannot be empty.`);
     }
-    if (!Array.isArray(config.tools) || config.tools.length === 0) {
-      throw new Error(`Agent '${config.id}' must declare at least one tool.`);
+    if (!Array.isArray(config.tools)) {
+      throw new Error(`Agent '${config.id}' tools must be an array.`);
     }
     for (const toolName of config.tools) {
       if (!toolName.trim()) {
@@ -43,20 +43,18 @@ function validateConfigs(configs: readonly AgentConfig[]): void {
   }
 }
 
-function assertKnownTools(
+function filterKnownTools(
   definitions: readonly AgentDefinition[],
   knownTools: readonly string[],
-): void {
+): AgentDefinition[] {
   const known = new Set(knownTools);
-  for (const definition of definitions) {
-    for (const toolName of definition.tools) {
-      if (!known.has(toolName)) {
-        throw new Error(
-          `Agent '${definition.id}' references unknown tool '${toolName}'.`,
-        );
-      }
-    }
-  }
+  return definitions.map((definition) => {
+    const tools = definition.tools.filter((toolName) => known.has(toolName));
+    return {
+      ...definition,
+      tools,
+    };
+  });
 }
 
 function context(config: Config): Record<string, unknown> {
@@ -102,7 +100,7 @@ export function loadBuiltInAgentDefinitions(
     };
   });
   if (options?.knownTools) {
-    assertKnownTools(definitions, options.knownTools);
+    return filterKnownTools(definitions, options.knownTools);
   }
   return definitions;
 }

package/src/core/prompts/system.ts

@@ -34,6 +34,7 @@ const HARNESS_PROMPT_FILES = [
 export type SystemMode = "default" | "daemon" | "acp";
 
 const SECTION_BREAK = "\n\n---\n\n";
+const EXTRA_CWD_INSTRUCTIONS = "AGENTS.md";
 
 /**
  * Loads `prompts/static/*.md` from the package, then `instructions.md` from disk,
@@ -122,12 +123,21 @@ export class System {
     return parts.join("\n\n");
   }
 
+  private readCwdAgentsInstructions(): string {
+    const path = join(process.cwd(), EXTRA_CWD_INSTRUCTIONS);
+    if (!existsSync(path)) {
+      return "";
+    }
+    return readFileSync(path, "utf8").trim();
+  }
+
   private readRawText(): string {
     const instructions = existsSync(this.path)
       ? readFileSync(this.path, "utf8").trim()
       : "";
     const bundled = this.readBundledStaticPrompts();
     const harness = this.readBundledHarnessPrompts();
+    const extra = this.readCwdAgentsInstructions();
 
     const blocks: string[] = [];
     if (bundled.length > 0) {
@@ -139,6 +149,9 @@ export class System {
     if (instructions.length > 0) {
       blocks.push(instructions);
     }
+    if (extra.length > 0) {
+      blocks.push(extra);
+    }
     if (blocks.length === 0) {
       return "";
     }

package/src/core/state/file-tool-display.ts

@@ -0,0 +1,70 @@
+import type { JSONValue } from "@strands-agents/sdk";
+
+const FILE_TOOL_DISPLAY_STATE_KEY = "fileToolDisplay";
+
+export type StructuredPatchHunk = {
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: string[];
+};
+
+export type FileToolDisplay = {
+  previews?: string[];
+  structuredPatch?: StructuredPatchHunk[];
+};
+
+type DisplayStateStore = {
+  get(key: string): JSONValue | undefined;
+  set(key: string, value: unknown): void;
+  delete(key: string): void;
+};
+
+function readDisplayState(
+  appState: DisplayStateStore,
+): Record<string, FileToolDisplay> {
+  const value = appState.get(FILE_TOOL_DISPLAY_STATE_KEY);
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, FileToolDisplay>)
+    : {};
+}
+
+export function setFileToolDisplay(
+  appState: DisplayStateStore,
+  toolUseId: string | undefined,
+  display: FileToolDisplay,
+): void {
+  if (!toolUseId) {
+    return;
+  }
+
+  appState.set(FILE_TOOL_DISPLAY_STATE_KEY, {
+    ...readDisplayState(appState),
+    [toolUseId]: display,
+  });
+}
+
+export function takeFileToolDisplay(
+  appState: DisplayStateStore,
+  toolUseId: string | null,
+): FileToolDisplay | undefined {
+  if (!toolUseId) {
+    return undefined;
+  }
+
+  const state = readDisplayState(appState);
+  const display = state[toolUseId];
+  if (!display) {
+    return undefined;
+  }
+
+  const { [toolUseId]: _removed, ...nextState } = state;
+  if (Object.keys(nextState).length === 0) {
+    appState.delete(FILE_TOOL_DISPLAY_STATE_KEY);
+  } else {
+    appState.set(FILE_TOOL_DISPLAY_STATE_KEY, nextState);
+  }
+
+  return display;
+}

package/src/core/state/thought-process.ts

@@ -0,0 +1,49 @@
+import type { ToolContext } from "@strands-agents/sdk";
+
+const THINKING_STATE_KEY = "thinking.sequential";
+
+export type ThoughtEntry = {
+  thought: string;
+  thoughtNumber: number;
+  totalThoughts: number;
+  nextThoughtNeeded: boolean;
+  isRevision: boolean;
+  revisesThought: number | null;
+  branchFromThought: number | null;
+  branchId: string | null;
+  needsMoreThoughts: boolean;
+};
+
+export type ThinkingState = {
+  history: ThoughtEntry[];
+  branches: string[];
+};
+
+function isThinkingState(value: unknown): value is ThinkingState {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    "history" in value &&
+    "branches" in value &&
+    Array.isArray(value.history) &&
+    Array.isArray(value.branches)
+  );
+}
+
+export function readThinkingState(context: ToolContext): ThinkingState {
+  const current = context.agent.appState.get(THINKING_STATE_KEY);
+
+  if (isThinkingState(current)) {
+    return current;
+  }
+
+  return { history: [], branches: [] };
+}
+
+export function writeThinkingState(
+  context: ToolContext,
+  state: ThinkingState,
+): void {
+  context.agent.appState.set(THINKING_STATE_KEY, state);
+}

package/src/core/state/todos.ts

@@ -0,0 +1,84 @@
+import { z } from "zod";
+
+export const TODO_ITEMS_STATE_KEY = "todo.items";
+export const TODO_VISIBLE_STATE_KEY = "todo.visible";
+
+export const TodoStatusSchema = z.enum(["pending", "in_progress", "completed"]);
+
+export const TodoItemSchema = z.object({
+  content: z.string().trim().min(1),
+  status: TodoStatusSchema,
+  activeForm: z.string().trim().min(1),
+});
+
+export type TodoStatus = z.infer<typeof TodoStatusSchema>;
+export type TodoItem = z.infer<typeof TodoItemSchema>;
+
+type AppStateLike = {
+  get<T = unknown>(key: string): T;
+  set(key: string, value: unknown): void;
+};
+
+type AgentLike = {
+  appState: AppStateLike;
+};
+
+export type TodoViewState = {
+  visible: boolean;
+  todos: TodoItem[];
+  total: number;
+  pending: number;
+  ongoing: number;
+  completed: number;
+};
+
+function normalizeTodoItems(value: unknown): TodoItem[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const normalized: TodoItem[] = [];
+  for (const item of value) {
+    const parsed = TodoItemSchema.safeParse(item);
+    if (parsed.success) {
+      normalized.push(parsed.data);
+    }
+  }
+  return normalized;
+}
+
+export function summarizeTodos(
+  todos: TodoItem[],
+): Omit<TodoViewState, "visible" | "todos"> {
+  const pending = todos.filter((todo) => todo.status === "pending").length;
+  const ongoing = todos.filter((todo) => todo.status === "in_progress").length;
+  const completed = todos.filter((todo) => todo.status === "completed").length;
+  return {
+    total: todos.length,
+    pending,
+    ongoing,
+    completed,
+  };
+}
+
+export function getTodoViewState(agent: AgentLike): TodoViewState {
+  const todos = normalizeTodoItems(agent.appState.get(TODO_ITEMS_STATE_KEY));
+  const rawVisible = agent.appState.get(TODO_VISIBLE_STATE_KEY);
+  const visible =
+    typeof rawVisible === "boolean" ? rawVisible : todos.length > 0;
+  const summary = summarizeTodos(todos);
+  return {
+    visible,
+    todos,
+    ...summary,
+  };
+}
+
+export function setTodoState(agent: AgentLike, todos: TodoItem[]): void {
+  agent.appState.set(TODO_ITEMS_STATE_KEY, todos);
+  agent.appState.set(TODO_VISIBLE_STATE_KEY, todos.length > 0);
+}
+
+export function clearTodoState(agent: AgentLike): void {
+  agent.appState.set(TODO_ITEMS_STATE_KEY, []);
+  agent.appState.set(TODO_VISIBLE_STATE_KEY, false);
+}