@goondan/openharness-base 0.1.7 → 0.1.9

package/src/extensions/logging.ts

@@ -1,42 +0,0 @@
-import type { Extension, ExtensionApi } from "@goondan/openharness-types";
-
-/**
- * Logging extension — subscribes to core events and logs them.
- */
-export function Logging(config?: { logger?: (msg: string) => void }): Extension {
-  const log = config?.logger ?? console.log;
-
-  return {
-    name: "logging",
-
-    register(api: ExtensionApi): void {
-      api.on("turn.start", (payload) => {
-        log(`[turn.start] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("turn.done", (payload) => {
-        log(`[turn.done] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("turn.error", (payload) => {
-        log(`[turn.error] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("step.start", (payload) => {
-        log(`[step.start] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("step.done", (payload) => {
-        log(`[step.done] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("tool.start", (payload) => {
-        log(`[tool.start] ${JSON.stringify(payload)}`);
-      });
-
-      api.on("tool.done", (payload) => {
-        log(`[tool.done] ${JSON.stringify(payload)}`);
-      });
-    },
-  };
-}

package/src/extensions/message-window.ts

@@ -1,23 +0,0 @@
-import type { Extension, ExtensionApi } from "@goondan/openharness-types";
-
-/**
- * MessageWindow extension — truncates conversation history to keep only
- * the most recent `maxMessages` messages before each step.
- */
-export function MessageWindow(config: { maxMessages: number }): Extension {
-  return {
-    name: "message-window",
-
-    register(api: ExtensionApi): void {
-      api.pipeline.register("step", async (ctx, next) => {
-        if (ctx.conversation.messages.length > config.maxMessages) {
-          ctx.conversation.emit({
-            type: "truncate",
-            keepLast: config.maxMessages,
-          });
-        }
-        return next();
-      });
-    },
-  };
-}

package/src/extensions/required-tools-guard.ts

@@ -1,24 +0,0 @@
-import type { Extension, ExtensionApi } from "@goondan/openharness-types";
-
-/**
- * RequiredToolsGuard extension — blocks a turn if any required tools are
- * not registered.
- */
-export function RequiredToolsGuard(config: { tools: string[] }): Extension {
-  return {
-    name: "required-tools-guard",
-
-    register(api: ExtensionApi): void {
-      api.pipeline.register("turn", async (ctx, next) => {
-        const registered = api.tools.list().map((t) => t.name);
-        const missing = config.tools.filter((name) => !registered.includes(name));
-        if (missing.length > 0) {
-          throw new Error(
-            `RequiredToolsGuard: missing required tools: ${missing.join(", ")}`,
-          );
-        }
-        return next();
-      });
-    },
-  };
-}

package/src/extensions/tool-search.ts

@@ -1,38 +0,0 @@
-import type { Extension, ExtensionApi, JsonValue } from "@goondan/openharness-types";
-
-/**
- * ToolSearch extension — registers a meta-tool `search_tools` that searches
- * registered tool names and descriptions by keyword.
- */
-export function ToolSearch(): Extension {
-  return {
-    name: "tool-search",
-
-    register(api: ExtensionApi): void {
-      api.tools.register({
-        name: "search_tools",
-        description: "Search registered tools by keyword in name or description.",
-        parameters: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "Keyword to search for in tool names and descriptions.",
-            },
-          },
-          required: ["query"],
-        },
-        handler: async (args) => {
-          const query = (args["query"] as string).toLowerCase();
-          const allTools = api.tools.list();
-          const matching = allTools.filter(
-            (t) =>
-              t.name.toLowerCase().includes(query) ||
-              t.description.toLowerCase().includes(query),
-          );
-          return { type: "json", data: matching as unknown as JsonValue };
-        },
-      });
-    },
-  };
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-export { BasicSystemPrompt } from "./extensions/basic-system-prompt.js";
-export { MessageWindow } from "./extensions/message-window.js";
-export { CompactionSummarize } from "./extensions/compaction-summarize.js";
-export { Logging } from "./extensions/logging.js";
-export { ToolSearch } from "./extensions/tool-search.js";
-export { RequiredToolsGuard } from "./extensions/required-tools-guard.js";
-
-// Tools
-export { BashTool } from "./tools/bash.js";
-export type { BashToolConfig } from "./tools/bash.js";
-export { FileReadTool, FileWriteTool, FileListTool } from "./tools/file-system.js";
-export { HttpFetchTool } from "./tools/http-fetch.js";
-export { JsonQueryTool } from "./tools/json-query.js";
-export { TextTransformTool } from "./tools/text-transform.js";
-export { WaitTool } from "./tools/wait.js";
-export type { WaitToolConfig } from "./tools/wait.js";

package/src/tools/bash.ts

@@ -1,38 +0,0 @@
-import { exec } from "node:child_process";
-import type { ToolDefinition, JsonObject, ToolContext } from "@goondan/openharness-types";
-
-export interface BashToolConfig {
-  timeout?: number;
-  maxBuffer?: number;
-}
-
-export function BashTool(config: BashToolConfig = {}): ToolDefinition {
-  const { timeout = 30_000, maxBuffer = 1024 * 1024 } = config;
-
-  return {
-    name: "bash",
-    description: "Execute a shell command and return its output.",
-    parameters: {
-      type: "object",
-      properties: {
-        command: { type: "string", description: "The shell command to execute." },
-        cwd: { type: "string", description: "Optional working directory for the command." },
-      },
-      required: ["command"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const command = args["command"] as string;
-      const cwd = args["cwd"] as string | undefined;
-
-      return new Promise((resolve) => {
-        exec(command, { timeout, maxBuffer, cwd }, (error, stdout, stderr) => {
-          if (error) {
-            resolve({ type: "error", error: stderr || error.message });
-          } else {
-            resolve({ type: "text", text: stdout });
-          }
-        });
-      });
-    },
-  };
-}

package/src/tools/file-system.ts

@@ -1,83 +0,0 @@
-import { readFile, writeFile, readdir } from "node:fs/promises";
-import type { ToolDefinition, JsonObject, ToolContext } from "@goondan/openharness-types";
-
-export function FileReadTool(): ToolDefinition {
-  return {
-    name: "file_read",
-    description: "Read the contents of a file.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Absolute or relative path to the file to read." },
-        encoding: {
-          type: "string",
-          enum: ["utf8", "base64"],
-          description: "File encoding. Defaults to utf8.",
-        },
-      },
-      required: ["path"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const filePath = args["path"] as string;
-      const encoding = (args["encoding"] as BufferEncoding | undefined) ?? "utf8";
-      try {
-        const content = await readFile(filePath, { encoding });
-        return { type: "text", text: content };
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}
-
-export function FileWriteTool(): ToolDefinition {
-  return {
-    name: "file_write",
-    description: "Write content to a file, creating or overwriting it.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Absolute or relative path to the file to write." },
-        content: { type: "string", description: "The content to write to the file." },
-      },
-      required: ["path", "content"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const filePath = args["path"] as string;
-      const content = args["content"] as string;
-      try {
-        await writeFile(filePath, content, "utf8");
-        return { type: "text", text: `File written: ${filePath}` };
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}
-
-export function FileListTool(): ToolDefinition {
-  return {
-    name: "file_list",
-    description: "List files and directories in a given directory.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Absolute or relative path to the directory to list." },
-      },
-      required: ["path"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const dirPath = args["path"] as string;
-      try {
-        const entries = await readdir(dirPath, { withFileTypes: true });
-        const result = entries.map((e) => ({
-          name: e.name,
-          type: e.isDirectory() ? "directory" : "file",
-        }));
-        return { type: "json", data: result };
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}

package/src/tools/http-fetch.ts

@@ -1,64 +0,0 @@
-import type { ToolDefinition, JsonObject, ToolContext, JsonValue } from "@goondan/openharness-types";
-
-export function HttpFetchTool(): ToolDefinition {
-  return {
-    name: "http_fetch",
-    description: "Perform an HTTP request and return the response.",
-    parameters: {
-      type: "object",
-      properties: {
-        url: { type: "string", description: "The URL to fetch." },
-        method: {
-          type: "string",
-          enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"],
-          description: "HTTP method. Defaults to GET.",
-        },
-        headers: {
-          type: "object",
-          additionalProperties: { type: "string" },
-          description: "Optional request headers.",
-        },
-        body: { type: "string", description: "Optional request body." },
-      },
-      required: ["url"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const url = args["url"] as string;
-      const method = (args["method"] as string | undefined) ?? "GET";
-      const headers = (args["headers"] as Record<string, string> | undefined) ?? {};
-      const body = args["body"] as string | undefined;
-
-      try {
-        const response = await fetch(url, {
-          method,
-          headers,
-          body: body !== undefined ? body : undefined,
-        });
-
-        const responseHeaders: Record<string, string> = {};
-        response.headers.forEach((value, key) => {
-          responseHeaders[key] = value;
-        });
-
-        let responseBody: unknown;
-        const contentType = response.headers.get("content-type") ?? "";
-        if (contentType.includes("application/json")) {
-          responseBody = await response.json();
-        } else {
-          responseBody = await response.text();
-        }
-
-        return {
-          type: "json",
-          data: {
-            status: response.status,
-            headers: responseHeaders,
-            body: responseBody as JsonValue,
-          },
-        };
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}

package/src/tools/json-query.ts

@@ -1,71 +0,0 @@
-import type { ToolDefinition, JsonObject, ToolContext, JsonValue } from "@goondan/openharness-types";
-
-/**
- * Simple JSONPath-like query supporting dot and bracket notation.
- * Supported path format: $.key.nested[0].field
- * The leading `$` is optional.
- */
-function jsonQuery(data: unknown, path: string): unknown {
-  // Normalize: strip leading `$` or `$.`
-  let normalized = path.trim();
-  if (normalized.startsWith("$.")) {
-    normalized = normalized.slice(2);
-  } else if (normalized === "$") {
-    return data;
-  } else if (normalized.startsWith("$")) {
-    normalized = normalized.slice(1);
-  }
-
-  if (normalized === "" || normalized === ".") {
-    return data;
-  }
-
-  // Tokenize path into segments
-  const segments: Array<string | number> = [];
-  // Replace bracket notation [0] with .0
-  const normalized2 = normalized.replace(/\[(\d+)\]/g, ".$1").replace(/\[['"](.+?)['"]\]/g, ".$1");
-  for (const part of normalized2.split(".")) {
-    if (part === "") continue;
-    const num = Number(part);
-    segments.push(Number.isInteger(num) && String(num) === part ? num : part);
-  }
-
-  let current: unknown = data;
-  for (const segment of segments) {
-    if (current === null || current === undefined) return undefined;
-    if (typeof current === "object") {
-      current = (current as Record<string | number, unknown>)[segment];
-    } else {
-      return undefined;
-    }
-  }
-  return current;
-}
-
-export function JsonQueryTool(): ToolDefinition {
-  return {
-    name: "json_query",
-    description: "Query JSON data using a simple JSONPath-like path expression.",
-    parameters: {
-      type: "object",
-      properties: {
-        data: { description: "The JSON data to query." },
-        path: {
-          type: "string",
-          description: "JSONPath-like path, e.g. $.key.nested[0].field",
-        },
-      },
-      required: ["data", "path"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const data = args["data"];
-      const path = args["path"] as string;
-      try {
-        const result = jsonQuery(data, path);
-        return { type: "json", data: result as JsonValue };
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}

package/src/tools/text-transform.ts

@@ -1,59 +0,0 @@
-import type { ToolDefinition, JsonObject, ToolContext } from "@goondan/openharness-types";
-
-type Operation = "uppercase" | "lowercase" | "trim" | "split" | "replace";
-
-export function TextTransformTool(): ToolDefinition {
-  return {
-    name: "text_transform",
-    description: "Apply a transformation operation to a text string.",
-    parameters: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "The input text to transform." },
-        operation: {
-          type: "string",
-          enum: ["uppercase", "lowercase", "trim", "split", "replace"],
-          description: "The transformation to apply.",
-        },
-        options: {
-          type: "object",
-          properties: {
-            delimiter: { type: "string", description: "Delimiter for split operation." },
-            find: { type: "string", description: "String to find for replace operation." },
-            replacement: { type: "string", description: "Replacement string for replace operation." },
-          },
-        },
-      },
-      required: ["text", "operation"],
-    },
-    async handler(args: JsonObject, _ctx: ToolContext) {
-      const text = args["text"] as string;
-      const operation = args["operation"] as Operation;
-      const options = (args["options"] as Record<string, string> | undefined) ?? {};
-
-      try {
-        switch (operation) {
-          case "uppercase":
-            return { type: "text", text: text.toUpperCase() };
-          case "lowercase":
-            return { type: "text", text: text.toLowerCase() };
-          case "trim":
-            return { type: "text", text: text.trim() };
-          case "split": {
-            const delimiter = options["delimiter"] ?? " ";
-            return { type: "json", data: text.split(delimiter) };
-          }
-          case "replace": {
-            const find = options["find"] ?? "";
-            const replacement = options["replacement"] ?? "";
-            return { type: "text", text: text.split(find).join(replacement) };
-          }
-          default:
-            return { type: "error", error: `Unknown operation: ${operation}` };
-        }
-      } catch (err) {
-        return { type: "error", error: (err as Error).message };
-      }
-    },
-  };
-}

package/src/tools/wait.ts

@@ -1,46 +0,0 @@
-import type { ToolDefinition, JsonObject, ToolContext } from "@goondan/openharness-types";
-
-export interface WaitToolConfig {
-  maxMs?: number;
-}
-
-export function WaitTool(config: WaitToolConfig = {}): ToolDefinition {
-  const { maxMs = 60_000 } = config;
-
-  return {
-    name: "wait",
-    description: "Wait for a specified number of milliseconds before continuing.",
-    parameters: {
-      type: "object",
-      properties: {
-        ms: {
-          type: "number",
-          description: "Number of milliseconds to wait.",
-          minimum: 0,
-        },
-      },
-      required: ["ms"],
-    },
-    async handler(args: JsonObject, ctx: ToolContext) {
-      const requestedMs = args["ms"] as number;
-      const ms = Math.min(requestedMs, maxMs);
-
-      await new Promise<void>((resolve, reject) => {
-        const timer = setTimeout(resolve, ms);
-
-        if (ctx.abortSignal.aborted) {
-          clearTimeout(timer);
-          reject(new Error("Aborted"));
-          return;
-        }
-
-        ctx.abortSignal.addEventListener("abort", () => {
-          clearTimeout(timer);
-          reject(new Error("Aborted"));
-        });
-      });
-
-      return { type: "text", text: `Waited ${ms}ms` };
-    },
-  };
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist",
-    "rootDir": "src"
-  },
-  "include": ["src"]
-}

package/vitest.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    include: ["src/**/*.test.ts"],
-  },
-});