@tjamescouch/gro 1.3.5 → 1.3.7

package/dist/tools/agentpatch.js

@@ -0,0 +1,91 @@
+/**
+ * agentpatch tool integration for gro.
+ *
+ * Exposes a first-class file editor: `apply_patch`.
+ *
+ * This wraps the agentpatch patch grammar and applies patches via the
+ * `agentpatch/bin/apply_patch` script.
+ */
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Logger } from "../logger.js";
+const DEFAULT_TIMEOUT = 120_000;
+const MAX_OUTPUT = 30_000;
+export function agentpatchToolDefinition() {
+    return {
+        type: "function",
+        function: {
+            name: "apply_patch",
+            description: "Apply a unified agentpatch-style patch to the working tree (safe, idempotent).",
+            parameters: {
+                type: "object",
+                properties: {
+                    patch: { type: "string", description: "The patch text (agentpatch grammar)." },
+                    dry_run: { type: "boolean", description: "If true, validate/preview without writing." },
+                    verbose: { type: "boolean", description: "If true, emit debug logs from applier." },
+                    allow_delete: { type: "boolean", description: "Allow *** Delete File ops." },
+                    allow_rename: { type: "boolean", description: "Allow *** Rename File ops." },
+                    timeout: { type: "number", description: "Timeout in ms (default 120000)." },
+                },
+                required: ["patch"],
+            },
+        },
+    };
+}
+function truncate(s) {
+    if (s.length <= MAX_OUTPUT)
+        return s;
+    const half = Math.floor(MAX_OUTPUT / 2);
+    return s.slice(0, half) + `\n\n... (truncated ${s.length - MAX_OUTPUT} chars) ...\n\n` + s.slice(-half);
+}
+export function executeAgentpatch(args) {
+    const patch = args.patch || "";
+    if (!patch.trim())
+        return "Error: empty patch";
+    const timeout = args.timeout || DEFAULT_TIMEOUT;
+    const dryRun = args.dry_run === true;
+    const verbose = args.verbose === true;
+    const allowDelete = args.allow_delete === true;
+    const allowRename = args.allow_rename === true;
+    // Expected layout in this monorepo-ish runner: /home/agent/agentpatch
+    // If not present, instruct user to clone it.
+    const agentpatchPath = process.env.AGENTPATCH_PATH || join(process.env.HOME || "", "agentpatch");
+    const bin = join(agentpatchPath, "bin", "apply_patch");
+    if (!existsSync(bin)) {
+        return `Error: agentpatch not found at ${bin}. Set AGENTPATCH_PATH or clone agentpatch to ~/agentpatch.`;
+    }
+    const cmd = [bin];
+    if (dryRun)
+        cmd.push("--dry-run");
+    if (verbose)
+        cmd.push("--verbose");
+    if (allowDelete)
+        cmd.push("--allow-delete");
+    if (allowRename)
+        cmd.push("--allow-rename");
+    Logger.debug(`apply_patch: ${cmd.join(" ")}`);
+    try {
+        const out = execSync(cmd.join(" "), {
+            shell: "/bin/bash",
+            input: patch,
+            encoding: "utf-8",
+            timeout,
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return truncate(out || "ok");
+    }
+    catch (e) {
+        let result = "";
+        if (e.stdout)
+            result += e.stdout;
+        if (e.stderr)
+            result += (result ? "\n" : "") + e.stderr;
+        if (!result)
+            result = e.message || "Command failed";
+        if (e.status != null)
+            result += `\n[exit code: ${e.status}]`;
+        return truncate(result);
+    }
+}

package/dist/tools/bash.js

@@ -0,0 +1,61 @@
+/**
+ * Built-in bash tool for gro — executes shell commands and returns output.
+ * Gated behind --bash flag. Not enabled by default.
+ */
+import { execSync } from "node:child_process";
+import { Logger } from "../logger.js";
+const MAX_OUTPUT = 30_000;
+const DEFAULT_TIMEOUT = 120_000;
+export function bashToolDefinition() {
+    return {
+        type: "function",
+        function: {
+            name: "bash",
+            description: "Execute a bash command and return its output (stdout + stderr).",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "The bash command to execute" },
+                    timeout: { type: "number", description: "Timeout in milliseconds (default: 120000)" },
+                },
+                required: ["command"],
+            },
+        },
+    };
+}
+export function executeBash(args) {
+    const command = args.command;
+    if (!command)
+        return "Error: no command provided";
+    const timeout = args.timeout || DEFAULT_TIMEOUT;
+    Logger.debug(`bash: ${command}`);
+    try {
+        const output = execSync(command, {
+            shell: "/bin/bash",
+            encoding: "utf-8",
+            timeout,
+            maxBuffer: 10 * 1024 * 1024,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return truncate(output);
+    }
+    catch (e) {
+        // execSync throws on non-zero exit — capture stdout + stderr
+        let result = "";
+        if (e.stdout)
+            result += e.stdout;
+        if (e.stderr)
+            result += (result ? "\n" : "") + e.stderr;
+        if (!result)
+            result = e.message || "Command failed";
+        if (e.status != null)
+            result += `\n[exit code: ${e.status}]`;
+        return truncate(result);
+    }
+}
+function truncate(s) {
+    if (s.length <= MAX_OUTPUT)
+        return s;
+    const half = Math.floor(MAX_OUTPUT / 2);
+    return s.slice(0, half) + `\n\n... (truncated ${s.length - MAX_OUTPUT} chars) ...\n\n` + s.slice(-half);
+}

package/dist/tools/version.js

@@ -0,0 +1,76 @@
+/**
+ * Built-in version/identity tool for gro.
+ *
+ * Lets agents (and humans) introspect the gro runtime — version, provider,
+ * model, uptime, process info. This is the canonical way to confirm an
+ * agent is running on gro.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const startTime = Date.now();
+/** Read version from package.json — single source of truth. */
+function readVersion() {
+    // In ESM, __dirname isn't available — derive from import.meta.url
+    let selfDir;
+    try {
+        selfDir = dirname(fileURLToPath(import.meta.url));
+    }
+    catch {
+        selfDir = process.cwd();
+    }
+    const candidates = [
+        join(selfDir, "..", "package.json"), // from dist/tools/ or src/tools/
+        join(selfDir, "..", "..", "package.json"), // from deeper nesting
+        join(process.cwd(), "package.json"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                const pkg = JSON.parse(readFileSync(p, "utf-8"));
+                if (pkg.name === "@tjamescouch/gro" && pkg.version) {
+                    return pkg.version;
+                }
+            }
+            catch {
+                // try next candidate
+            }
+        }
+    }
+    return "unknown";
+}
+// Cache version at module load
+const GRO_VERSION = readVersion();
+export function getGroVersion() {
+    return GRO_VERSION;
+}
+export function groVersionToolDefinition() {
+    return {
+        type: "function",
+        function: {
+            name: "gro_version",
+            description: "Report gro runtime identity and version. Returns runtime name, version, provider, model, uptime, and process info. Use this to confirm an agent is running on gro.",
+            parameters: {
+                type: "object",
+                properties: {},
+            },
+        },
+    };
+}
+/**
+ * Execute the version tool. Requires runtime config to report provider/model.
+ */
+export function executeGroVersion(cfg) {
+    const info = {
+        runtime: "gro",
+        version: GRO_VERSION,
+        provider: cfg.provider,
+        model: cfg.model,
+        pid: process.pid,
+        uptime_seconds: Math.floor((Date.now() - startTime) / 1000),
+        node_version: process.version,
+        platform: process.platform,
+        persistent: cfg.persistent,
+    };
+    return JSON.stringify(info, null, 2);
+}

package/dist/utils/rate-limiter.js

@@ -0,0 +1,46 @@
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+class RateLimiter {
+    constructor(now) {
+        this.states = new Map();
+        this.now =
+            now ??
+                (() => typeof performance !== "undefined" && typeof performance.now === "function"
+                    ? performance.now()
+                    : Date.now());
+    }
+    async limit(name, throughputPerSecond) {
+        if (!Number.isFinite(throughputPerSecond) || throughputPerSecond <= 0) {
+            throw new RangeError(`throughputPerSecond must be a positive finite number; got ${throughputPerSecond}`);
+        }
+        const key = name || "default";
+        const state = this.getState(key);
+        const waitPromise = state.tail.then(async () => {
+            const intervalMs = 1000 / throughputPerSecond;
+            const now = this.now();
+            const scheduledAt = Math.max(now, state.nextAvailableMs);
+            state.nextAvailableMs = scheduledAt + intervalMs;
+            const delay = scheduledAt - now;
+            if (delay > 0)
+                await sleep(delay);
+        });
+        state.tail = waitPromise.catch(() => { });
+        return waitPromise;
+    }
+    reset(name) {
+        if (name)
+            this.states.delete(name);
+        else
+            this.states.clear();
+    }
+    getState(name) {
+        let s = this.states.get(name);
+        if (!s) {
+            s = { nextAvailableMs: this.now(), tail: Promise.resolve() };
+            this.states.set(name, s);
+        }
+        return s;
+    }
+}
+export const rateLimiter = new RateLimiter();

package/{src/utils/retry.ts → dist/utils/retry.js}

@@ -3,30 +3,26 @@
  *
  * Shared between Anthropic and OpenAI drivers to avoid duplication.
  */
-
 export const MAX_RETRIES = 3;
 export const RETRY_BASE_MS = 1000;
-
 /**
  * Check if an HTTP status code is retryable.
  * 429 = rate limited, 502/503 = upstream error, 529 = overloaded.
  */
-export function isRetryable(status: number): boolean {
-  return status === 429 || status === 502 || status === 503 || status === 529;
+export function isRetryable(status) {
+    return status === 429 || status === 502 || status === 503 || status === 529;
 }
-
 /**
  * Calculate retry delay with exponential backoff + jitter.
  * attempt 0 → base 1s + 0-0.5s jitter
  * attempt 1 → base 2s + 0-1s jitter
  * attempt 2 → base 4s + 0-2s jitter
  */
-export function retryDelay(attempt: number): number {
-  const base = RETRY_BASE_MS * Math.pow(2, attempt);
-  const jitter = Math.random() * base * 0.5;
-  return base + jitter;
+export function retryDelay(attempt) {
+    const base = RETRY_BASE_MS * Math.pow(2, attempt);
+    const jitter = Math.random() * base * 0.5;
+    return base + jitter;
 }
-
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/utils/timed-fetch.js

@@ -0,0 +1,25 @@
+import { asError } from "../errors.js";
+/** Wrap fetch with timeout and location context for debugging. */
+export async function timedFetch(url, init = {}) {
+    const { timeoutMs, where, ...rest } = init;
+    let controller = null;
+    let timer = null;
+    try {
+        if (timeoutMs && timeoutMs > 0) {
+            controller = new AbortController();
+            rest.signal = controller.signal;
+            timer = setTimeout(() => controller.abort(), timeoutMs);
+        }
+        return await fetch(url, rest);
+    }
+    catch (e) {
+        const wrapped = asError(e);
+        const err = new Error(`[fetch timeout] ${where ?? ""} ${url} -> ${wrapped.name}: ${wrapped.message}`);
+        err.cause = e;
+        throw err;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/package.json

@@ -1,11 +1,22 @@
 {
   "name": "@tjamescouch/gro",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "Provider-agnostic LLM runtime with context management",
+  "bin": {
+    "gro": "./dist/main.js"
+  },
+  "files": [
+    "dist/",
+    "gro",
+    "providers/",
+    "_base.md",
+    "owl"
+  ],
   "type": "module",
   "scripts": {
     "start": "npx tsx src/main.ts",
-    "build": "npx tsc && cp package.json dist/",
+    "build": "npx tsc && chmod +x dist/main.js",
+    "prepublishOnly": "npm run build",
     "build:bun": "bun build src/main.ts --outdir dist --target bun",
     "test": "npx tsx --test tests/*.test.ts",
     "test:bun": "bun test"

package/.github/workflows/ci.yml

@@ -1,20 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches: [main]
-  push:
-    branches: [main]
-
-jobs:
-  ci:
-    name: Build & Test
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-      - run: bun install
-      - run: bun run build
-      - run: bun test

package/src/drivers/anthropic.ts

@@ -1,281 +0,0 @@
-/**
- * Anthropic Messages API driver.
- * Direct HTTP — no SDK dependency.
- */
-import { Logger } from "../logger.js";
-import { rateLimiter } from "../utils/rate-limiter.js";
-import { timedFetch } from "../utils/timed-fetch.js";
-import { MAX_RETRIES, isRetryable, retryDelay, sleep } from "../utils/retry.js";
-import { groError, asError, isGroError, errorLogFields } from "../errors.js";
-import type { ChatDriver, ChatMessage, ChatOutput, ChatToolCall, TokenUsage } from "./types.js";
-
-export interface AnthropicDriverConfig {
-  apiKey: string;
-  baseUrl?: string;
-  model?: string;
-  maxTokens?: number;
-  timeoutMs?: number;
-}
-
-/**
- * Convert tool definitions from OpenAI format to Anthropic format.
- * OpenAI: { type: "function", function: { name, description, parameters } }
- * Anthropic: { name, description, input_schema }
- */
-function convertToolDefs(tools: any[]): any[] {
-  return tools.map(t => {
-    if (t.type === "function" && t.function) {
-      return {
-        type: "custom",
-        name: t.function.name,
-        description: t.function.description || "",
-        input_schema: t.function.parameters || { type: "object", properties: {} },
-      };
-    }
-    // Already in Anthropic format — ensure type is set
-    if (!t.type) return { type: "custom", ...t };
-    return t;
-  });
-}
-
-/**
- * Convert internal messages (OpenAI-style) to Anthropic Messages API format.
- *
- * Key differences:
- * - Assistant tool calls become content blocks with type "tool_use"
- * - Tool result messages become user messages with type "tool_result" content blocks
- * - Anthropic requires strictly alternating user/assistant roles
- */
-function convertMessages(messages: ChatMessage[]): { system: string | undefined; apiMessages: any[] } {
-  let systemPrompt: string | undefined;
-  const apiMessages: any[] = [];
-
-  for (const m of messages) {
-    if (m.role === "system") {
-      systemPrompt = systemPrompt ? systemPrompt + "\n" + m.content : m.content;
-      continue;
-    }
-
-    if (m.role === "assistant") {
-      const content: any[] = [];
-      if (m.content) content.push({ type: "text", text: m.content });
-
-      // Convert OpenAI-style tool_calls to Anthropic tool_use blocks
-      const toolCalls = (m as any).tool_calls;
-      if (Array.isArray(toolCalls)) {
-        for (const tc of toolCalls) {
-          let input: any;
-          try { input = JSON.parse(tc.function.arguments || "{}"); } catch { input = {}; }
-          content.push({
-            type: "tool_use",
-            id: tc.id,
-            name: tc.function.name,
-            input,
-          });
-        }
-      }
-
-      if (content.length > 0) {
-        apiMessages.push({ role: "assistant", content });
-      }
-      continue;
-    }
-
-    if (m.role === "tool") {
-      // Tool results must be in a user message with tool_result content blocks
-      const block = {
-        type: "tool_result",
-        tool_use_id: m.tool_call_id,
-        content: m.content,
-      };
-
-      // Group consecutive tool results into a single user message
-      const last = apiMessages[apiMessages.length - 1];
-      if (last && last.role === "user" && Array.isArray(last.content) &&
-          last.content.length > 0 && last.content[0].type === "tool_result") {
-        last.content.push(block);
-      } else {
-        apiMessages.push({ role: "user", content: [block] });
-      }
-      continue;
-    }
-
-    // Regular user messages
-    apiMessages.push({ role: "user", content: m.content });
-  }
-
-  return { system: systemPrompt, apiMessages };
-}
-
-/** Pattern matching transient network errors that should be retried */
-const TRANSIENT_ERROR_RE = /fetch timeout|fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENETUNREACH|EAI_AGAIN|socket hang up/i;
-
-/** Parse response content blocks into text + tool calls + token usage */
-function parseResponseContent(data: any, onToken?: (t: string) => void): ChatOutput {
-  let text = "";
-  const toolCalls: ChatToolCall[] = [];
-
-  for (const block of data.content ?? []) {
-    if (block.type === "text") {
-      text += block.text;
-      if (onToken) {
-        try { onToken(block.text); } catch {}
-      }
-    } else if (block.type === "tool_use") {
-      toolCalls.push({
-        id: block.id,
-        type: "custom",
-        function: {
-          name: block.name,
-          arguments: JSON.stringify(block.input),
-        },
-      });
-    }
-  }
-
-  const usage: TokenUsage | undefined = data.usage ? {
-    inputTokens: data.usage.input_tokens ?? 0,
-    outputTokens: data.usage.output_tokens ?? 0,
-  } : undefined;
-
-  return { text, toolCalls, usage };
-}
-
-export function makeAnthropicDriver(cfg: AnthropicDriverConfig): ChatDriver {
-  const base = (cfg.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
-  const endpoint = `${base}/v1/messages`;
-  const model = cfg.model ?? "claude-sonnet-4-20250514";
-  const maxTokens = cfg.maxTokens ?? 4096;
-  const timeoutMs = cfg.timeoutMs ?? 2 * 60 * 60 * 1000;
-
-  async function chat(messages: ChatMessage[], opts?: any): Promise<ChatOutput> {
-    await rateLimiter.limit("llm-ask", 1);
-
-    const onToken: ((t: string) => void) | undefined = opts?.onToken;
-    const resolvedModel = opts?.model ?? model;
-
-    const { system: systemPrompt, apiMessages } = convertMessages(messages);
-
-    const body: any = {
-      model: resolvedModel,
-      thinking: {
-        type: "adaptive"
-      },
-      max_tokens: maxTokens,
-      messages: apiMessages,
-    };
-    if (systemPrompt) body.system = systemPrompt;
-
-    // Tools support — convert from OpenAI format to Anthropic format
-    if (Array.isArray(opts?.tools) && opts.tools.length) {
-      body.tools = convertToolDefs(opts.tools);
-    }
-
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      "x-api-key": cfg.apiKey,
-      "anthropic-version": "2023-06-01",
-    };
-
-    const RETRYABLE_STATUS = new Set([429, 503, 529]);
-    let requestId: string | undefined;
-
-    try {
-      let res!: Response;
-      for (let attempt = 0; ; attempt++) {
-        res = await timedFetch(endpoint, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(body),
-          where: "driver:anthropic",
-          timeoutMs,
-        });
-
-        if (res.ok) break;
-
-        if (isRetryable(res.status) && attempt < MAX_RETRIES) {
-          const delay = retryDelay(attempt);
-          Logger.warn(`Anthropic ${res.status}, retry ${attempt + 1}/${MAX_RETRIES} in ${Math.round(delay)}ms`);
-          await sleep(delay);
-          continue;
-        }
-
-        const text = await res.text().catch(() => "");
-        const ge = groError("provider_error", `Anthropic API failed (${res.status}): ${text}`, {
-          provider: "anthropic",
-          model: resolvedModel,
-          request_id: requestId,
-          retryable: RETRYABLE_STATUS.has(res.status),
-          cause: new Error(text),
-        });
-        Logger.error("Anthropic driver error:", errorLogFields(ge));
-        throw ge;
-      }
-
-      const data = await res.json() as any;
-      return parseResponseContent(data, onToken);
-    } catch (e: unknown) {
-      if (isGroError(e)) throw e; // already wrapped above
-
-      // Classify the error: fetch timeouts and network errors are transient
-      const errMsg = asError(e).message;
-      const isTransient = TRANSIENT_ERROR_RE.test(errMsg);
-
-      if (isTransient) {
-        // Retry transient network errors (e.g. auth proxy down during container restart)
-        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-          const delay = retryDelay(attempt);
-          Logger.warn(`Transient error: ${errMsg.substring(0, 120)}, retry ${attempt + 1}/${MAX_RETRIES} in ${Math.round(delay)}ms`);
-          await sleep(delay);
-
-          try {
-            const retryRes = await timedFetch(endpoint, {
-              method: "POST",
-              headers,
-              body: JSON.stringify(body),
-              where: "driver:anthropic",
-              timeoutMs,
-            });
-
-            if (!retryRes.ok) {
-              const text = await retryRes.text().catch(() => "");
-              if (isRetryable(retryRes.status) && attempt < MAX_RETRIES - 1) continue;
-              throw groError("provider_error", `Anthropic API failed (${retryRes.status}): ${text}`, {
-                provider: "anthropic", model: resolvedModel, retryable: false, cause: new Error(text),
-              });
-            }
-
-            // Success on retry — parse and return
-            const data = await retryRes.json() as any;
-            Logger.info(`Recovered from transient error after ${attempt + 1} retries`);
-            return parseResponseContent(data, onToken);
-          } catch (retryErr: unknown) {
-            if (isGroError(retryErr)) throw retryErr;
-            if (attempt === MAX_RETRIES - 1) {
-              // Exhausted retries — throw with context
-              const ge = groError("provider_error", `Anthropic driver error (after ${MAX_RETRIES} retries): ${errMsg}`, {
-                provider: "anthropic", model: resolvedModel, request_id: requestId,
-                retryable: false, cause: e,
-              });
-              Logger.error("Anthropic driver error (retries exhausted):", errorLogFields(ge));
-              throw ge;
-            }
-          }
-        }
-      }
-
-      // Non-transient error — throw immediately
-      const ge = groError("provider_error", `Anthropic driver error: ${errMsg}`, {
-        provider: "anthropic",
-        model: resolvedModel,
-        request_id: requestId,
-        retryable: false,
-        cause: e,
-      });
-      Logger.error("Anthropic driver error:", errorLogFields(ge));
-      throw ge;
-    }
-  }
-
-  return { chat };
-}

package/src/drivers/index.ts

@@ -1,5 +0,0 @@
-export type { ChatDriver, ChatMessage, ChatOutput, ChatToolCall, TokenUsage } from "./types.js";
-export { makeStreamingOpenAiDriver } from "./streaming-openai.js";
-export type { OpenAiDriverConfig } from "./streaming-openai.js";
-export { makeAnthropicDriver } from "./anthropic.js";
-export type { AnthropicDriverConfig } from "./anthropic.js";