@goondan/openharness-base 0.1.7 → 0.1.9

package/src/__tests__/tool-search.test.ts

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ToolSearch } from "../extensions/tool-search.js";
-import type {
-  ExtensionApi,
-  ConversationState,
-  ToolDefinition,
-  ToolContext,
-} from "@goondan/openharness-types";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeMockConversationState(): ConversationState {
-  return {
-    messages: [],
-    events: [],
-    emit: vi.fn(),
-    restore: vi.fn(),
-  };
-}
-
-function makeMockApi(
-  conversation: ConversationState,
-  availableTools: ToolDefinition[] = [],
-): {
-  api: ExtensionApi;
-  registeredTools: ToolDefinition[];
-} {
-  const registeredTools: ToolDefinition[] = [...availableTools];
-
-  const api: ExtensionApi = {
-    pipeline: {
-      register: vi.fn() as unknown as ExtensionApi["pipeline"]["register"],
-    },
-    tools: {
-      register: vi.fn((tool: ToolDefinition) => {
-        registeredTools.push(tool);
-      }),
-      remove: vi.fn(),
-      list: vi.fn(() => registeredTools as readonly ToolDefinition[]),
-    },
-    on: vi.fn(),
-    conversation,
-    runtime: {
-      agent: {
-        name: "test-agent",
-        model: { provider: "openai", model: "gpt-4o" },
-        extensions: [],
-        tools: [],
-      },
-      agents: {},
-      connections: {},
-    },
-  };
-
-  return { api, registeredTools };
-}
-
-function makeDummyTool(name: string, description: string): ToolDefinition {
-  return {
-    name,
-    description,
-    parameters: { type: "object", properties: {} },
-    handler: async () => ({ type: "text", text: "ok" }),
-  };
-}
-
-function makeToolContext(): ToolContext {
-  return {
-    conversationId: "conv-1",
-    agentName: "test-agent",
-    abortSignal: new AbortController().signal,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("ToolSearch", () => {
-  it("creates an Extension with name 'tool-search'", () => {
-    const ext = ToolSearch();
-    expect(ext.name).toBe("tool-search");
-  });
-
-  it("registers a meta-tool named 'search_tools'", () => {
-    const conversation = makeMockConversationState();
-    const { api, registeredTools } = makeMockApi(conversation);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    expect(api.tools.register).toHaveBeenCalledOnce();
-    const searchTool = registeredTools.find((t) => t.name === "search_tools");
-    expect(searchTool).toBeDefined();
-  });
-
-  it("search_tools returns tools matching keyword in name", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [
-      makeDummyTool("weather_get", "Get current weather"),
-      makeDummyTool("calendar_add", "Add a calendar event"),
-      makeDummyTool("weather_forecast", "Get weather forecast"),
-    ];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "weather" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(2);
-      expect(data.map((t) => t.name)).toContain("weather_get");
-      expect(data.map((t) => t.name)).toContain("weather_forecast");
-    }
-  });
-
-  it("search_tools returns tools matching keyword in description", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [
-      makeDummyTool("tool_a", "Send an email to a recipient"),
-      makeDummyTool("tool_b", "Read a file from disk"),
-    ];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "email" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(1);
-      expect(data[0].name).toBe("tool_a");
-    }
-  });
-
-  it("search_tools returns empty array when no match", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [makeDummyTool("calculator", "Perform math operations")];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "nonexistent" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toEqual([]);
-    }
-  });
-
-  it("search is case-insensitive", async () => {
-    const conversation = makeMockConversationState();
-    const seedTools = [makeDummyTool("WeatherTool", "Get Weather Data")];
-    const { api } = makeMockApi(conversation, seedTools);
-
-    const ext = ToolSearch();
-    ext.register(api);
-
-    const searchTool = (api.tools.list() as ToolDefinition[]).find(
-      (t) => t.name === "search_tools",
-    )!;
-    const result = await searchTool.handler({ query: "weather" }, makeToolContext());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as unknown as ToolDefinition[];
-      expect(data).toHaveLength(1);
-    }
-  });
-});

package/src/__tests__/tools.test.ts

@@ -1,332 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { BashTool } from "../tools/bash.js";
-import { FileReadTool, FileWriteTool, FileListTool } from "../tools/file-system.js";
-import { HttpFetchTool } from "../tools/http-fetch.js";
-import { JsonQueryTool } from "../tools/json-query.js";
-import { TextTransformTool } from "../tools/text-transform.js";
-import { WaitTool } from "../tools/wait.js";
-import type { ToolContext } from "@goondan/openharness-types";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { writeFile, mkdir } from "node:fs/promises";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeCtx(abortSignal?: AbortSignal): ToolContext {
-  return {
-    conversationId: "conv-1",
-    agentName: "test-agent",
-    abortSignal: abortSignal ?? new AbortController().signal,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// All tools — consolidated schema validation
-// ---------------------------------------------------------------------------
-
-describe("All tools — schema structure", () => {
-  it("every tool has name, description, non-empty required params, and a handler function", () => {
-    const tools = [
-      { factory: BashTool, expectedName: "bash", expectedRequired: ["command"] },
-      { factory: FileReadTool, expectedName: "file_read", expectedRequired: ["path"] },
-      { factory: FileWriteTool, expectedName: "file_write", expectedRequired: ["path", "content"] },
-      { factory: FileListTool, expectedName: "file_list", expectedRequired: ["path"] },
-      { factory: HttpFetchTool, expectedName: "http_fetch", expectedRequired: ["url"] },
-      { factory: JsonQueryTool, expectedName: "json_query", expectedRequired: ["data", "path"] },
-      { factory: TextTransformTool, expectedName: "text_transform", expectedRequired: ["text", "operation"] },
-      { factory: WaitTool, expectedName: "wait", expectedRequired: ["ms"] },
-    ];
-
-    for (const { factory, expectedName, expectedRequired } of tools) {
-      const tool = factory();
-      expect(tool.name).toBe(expectedName);
-      expect(typeof tool.description).toBe("string");
-      expect(tool.description.length).toBeGreaterThan(0);
-      expect(typeof tool.handler).toBe("function");
-
-      const params = tool.parameters as { properties: Record<string, unknown>; required: string[] };
-      for (const req of expectedRequired) {
-        expect(params.properties).toHaveProperty(req);
-        expect(params.required).toContain(req);
-      }
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// BashTool
-// ---------------------------------------------------------------------------
-
-describe("BashTool", () => {
-  it("returns stdout as text result on success", async () => {
-    const tool = BashTool();
-    const result = await tool.handler({ command: "echo hello" }, makeCtx());
-    expect(result.type).toBe("text");
-    if (result.type === "text") {
-      expect(result.text.trim()).toBe("hello");
-    }
-  });
-
-  it("returns error result on command failure", async () => {
-    const tool = BashTool();
-    const result = await tool.handler({ command: "cat /nonexistent_file_xyz_abc_123" }, makeCtx());
-    expect(result.type).toBe("error");
-    if (result.type === "error") {
-      expect(typeof result.error).toBe("string");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// FileReadTool
-// ---------------------------------------------------------------------------
-
-describe("FileReadTool", () => {
-  let tmpFile: string;
-
-  beforeEach(async () => {
-    tmpFile = join(tmpdir(), `openharness-test-${Date.now()}.txt`);
-    await writeFile(tmpFile, "hello file", "utf8");
-  });
-
-  it("reads file content successfully", async () => {
-    const tool = FileReadTool();
-    const result = await tool.handler({ path: tmpFile }, makeCtx());
-    expect(result.type).toBe("text");
-    if (result.type === "text") {
-      expect(result.text).toBe("hello file");
-    }
-  });
-
-  it("returns error for non-existent file", async () => {
-    const tool = FileReadTool();
-    const result = await tool.handler({ path: "/nonexistent/path/file.txt" }, makeCtx());
-    expect(result.type).toBe("error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// FileWriteTool
-// ---------------------------------------------------------------------------
-
-describe("FileWriteTool", () => {
-  it("writes file successfully and returns text result", async () => {
-    const tmpFile = join(tmpdir(), `openharness-write-${Date.now()}.txt`);
-    const tool = FileWriteTool();
-    const result = await tool.handler({ path: tmpFile, content: "written content" }, makeCtx());
-    expect(result.type).toBe("text");
-    if (result.type === "text") {
-      expect(result.text).toContain(tmpFile);
-    }
-  });
-
-  it("returns error when path is invalid", async () => {
-    const tool = FileWriteTool();
-    const result = await tool.handler({ path: "/nonexistent/deeply/nested/path.txt", content: "x" }, makeCtx());
-    expect(result.type).toBe("error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// FileListTool
-// ---------------------------------------------------------------------------
-
-describe("FileListTool", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = join(tmpdir(), `openharness-list-${Date.now()}`);
-    await mkdir(tmpDir, { recursive: true });
-    await writeFile(join(tmpDir, "a.txt"), "a");
-    await writeFile(join(tmpDir, "b.txt"), "b");
-  });
-
-  it("lists directory entries as json result", async () => {
-    const tool = FileListTool();
-    const result = await tool.handler({ path: tmpDir }, makeCtx());
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const entries = result.data as Array<{ name: string; type: string }>;
-      expect(Array.isArray(entries)).toBe(true);
-      const names = entries.map((e) => e.name);
-      expect(names).toContain("a.txt");
-      expect(names).toContain("b.txt");
-    }
-  });
-
-  it("returns error for non-existent directory", async () => {
-    const tool = FileListTool();
-    const result = await tool.handler({ path: "/nonexistent/dir/xyz" }, makeCtx());
-    expect(result.type).toBe("error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HttpFetchTool
-// ---------------------------------------------------------------------------
-
-describe("HttpFetchTool", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("returns json result with status, headers, body on success", async () => {
-    const mockResponse = {
-      status: 200,
-      headers: {
-        get: (name: string) => (name === "content-type" ? "application/json" : null),
-        forEach: (cb: (value: string, key: string) => void) => {
-          cb("application/json", "content-type");
-        },
-      },
-      json: async () => ({ ok: true }),
-    };
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(mockResponse));
-
-    const tool = HttpFetchTool();
-    const result = await tool.handler({ url: "https://example.com/api" }, makeCtx());
-
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      const data = result.data as { status: number; headers: Record<string, string>; body: unknown };
-      expect(data.status).toBe(200);
-      expect(data.body).toEqual({ ok: true });
-    }
-  });
-
-  it("returns error result when fetch throws", async () => {
-    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network error")));
-
-    const tool = HttpFetchTool();
-    const result = await tool.handler({ url: "https://example.com/fail" }, makeCtx());
-    expect(result.type).toBe("error");
-    if (result.type === "error") {
-      expect(result.error).toContain("Network error");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// JsonQueryTool
-// ---------------------------------------------------------------------------
-
-describe("JsonQueryTool", () => {
-  it("queries nested object with dot notation", async () => {
-    const tool = JsonQueryTool();
-    const data = { user: { name: "Alice", age: 30 } };
-    const result = await tool.handler({ data, path: "$.user.name" }, makeCtx());
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toBe("Alice");
-    }
-  });
-
-  it("queries array with bracket notation", async () => {
-    const tool = JsonQueryTool();
-    const data = { items: ["a", "b", "c"] };
-    const result = await tool.handler({ data, path: "$.items[1]" }, makeCtx());
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toBe("b");
-    }
-  });
-
-  it("returns root data for $ path", async () => {
-    const tool = JsonQueryTool();
-    const data = { x: 1 };
-    const result = await tool.handler({ data, path: "$" }, makeCtx());
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toEqual(data);
-    }
-  });
-
-  it("returns undefined for missing path", async () => {
-    const tool = JsonQueryTool();
-    const data = { a: 1 };
-    const result = await tool.handler({ data, path: "$.b.c" }, makeCtx());
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toBeUndefined();
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// TextTransformTool
-// ---------------------------------------------------------------------------
-
-describe("TextTransformTool", () => {
-  it("uppercase operation", async () => {
-    const tool = TextTransformTool();
-    const result = await tool.handler({ text: "hello world", operation: "uppercase" }, makeCtx());
-    expect(result).toEqual({ type: "text", text: "HELLO WORLD" });
-  });
-
-  it("lowercase operation", async () => {
-    const tool = TextTransformTool();
-    const result = await tool.handler({ text: "HELLO WORLD", operation: "lowercase" }, makeCtx());
-    expect(result).toEqual({ type: "text", text: "hello world" });
-  });
-
-  it("trim operation", async () => {
-    const tool = TextTransformTool();
-    const result = await tool.handler({ text: "  spaces  ", operation: "trim" }, makeCtx());
-    expect(result).toEqual({ type: "text", text: "spaces" });
-  });
-
-  it("split operation returns json array", async () => {
-    const tool = TextTransformTool();
-    const result = await tool.handler(
-      { text: "a,b,c", operation: "split", options: { delimiter: "," } },
-      makeCtx(),
-    );
-    expect(result.type).toBe("json");
-    if (result.type === "json") {
-      expect(result.data).toEqual(["a", "b", "c"]);
-    }
-  });
-
-  it("replace operation", async () => {
-    const tool = TextTransformTool();
-    const result = await tool.handler(
-      { text: "foo bar foo", operation: "replace", options: { find: "foo", replacement: "baz" } },
-      makeCtx(),
-    );
-    expect(result).toEqual({ type: "text", text: "baz bar baz" });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// WaitTool
-// ---------------------------------------------------------------------------
-
-describe("WaitTool", () => {
-  it("waits and returns text result", async () => {
-    const tool = WaitTool();
-    const result = await tool.handler({ ms: 10 }, makeCtx());
-    expect(result.type).toBe("text");
-    if (result.type === "text") {
-      expect(result.text).toBe("Waited 10ms");
-    }
-  });
-
-  it("respects maxMs cap", async () => {
-    const tool = WaitTool({ maxMs: 20 });
-    const result = await tool.handler({ ms: 1000 }, makeCtx());
-    expect(result.type).toBe("text");
-    if (result.type === "text") {
-      expect(result.text).toBe("Waited 20ms");
-    }
-  });
-
-  it("rejects when aborted", async () => {
-    const tool = WaitTool();
-    const ac = new AbortController();
-    const promise = tool.handler({ ms: 5000 }, makeCtx(ac.signal));
-    ac.abort();
-    await expect(promise).rejects.toThrow();
-  });
-});

package/src/extensions/basic-system-prompt.ts

@@ -1,48 +0,0 @@
-import type { Extension, ExtensionApi } from "@goondan/openharness-types";
-
-const SYSTEM_MESSAGE_ID = "sys-basic-system-prompt";
-
-/**
- * BasicSystemPrompt extension — prepends a system message to the conversation
- * at the start of every turn.
- *
- * Uses a fixed message ID so the system prompt is only appended once;
- * subsequent turns detect the existing message and skip the append.
- *
- * Priority 10 (HIGH) ensures it runs before other turn middleware.
- */
-export function BasicSystemPrompt(text: string): Extension {
-  return {
-    name: "basic-system-prompt",
-
-    register(api: ExtensionApi): void {
-      api.pipeline.register(
-        "turn",
-        async (ctx, next) => {
-          const alreadyExists = ctx.conversation.messages.some(
-            (m) => m.id === SYSTEM_MESSAGE_ID,
-          );
-
-          if (!alreadyExists) {
-            ctx.conversation.emit({
-              type: "append",
-              message: {
-                id: SYSTEM_MESSAGE_ID,
-                data: {
-                  role: "system",
-                  content: text,
-                },
-                metadata: {
-                  __createdBy: "basic-system-prompt",
-                },
-              },
-            });
-          }
-
-          return next();
-        },
-        { priority: 10 },
-      );
-    },
-  };
-}

package/src/extensions/compaction-summarize.ts

@@ -1,104 +0,0 @@
-import type { Extension, ExtensionApi, Message, LlmChatOptions } from "@goondan/openharness-types";
-import { randomUUID } from "node:crypto";
-
-const DEFAULT_SUMMARY_PROMPT =
-  "You are a conversation compactor. Summarize the following messages into a concise summary " +
-  "that preserves all important context, decisions, facts, and action items. " +
-  "Be thorough but brief. Output only the summary text, nothing else.";
-
-/**
- * Extract plain-text representation of a Message for summarization.
- */
-function messageToText(m: Message): string {
-  const role = m.data.role;
-  const content =
-    typeof m.data.content === "string"
-      ? m.data.content
-      : JSON.stringify(m.data.content);
-  return `[${role}]: ${content}`;
-}
-
-/**
- * CompactionSummarize extension — when message count exceeds `threshold`,
- * removes the oldest messages and replaces them with an LLM-generated summary.
- *
- * By default, uses the agent's own LLM (`ctx.llm`) to produce the summary.
- * A custom `summarizer` callback can override this for advanced use cases
- * (e.g. using a cheaper model, external API, or deterministic logic).
- *
- * @param config.threshold - Trigger compaction when messages exceed this count.
- * @param config.summaryPrompt - Custom system prompt for the LLM summarizer.
- * @param config.summarizer - Optional override: produce summary text from messages.
- */
-export function CompactionSummarize(config: {
-  threshold: number;
-  summaryPrompt?: string;
-  /** LLM options for the summarization call (e.g. model override for cheaper summarization). */
-  llmOptions?: LlmChatOptions;
-  summarizer?: (messages: Message[]) => Promise<string>;
-}): Extension {
-  return {
-    name: "compaction-summarize",
-
-    register(api: ExtensionApi): void {
-      api.pipeline.register("step", async (ctx, next) => {
-        const messages = ctx.conversation.messages;
-        if (messages.length > config.threshold) {
-          const keepCount = Math.floor(config.threshold / 2);
-          const removeCount = messages.length - keepCount;
-          const toRemove = messages.slice(0, removeCount);
-
-          let summaryText: string;
-
-          if (config.summarizer) {
-            // User-provided summarizer takes precedence
-            summaryText = await config.summarizer([...toRemove]);
-          } else {
-            // Default: LLM-based summarization via ctx.llm
-            const transcript = toRemove.map(messageToText).join("\n");
-            const prompt = config.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
-
-            const llmResponse = await ctx.llm.chat(
-              [
-                { id: `compaction-sys-${randomUUID()}`, data: { role: "system", content: prompt }, metadata: {} },
-                { id: `compaction-usr-${randomUUID()}`, data: { role: "user", content: transcript }, metadata: {} },
-              ],
-              [], // no tools needed for summarization
-              ctx.abortSignal,
-              config.llmOptions,
-            );
-
-            summaryText = llmResponse.text ?? transcript;
-          }
-
-          // Remove old messages, replace first with summary for stable ordering
-          const [firstToRemove, ...restToRemove] = toRemove;
-          // Replace the first message with the summary
-          ctx.conversation.emit({
-            type: "remove",
-            messageId: firstToRemove.id,
-          });
-          for (const msg of restToRemove) {
-            ctx.conversation.emit({ type: "remove", messageId: msg.id });
-          }
-
-          // Prepend summary as a system message
-          ctx.conversation.emit({
-            type: "append",
-            message: {
-              id: `summary-${randomUUID()}`,
-              data: {
-                role: "system",
-                content: `[Summary of earlier conversation]: ${summaryText}`,
-              },
-              metadata: {
-                __createdBy: "compaction-summarize",
-              },
-            },
-          });
-        }
-        return next();
-      });
-    },
-  };
-}