@goondan/openharness-base 0.1.8 → 0.1.9

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"],
-  },
-});