@goondan/openharness-base 0.0.1-alpha4 → 2.0.0-alpha.1

package/dist/index.d.ts

@@ -1,5 +1,72 @@
-export * from './types.js';
-export * from './tools/index.js';
-export * from './extensions/index.js';
-export * from './manifests/index.js';
-//# sourceMappingURL=index.d.ts.map
+import { Extension, ToolDefinition } from '@goondan/openharness-types';
+
+/**
+ * ContextMessage extension — prepends a system message to the conversation
+ * at the start of every turn.
+ *
+ * Priority 10 (HIGH) ensures it runs before other turn middleware.
+ */
+declare function ContextMessage(text: string): Extension;
+
+/**
+ * MessageWindow extension — truncates conversation history to keep only
+ * the most recent `maxMessages` messages before each step.
+ */
+declare function MessageWindow(config: {
+    maxMessages: number;
+}): Extension;
+
+/**
+ * CompactionSummarize extension — when message count exceeds `threshold`,
+ * removes the oldest messages and prepends a summary system message.
+ *
+ * For MVP the "summary" is just the concatenation of removed message text.
+ */
+declare function CompactionSummarize(config: {
+    threshold: number;
+    summaryPrompt?: string;
+}): Extension;
+
+/**
+ * Logging extension — subscribes to core events and logs them.
+ */
+declare function Logging(config?: {
+    logger?: (msg: string) => void;
+}): Extension;
+
+/**
+ * ToolSearch extension — registers a meta-tool `search_tools` that searches
+ * registered tool names and descriptions by keyword.
+ */
+declare function ToolSearch(): Extension;
+
+/**
+ * RequiredToolsGuard extension — blocks a turn if any required tools are
+ * not registered.
+ */
+declare function RequiredToolsGuard(config: {
+    tools: string[];
+}): Extension;
+
+interface BashToolConfig {
+    timeout?: number;
+    maxBuffer?: number;
+}
+declare function BashTool(config?: BashToolConfig): ToolDefinition;
+
+declare function FileReadTool(): ToolDefinition;
+declare function FileWriteTool(): ToolDefinition;
+declare function FileListTool(): ToolDefinition;
+
+declare function HttpFetchTool(): ToolDefinition;
+
+declare function JsonQueryTool(): ToolDefinition;
+
+declare function TextTransformTool(): ToolDefinition;
+
+interface WaitToolConfig {
+    maxMs?: number;
+}
+declare function WaitTool(config?: WaitToolConfig): ToolDefinition;
+
+export { BashTool, type BashToolConfig, CompactionSummarize, ContextMessage, FileListTool, FileReadTool, FileWriteTool, HttpFetchTool, JsonQueryTool, Logging, MessageWindow, RequiredToolsGuard, TextTransformTool, ToolSearch, WaitTool, type WaitToolConfig };

package/dist/index.js

@@ -1,5 +1,506 @@
-export * from './types.js';
-export * from './tools/index.js';
-export * from './extensions/index.js';
-export * from './manifests/index.js';
-//# sourceMappingURL=index.js.map
+// src/extensions/context-message.ts
+import { randomUUID } from "crypto";
+function ContextMessage(text) {
+  return {
+    name: "context-message",
+    register(api) {
+      api.pipeline.register(
+        "turn",
+        async (ctx, next) => {
+          ctx.conversation.emit({
+            type: "append",
+            message: {
+              id: `ctx-msg-${randomUUID()}`,
+              data: {
+                role: "system",
+                content: text
+              },
+              metadata: {
+                __createdBy: "context-message"
+              }
+            }
+          });
+          return next();
+        },
+        { priority: 10 }
+      );
+    }
+  };
+}
+
+// src/extensions/message-window.ts
+function MessageWindow(config) {
+  return {
+    name: "message-window",
+    register(api) {
+      api.pipeline.register("step", async (ctx, next) => {
+        if (ctx.conversation.messages.length > config.maxMessages) {
+          ctx.conversation.emit({
+            type: "truncate",
+            keepLast: config.maxMessages
+          });
+        }
+        return next();
+      });
+    }
+  };
+}
+
+// src/extensions/compaction-summarize.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function CompactionSummarize(config) {
+  return {
+    name: "compaction-summarize",
+    register(api) {
+      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);
+          const summaryText = toRemove.map(
+            (m) => typeof m.data.content === "string" ? m.data.content : JSON.stringify(m.data.content)
+          ).join(" ");
+          for (const msg of toRemove) {
+            ctx.conversation.emit({ type: "remove", messageId: msg.id });
+          }
+          ctx.conversation.emit({
+            type: "append",
+            message: {
+              id: `summary-${randomUUID2()}`,
+              data: {
+                role: "system",
+                content: `[Summary of earlier conversation]: ${summaryText}`
+              },
+              metadata: {
+                __createdBy: "compaction-summarize"
+              }
+            }
+          });
+        }
+        return next();
+      });
+    }
+  };
+}
+
+// src/extensions/logging.ts
+function Logging(config) {
+  const log = config?.logger ?? console.log;
+  return {
+    name: "logging",
+    register(api) {
+      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)}`);
+      });
+    }
+  };
+}
+
+// src/extensions/tool-search.ts
+function ToolSearch() {
+  return {
+    name: "tool-search",
+    register(api) {
+      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"].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 };
+        }
+      });
+    }
+  };
+}
+
+// src/extensions/required-tools-guard.ts
+function RequiredToolsGuard(config) {
+  return {
+    name: "required-tools-guard",
+    register(api) {
+      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();
+      });
+    }
+  };
+}
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+function BashTool(config = {}) {
+  const { timeout = 3e4, 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, _ctx) {
+      const command = args["command"];
+      const cwd = args["cwd"];
+      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 });
+          }
+        });
+      });
+    }
+  };
+}
+
+// src/tools/file-system.ts
+import { readFile, writeFile, readdir } from "fs/promises";
+function FileReadTool() {
+  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, _ctx) {
+      const filePath = args["path"];
+      const encoding = args["encoding"] ?? "utf8";
+      try {
+        const content = await readFile(filePath, { encoding });
+        return { type: "text", text: content };
+      } catch (err) {
+        return { type: "error", error: err.message };
+      }
+    }
+  };
+}
+function FileWriteTool() {
+  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, _ctx) {
+      const filePath = args["path"];
+      const content = args["content"];
+      try {
+        await writeFile(filePath, content, "utf8");
+        return { type: "text", text: `File written: ${filePath}` };
+      } catch (err) {
+        return { type: "error", error: err.message };
+      }
+    }
+  };
+}
+function FileListTool() {
+  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, _ctx) {
+      const dirPath = args["path"];
+      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.message };
+      }
+    }
+  };
+}
+
+// src/tools/http-fetch.ts
+function HttpFetchTool() {
+  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, _ctx) {
+      const url = args["url"];
+      const method = args["method"] ?? "GET";
+      const headers = args["headers"] ?? {};
+      const body = args["body"];
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: body !== void 0 ? body : void 0
+        });
+        const responseHeaders = {};
+        response.headers.forEach((value, key) => {
+          responseHeaders[key] = value;
+        });
+        let responseBody;
+        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
+          }
+        };
+      } catch (err) {
+        return { type: "error", error: err.message };
+      }
+    }
+  };
+}
+
+// src/tools/json-query.ts
+function jsonQuery(data, path) {
+  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;
+  }
+  const segments = [];
+  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 = data;
+  for (const segment of segments) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current === "object") {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function JsonQueryTool() {
+  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, _ctx) {
+      const data = args["data"];
+      const path = args["path"];
+      try {
+        const result = jsonQuery(data, path);
+        return { type: "json", data: result };
+      } catch (err) {
+        return { type: "error", error: err.message };
+      }
+    }
+  };
+}
+
+// src/tools/text-transform.ts
+function TextTransformTool() {
+  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, _ctx) {
+      const text = args["text"];
+      const operation = args["operation"];
+      const options = args["options"] ?? {};
+      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.message };
+      }
+    }
+  };
+}
+
+// src/tools/wait.ts
+function WaitTool(config = {}) {
+  const { maxMs = 6e4 } = 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, ctx) {
+      const requestedMs = args["ms"];
+      const ms = Math.min(requestedMs, maxMs);
+      await new Promise((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` };
+    }
+  };
+}
+export {
+  BashTool,
+  CompactionSummarize,
+  ContextMessage,
+  FileListTool,
+  FileReadTool,
+  FileWriteTool,
+  HttpFetchTool,
+  JsonQueryTool,
+  Logging,
+  MessageWindow,
+  RequiredToolsGuard,
+  TextTransformTool,
+  ToolSearch,
+  WaitTool
+};

package/package.json

@@ -1,45 +1,23 @@
 {
   "name": "@goondan/openharness-base",
-  "version": "0.0.1-alpha4",
-  "description": "Barebone harness with reference tools and extensions",
+  "version": "2.0.0-alpha.1",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "homepage": "https://github.com/goondan/openharness#readme",
-  "bugs": {
-    "url": "https://github.com/goondan/openharness/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/goondan/openharness.git",
-    "directory": "packages/base"
-  },
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "keywords": [
-    "agent",
-    "extensions",
-    "harness",
-    "reference",
-    "tools"
-  ],
-  "publishConfig": {
-    "access": "public"
+    ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" }
   },
   "scripts": {
-    "build": "pnpm clean && tsc -p tsconfig.json && node ./build-manifest.mjs",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build": "tsup src/index.ts --format esm --dts",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@goondan/openharness-types": "^0.0.1-alpha4"
+    "@goondan/openharness-types": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
   }
 }