@cuylabs/agent-core 0.9.0 → 0.10.0

package/dist/chunk-SDSBEQXG.js

@@ -1,157 +0,0 @@
-// src/tool/registry.ts
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  groups = /* @__PURE__ */ new Map();
-  // --------------------------------------------------------------------------
-  // Tool registration
-  // --------------------------------------------------------------------------
-  /**
-   * Register a tool. Throws if a tool with the same ID is already registered.
-   * Use `set()` for upsert semantics.
-   */
-  register(tool) {
-    if (this.tools.has(tool.id)) {
-      throw new Error(`Tool '${tool.id}' is already registered`);
-    }
-    this.tools.set(tool.id, tool);
-  }
-  /** Register multiple tools (throws on duplicates). */
-  registerAll(tools) {
-    for (const tool of tools) {
-      this.register(tool);
-    }
-  }
-  /** Register or replace a tool (upsert). */
-  set(tool) {
-    this.tools.set(tool.id, tool);
-  }
-  /** Unregister a tool by ID. Returns `true` if it existed. */
-  unregister(id) {
-    return this.tools.delete(id);
-  }
-  /** Get a tool by ID. */
-  get(id) {
-    return this.tools.get(id);
-  }
-  /** Check if a tool is registered. */
-  has(id) {
-    return this.tools.has(id);
-  }
-  /** Get all tool IDs. */
-  ids() {
-    return Array.from(this.tools.keys());
-  }
-  /** Get all tools. */
-  all() {
-    return Array.from(this.tools.values());
-  }
-  /** Clear all tools and groups. */
-  clear() {
-    this.tools.clear();
-    this.groups.clear();
-  }
-  /** Number of registered tools. */
-  get size() {
-    return this.tools.size;
-  }
-  // --------------------------------------------------------------------------
-  // Group management
-  // --------------------------------------------------------------------------
-  /**
-   * Register a named group of tool IDs.
-   * The group name can be used in `resolve()` specs.
-   * Tool IDs don't need to be registered yet — resolution is lazy.
-   */
-  registerGroup(name, toolIds) {
-    this.groups.set(name, toolIds);
-  }
-  /** Get tools in a group (only returns registered tools). */
-  getGroup(name) {
-    const ids = this.groups.get(name);
-    if (!ids) return void 0;
-    return ids.map((id) => this.tools.get(id)).filter((t) => t !== void 0);
-  }
-  /** Check if a group is registered. */
-  hasGroup(name) {
-    return this.groups.has(name);
-  }
-  /** List all group names. */
-  listGroups() {
-    return Array.from(this.groups.keys());
-  }
-  // --------------------------------------------------------------------------
-  // Resolution
-  // --------------------------------------------------------------------------
-  /**
-   * Resolve a `ToolSpec` to an array of tools.
-   *
-   * Supports group names, individual tool IDs, comma-separated strings,
-   * exclusions with `-` prefix, booleans, and pass-through arrays.
-   *
-   * @example
-   * ```typescript
-   * registry.resolve("read-only");          // group name
-   * registry.resolve("read,grep,glob");     // comma-separated IDs
-   * registry.resolve("all,-bash");          // all except bash
-   * registry.resolve(["read", "grep"]);     // array of IDs
-   * registry.resolve(true);                 // all registered tools
-   * registry.resolve(false);                // empty array
-   * ```
-   */
-  resolve(spec) {
-    if (spec === true) return this.all();
-    if (spec === false) return [];
-    if (Array.isArray(spec) && spec.length > 0 && typeof spec[0] !== "string") {
-      return spec;
-    }
-    const tokens = Array.isArray(spec) ? spec : spec.split(",").map((s) => s.trim()).filter(Boolean);
-    const includes = [];
-    const excludes = [];
-    for (const token of tokens) {
-      if (token.startsWith("-")) {
-        excludes.push(token.slice(1));
-      } else {
-        includes.push(token);
-      }
-    }
-    const result = /* @__PURE__ */ new Map();
-    if (includes.length === 0 && excludes.length > 0) {
-      for (const [id, tool] of this.tools) {
-        result.set(id, tool);
-      }
-    } else {
-      for (const token of includes) {
-        if (token === "all") {
-          for (const [id, tool] of this.tools) {
-            result.set(id, tool);
-          }
-        } else if (this.groups.has(token)) {
-          const ids = this.groups.get(token);
-          for (const id of ids) {
-            const tool = this.tools.get(id);
-            if (tool) result.set(id, tool);
-          }
-        } else if (this.tools.has(token)) {
-          result.set(token, this.tools.get(token));
-        }
-      }
-    }
-    for (const id of excludes) {
-      if (this.groups.has(id)) {
-        const ids = this.groups.get(id);
-        for (const gid of ids) {
-          result.delete(gid);
-        }
-      } else {
-        result.delete(id);
-      }
-    }
-    return Array.from(result.values());
-  }
-};
-var defaultRegistry = new ToolRegistry();
-
-export {
-  ToolRegistry,
-  defaultRegistry
-};

package/dist/chunk-VEKUXUVF.js

@@ -1,41 +0,0 @@
-// src/tracking/file-tracking.ts
-function extractFilePathsFromArgs(args, meta) {
-  if (!meta.pathArgs || meta.pathArgs.length === 0) {
-    return [];
-  }
-  const paths = [];
-  for (const argName of meta.pathArgs) {
-    const value = args[argName];
-    if (typeof value === "string") {
-      paths.push(value);
-    } else if (Array.isArray(value)) {
-      for (const item of value) {
-        if (typeof item === "string") {
-          paths.push(item);
-        }
-      }
-    }
-  }
-  return paths;
-}
-function shouldCaptureBaseline(meta) {
-  return meta.operationType !== "read";
-}
-function withFileTracking(tracker, meta, execute) {
-  return (async (...args) => {
-    const params = args[0];
-    if (params && shouldCaptureBaseline(meta)) {
-      const paths = extractFilePathsFromArgs(params, meta);
-      for (const path of paths) {
-        await tracker.beforeWrite(path);
-      }
-    }
-    return await execute(...args);
-  });
-}
-
-export {
-  extractFilePathsFromArgs,
-  shouldCaptureBaseline,
-  withFileTracking
-};

package/dist/chunk-VNQBHPCT.js

@@ -1,398 +0,0 @@
-// src/host/local.ts
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import { existsSync } from "fs";
-import path from "path";
-import process from "process";
-function getShell() {
-  if (process.platform === "win32") {
-    return { shell: "cmd.exe", args: ["/c"] };
-  }
-  const userShell = process.env.SHELL ?? "/bin/bash";
-  return { shell: userShell, args: ["-c"] };
-}
-async function killProcessTree(pid) {
-  try {
-    if (process.platform !== "win32") {
-      process.kill(-pid, "SIGKILL");
-    } else {
-      const { exec: execCb } = await import("child_process");
-      execCb(`taskkill /pid ${pid} /t /f`, () => {
-      });
-    }
-  } catch {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-function localHost(defaultCwd) {
-  const cwd = defaultCwd ?? process.cwd();
-  return {
-    name: "local",
-    // --------------------------------------------------------------------------
-    // File system
-    // --------------------------------------------------------------------------
-    async readFile(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return fs.readFile(abs, "utf-8");
-    },
-    async readBytes(filePath, offset, length) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const fh = await fs.open(abs, "r");
-      try {
-        const buf = Buffer.alloc(length);
-        await fh.read(buf, 0, length, offset);
-        return buf;
-      } finally {
-        await fh.close();
-      }
-    },
-    async writeFile(filePath, content) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      await fs.mkdir(path.dirname(abs), { recursive: true });
-      await fs.writeFile(abs, content, "utf-8");
-    },
-    async exists(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return existsSync(abs);
-    },
-    async stat(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const s = await fs.stat(abs);
-      return {
-        size: s.size,
-        mtime: s.mtime,
-        isDirectory: s.isDirectory(),
-        isFile: s.isFile()
-      };
-    },
-    async readdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      const entries = await fs.readdir(abs, { withFileTypes: true });
-      return entries.map((e) => ({
-        name: e.name,
-        isDirectory: e.isDirectory(),
-        isFile: e.isFile()
-      }));
-    },
-    async mkdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      await fs.mkdir(abs, { recursive: true });
-    },
-    // --------------------------------------------------------------------------
-    // Process execution
-    // --------------------------------------------------------------------------
-    exec(command, options) {
-      const { shell, args } = getShell();
-      const execCwd = options?.cwd ?? cwd;
-      const env = {
-        ...process.env,
-        ...options?.env,
-        // Disable pagers — tools collect output, not interactive
-        PAGER: "cat",
-        GIT_PAGER: "cat"
-      };
-      return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let settled = false;
-        const child = spawn(shell, [...args, command], {
-          cwd: execCwd,
-          detached: process.platform !== "win32",
-          env,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        child.stdout?.on("data", (data) => {
-          stdout += data.toString();
-          options?.onStdout?.(data);
-        });
-        child.stderr?.on("data", (data) => {
-          stderr += data.toString();
-          options?.onStderr?.(data);
-        });
-        let timer;
-        if (options?.timeout && options.timeout > 0) {
-          timer = setTimeout(() => {
-            timedOut = true;
-            if (child.pid) killProcessTree(child.pid);
-          }, options.timeout);
-        }
-        const onAbort = () => {
-          if (child.pid) killProcessTree(child.pid);
-        };
-        options?.signal?.addEventListener("abort", onAbort, { once: true });
-        child.on("close", (code) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          resolve({ stdout, stderr, exitCode: code, timedOut });
-        });
-        child.on("error", (err) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          reject(err);
-        });
-      });
-    }
-  };
-}
-
-// src/host/docker/exec.ts
-async function loadDockerode() {
-  try {
-    const module = await import("dockerode");
-    return module.default ?? module;
-  } catch {
-    throw new Error(
-      "dockerHost requires the 'dockerode' package. Install it with: npm install dockerode"
-    );
-  }
-}
-async function resolveDockerRuntime(options) {
-  const Dockerode = await loadDockerode();
-  if (typeof options.container === "string") {
-    const docker = new Dockerode(options.dockerOptions);
-    const container2 = docker.getContainer(options.container);
-    return {
-      docker,
-      container: container2,
-      label: options.container
-    };
-  }
-  const container = options.container;
-  return {
-    docker: { modem: container.modem },
-    container,
-    label: container.id?.slice(0, 12) ?? "unknown"
-  };
-}
-async function containerExec(runtime, command, options = {}) {
-  const envEntries = options.env ? Object.entries(options.env).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${value}`) : void 0;
-  const exec = await runtime.container.exec({
-    Cmd: ["sh", "-c", command],
-    ...options.user ? { User: options.user } : {},
-    ...options.workdir ? { WorkingDir: options.workdir } : {},
-    ...envEntries && envEntries.length > 0 ? { Env: envEntries } : {},
-    AttachStdout: true,
-    AttachStderr: true
-  });
-  const stream = await exec.start({});
-  let timedOut = false;
-  let aborted = false;
-  return await new Promise((resolve, reject) => {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    runtime.docker.modem.demuxStream(
-      stream,
-      {
-        write: (chunk) => {
-          stdoutChunks.push(chunk);
-          options.onStdout?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      },
-      {
-        write: (chunk) => {
-          stderrChunks.push(chunk);
-          options.onStderr?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      }
-    );
-    let timer;
-    if (options.timeout && options.timeout > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        stream.destroy?.();
-      }, options.timeout);
-    }
-    const onAbort = () => {
-      aborted = true;
-      stream.destroy?.();
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    stream.on("end", async () => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      try {
-        const info = await exec.inspect();
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
-          timedOut
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-    stream.on("error", (error) => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      if (timedOut || aborted) {
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: null,
-          timedOut
-        });
-        return;
-      }
-      reject(error);
-    });
-  });
-}
-async function runDockerCommand(options) {
-  const { runtime, command, defaultUser, defaultWorkdir, execOptions } = options;
-  return await containerExec(runtime, command, {
-    user: defaultUser,
-    workdir: execOptions?.workdir ?? execOptions?.cwd ?? defaultWorkdir,
-    env: execOptions?.env,
-    timeout: execOptions?.timeout,
-    signal: execOptions?.signal,
-    onStdout: execOptions?.onStdout,
-    onStderr: execOptions?.onStderr
-  });
-}
-
-// src/host/docker/shell.ts
-function sq(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function resolveDockerPath(path2, defaultWorkdir) {
-  if (path2.startsWith("/")) {
-    return path2;
-  }
-  const base = defaultWorkdir.endsWith("/") ? defaultWorkdir : `${defaultWorkdir}/`;
-  return `${base}${path2}`;
-}
-
-// src/host/docker/host.ts
-async function dockerHost(options) {
-  const runtime = await resolveDockerRuntime(options);
-  const defaultUser = options.user;
-  const defaultWorkdir = options.workdir ?? "/";
-  async function run(command, execOptions) {
-    return await runDockerCommand({
-      runtime,
-      command,
-      defaultUser,
-      defaultWorkdir,
-      execOptions
-    });
-  }
-  return {
-    name: `docker:${runtime.label}`,
-    async readFile(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`cat ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`readFile failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      return result.stdout;
-    },
-    async readBytes(filePath, offset, length) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `dd if=${sq(absPath)} bs=1 skip=${offset} count=${length} 2>/dev/null`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readBytes failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return Buffer.from(result.stdout, "binary");
-    },
-    async writeFile(filePath, content) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const dir = absPath.substring(0, absPath.lastIndexOf("/")) || "/";
-      await run(`mkdir -p ${sq(dir)}`);
-      const encoded = Buffer.from(content, "utf-8").toString("base64");
-      const result = await run(`echo ${sq(encoded)} | base64 -d > ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `writeFile failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-    },
-    async exists(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`test -e ${sq(absPath)}`);
-      return result.exitCode === 0;
-    },
-    async stat(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `stat -c '%s %Y %F' ${sq(absPath)} 2>/dev/null || stat -f '%z %m %HT' ${sq(absPath)}`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(`stat failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      const parts = result.stdout.trim().split(/\s+/);
-      if (parts.length < 3) {
-        throw new Error(
-          `stat: unexpected output format for ${absPath}: ${result.stdout}`
-        );
-      }
-      const size = parseInt(parts[0], 10);
-      const mtimeSec = parseInt(parts[1], 10);
-      const typeStr = parts.slice(2).join(" ").toLowerCase();
-      return {
-        size,
-        mtime: new Date(mtimeSec * 1e3),
-        isDirectory: typeStr.includes("directory"),
-        isFile: typeStr.includes("regular") || typeStr.includes("file")
-      };
-    },
-    async readdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(
-        `find ${sq(absPath)} -maxdepth 1 -mindepth 1 -printf '%f\\t%y\\n' 2>/dev/null || for f in ${sq(absPath)}/*; do [ -e "$f" ] || continue; n=$(basename "$f"); if [ -d "$f" ]; then printf '%s\\td\\n' "$n"; else printf '%s\\tf\\n' "$n"; fi; done`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readdir failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
-        const [name, type] = line.split("	");
-        return {
-          name,
-          isDirectory: type === "d",
-          isFile: type === "f"
-        };
-      });
-    },
-    async mkdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(`mkdir -p ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`mkdir failed (${absPath}): ${result.stderr.trim()}`);
-      }
-    },
-    async exec(command, execOptions) {
-      return await run(command, execOptions);
-    }
-  };
-}
-
-export {
-  localHost,
-  dockerHost
-};