@tjamescouch/gro 1.3.6 → 1.3.7

package/src/session.ts

@@ -1,150 +0,0 @@
-import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { randomUUID } from "node:crypto";
-import type { ChatMessage } from "./drivers/types.js";
-import { Logger } from "./logger.js";
-import { groError, asError, errorLogFields } from "./errors.js";
-
-/**
- * Session persistence for gro.
- *
- * Layout:
- *   .gro/
- *     context/
- *       <session-id>/
- *         messages.json   — full message history
- *         meta.json       — session metadata (model, provider, timestamps)
- */
-
-export interface SessionMeta {
-  id: string;
-  provider: string;
-  model: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-const GRO_DIR = ".gro";
-const CONTEXT_DIR = "context";
-
-function groDir(): string {
-  return join(process.cwd(), GRO_DIR);
-}
-
-function contextDir(): string {
-  return join(groDir(), CONTEXT_DIR);
-}
-
-function sessionDir(id: string): string {
-  return join(contextDir(), id);
-}
-
-/**
- * Ensure the .gro/context directory exists.
- */
-export function ensureGroDir(): void {
-  const dir = contextDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-/**
- * Generate a new session ID (short UUID prefix for readability).
- */
-export function newSessionId(): string {
-  return randomUUID().split("-")[0];
-}
-
-/**
- * Save a session to disk.
- */
-export function saveSession(
-  id: string,
-  messages: ChatMessage[],
-  meta: Omit<SessionMeta, "updatedAt">,
-): void {
-  const dir = sessionDir(id);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-
-  const fullMeta: SessionMeta = {
-    ...meta,
-    updatedAt: new Date().toISOString(),
-  };
-
-  writeFileSync(join(dir, "messages.json"), JSON.stringify(messages, null, 2));
-  writeFileSync(join(dir, "meta.json"), JSON.stringify(fullMeta, null, 2));
-}
-
-/**
- * Load a session from disk. Returns null if not found.
- */
-export function loadSession(id: string): { messages: ChatMessage[]; meta: SessionMeta } | null {
-  const dir = sessionDir(id);
-  const msgPath = join(dir, "messages.json");
-  const metaPath = join(dir, "meta.json");
-
-  if (!existsSync(msgPath) || !existsSync(metaPath)) {
-    return null;
-  }
-
-  try {
-    const messages = JSON.parse(readFileSync(msgPath, "utf-8"));
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-    return { messages, meta };
-  } catch (e: unknown) {
-    const ge = groError("session_error", `Failed to load session ${id}: ${asError(e).message}`, { cause: e });
-    Logger.warn(ge.message, errorLogFields(ge));
-    return null;
-  }
-}
-
-/**
- * Find the most recent session (for --continue).
- */
-export function findLatestSession(): string | null {
-  const dir = contextDir();
-  if (!existsSync(dir)) return null;
-
-  let latest: { id: string; mtime: number } | null = null;
-
-  for (const entry of readdirSync(dir)) {
-    const metaPath = join(dir, entry, "meta.json");
-    if (existsSync(metaPath)) {
-      const stat = statSync(metaPath);
-      if (!latest || stat.mtimeMs > latest.mtime) {
-        latest = { id: entry, mtime: stat.mtimeMs };
-      }
-    }
-  }
-
-  return latest?.id ?? null;
-}
-
-/**
- * List all sessions, sorted by most recent first.
- */
-export function listSessions(): SessionMeta[] {
-  const dir = contextDir();
-  if (!existsSync(dir)) return [];
-
-  const sessions: (SessionMeta & { mtime: number })[] = [];
-
-  for (const entry of readdirSync(dir)) {
-    const metaPath = join(dir, entry, "meta.json");
-    if (existsSync(metaPath)) {
-      try {
-        const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-        const stat = statSync(metaPath);
-        sessions.push({ ...meta, mtime: stat.mtimeMs });
-      } catch {
-        // skip corrupt sessions
-      }
-    }
-  }
-
-  sessions.sort((a, b) => b.mtime - a.mtime);
-  return sessions.map(({ mtime: _, ...rest }) => rest);
-}

package/src/tools/agentpatch.ts

@@ -1,89 +0,0 @@
-/**
- * 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(): any {
-  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: string): string {
-  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: Record<string, any>): string {
-  const patch = (args.patch as string) || "";
-  if (!patch.trim()) return "Error: empty patch";
-
-  const timeout = (args.timeout as number) || 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: any) {
-    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/src/tools/bash.ts

@@ -1,61 +0,0 @@
-/**
- * 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(): any {
-  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: Record<string, any>): string {
-  const command = args.command as string;
-  if (!command) return "Error: no command provided";
-
-  const timeout = (args.timeout as number) || 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: any) {
-    // 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: string): string {
-  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/src/tools/version.ts

@@ -1,98 +0,0 @@
-/**
- * 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();
-
-interface GroRuntimeInfo {
-  runtime: "gro";
-  version: string;
-  provider: string;
-  model: string;
-  pid: number;
-  uptime_seconds: number;
-  node_version: string;
-  platform: string;
-  persistent: boolean;
-}
-
-/** Read version from package.json — single source of truth. */
-function readVersion(): string {
-  // In ESM, __dirname isn't available — derive from import.meta.url
-  let selfDir: string;
-  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(): string {
-  return GRO_VERSION;
-}
-
-export function groVersionToolDefinition(): any {
-  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: {
-  provider: string;
-  model: string;
-  persistent: boolean;
-}): string {
-  const info: GroRuntimeInfo = {
-    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/src/utils/rate-limiter.ts

@@ -1,60 +0,0 @@
-type LimiterState = {
-  nextAvailableMs: number;
-  tail: Promise<void>;
-};
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
-}
-
-class RateLimiter {
-  private states = new Map<string, LimiterState>();
-  private readonly now: () => number;
-
-  constructor(now?: () => number) {
-    this.now =
-      now ??
-      (() =>
-        typeof performance !== "undefined" && typeof performance.now === "function"
-          ? performance.now()
-          : Date.now());
-  }
-
-  async limit(name: string, throughputPerSecond: number): Promise<void> {
-    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?: string): void {
-    if (name) this.states.delete(name);
-    else this.states.clear();
-  }
-
-  private getState(name: string): LimiterState {
-    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/timed-fetch.ts

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