@cuylabs/agent-core 0.9.0 → 0.11.0

package/dist/chunk-FII65CN7.js

@@ -0,0 +1,117 @@
+// src/safety/patterns.ts
+function matchApprovalPattern(pattern, value) {
+  if (pattern.length > 500) return false;
+  const p = pattern.toLowerCase();
+  const v = value.toLowerCase();
+  let pi = 0;
+  let vi = 0;
+  let starPi = -1;
+  let starVi = -1;
+  while (vi < v.length) {
+    if (pi < p.length && (p[pi] === "?" || p[pi] === v[vi])) {
+      pi++;
+      vi++;
+    } else if (pi < p.length && p[pi] === "*") {
+      starPi = pi;
+      starVi = vi;
+      pi++;
+    } else if (starPi !== -1) {
+      pi = starPi + 1;
+      starVi++;
+      vi = starVi;
+    } else {
+      return false;
+    }
+  }
+  while (pi < p.length && p[pi] === "*") {
+    pi++;
+  }
+  return pi === p.length;
+}
+function extractApprovalPatterns(tool, args) {
+  if (!args || typeof args !== "object") {
+    return [tool];
+  }
+  const record = args;
+  if ("path" in record && typeof record.path === "string" || "filePath" in record && typeof record.filePath === "string") {
+    const path = record.path ?? record.filePath;
+    const dir = path.substring(0, path.lastIndexOf("/") + 1);
+    return [dir ? `${dir}*` : path];
+  }
+  if ("command" in record && typeof record.command === "string") {
+    const command = record.command.split(/\s+/)[0];
+    return [command];
+  }
+  if ("pattern" in record && typeof record.pattern === "string") {
+    return [record.pattern];
+  }
+  return [tool];
+}
+function describeApprovalOperation(tool, args) {
+  if (!args || typeof args !== "object") {
+    return `Execute ${tool}`;
+  }
+  const record = args;
+  switch (tool) {
+    case "read":
+    case "read_file":
+      return `Read file: ${record.path ?? record.filePath}`;
+    case "write":
+    case "write_file":
+    case "create_file":
+      return `Write file: ${record.path ?? record.filePath}`;
+    case "edit":
+    case "edit_file":
+      return `Edit file: ${record.path ?? record.filePath}`;
+    case "delete_file":
+    case "remove":
+      return `Delete: ${record.path}`;
+    case "bash":
+    case "shell": {
+      const command = String(record.command);
+      return `Run command: ${command.slice(0, 100)}${command.length > 100 ? "..." : ""}`;
+    }
+    case "grep":
+      return `Search for: ${record.pattern}`;
+    case "glob":
+      return `Find files: ${record.pattern}`;
+    default: {
+      const json = JSON.stringify(args);
+      const truncated = json.length > 50 ? `${json.slice(0, 50)}...` : json;
+      return `${tool}(${truncated})`;
+    }
+  }
+}
+
+// src/types/tool.ts
+function requiresToolHost(requirements) {
+  if (!requirements) return false;
+  if (requirements.required !== void 0) {
+    return requirements.required;
+  }
+  return requirements.filesystem !== void 0 && requirements.filesystem !== "none" ? true : requirements.shell === true;
+}
+function getRequiredToolHost(ctx, options = {}) {
+  if (ctx.host) {
+    return ctx.host;
+  }
+  const target = options.toolName ? `Tool "${options.toolName}"` : "This tool";
+  const usageSuffix = options.usage ? ` (${options.usage})` : "";
+  throw new Error(
+    `${target} requires an execution host${usageSuffix}, but none was configured.`
+  );
+}
+function resolveCapability(cap, input, fallback) {
+  if (cap === void 0) return fallback;
+  if (typeof cap === "function") return cap(input);
+  return cap;
+}
+
+export {
+  matchApprovalPattern,
+  extractApprovalPatterns,
+  describeApprovalOperation,
+  requiresToolHost,
+  getRequiredToolHost,
+  resolveCapability
+};

package/dist/{chunk-UHCJEM2E.js → chunk-ICZ66572.js}

@@ -2,9 +2,6 @@
 var STORAGE_VERSION = 1;
 
 // src/storage/utils.ts
-function logStorageWarning(message) {
-  console.warn(message);
-}
 function generateEntryId(existingIds) {
   for (let i = 0; i < 100; i++) {
     const id = crypto.randomUUID().slice(0, 8);
@@ -12,7 +9,7 @@ function generateEntryId(existingIds) {
   }
   return crypto.randomUUID();
 }
-function parseJSONL(content) {
+function parseJSONL(content, logger) {
   const entries = [];
   const lines = content.split("\n");
   for (const line of lines) {
@@ -21,7 +18,7 @@ function parseJSONL(content) {
     try {
       entries.push(JSON.parse(trimmed));
     } catch {
-      logStorageWarning("[Storage] Skipping malformed JSONL line");
+      logger?.warn("Skipping malformed JSONL line");
     }
   }
   return entries;
@@ -207,7 +204,7 @@ function buildMessagesFromEntries(entries, leafId) {
   for (const entry of path) {
     if (entry.type === "compaction") {
       messages.length = 0;
-      skipUntilId = entry.firstKeptEntryId;
+      skipUntilId = entry.firstKeptEntryId !== entry.id ? entry.firstKeptEntryId : void 0;
       messages.push({
         id: entry.id,
         role: "system",
@@ -294,6 +291,16 @@ async function ensureStorageDirectory(directory) {
 }
 function getSessionFilePath(directory, extension, sessionId) {
   const safeId = sessionId.replace(/[^a-zA-Z0-9-_]/g, "_");
+  const needsHash = safeId !== sessionId;
+  if (needsHash) {
+    let hash = 2166136261;
+    for (let i = 0; i < sessionId.length; i++) {
+      hash ^= sessionId.charCodeAt(i);
+      hash = hash * 16777619 >>> 0;
+    }
+    const suffix = hash.toString(16).padStart(8, "0");
+    return join(directory, `${safeId}_${suffix}${extension}`);
+  }
   return join(directory, `${safeId}${extension}`);
 }
 async function loadEntriesFromDisk(filePath, sessionId) {

package/dist/chunk-KYLPMBHD.js

@@ -0,0 +1,316 @@
+import {
+  Tool
+} from "./chunk-Q742PSH3.js";
+
+// src/tool/registry.ts
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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());
+  }
+  // --------------------------------------------------------------------------
+  // Deferred loading
+  // --------------------------------------------------------------------------
+  /**
+   * Partition registered tools into eager and deferred sets.
+   *
+   * Eager tools have their full schemas sent to the LLM on turn 1.
+   * Deferred tools are held back — the model discovers them via a
+   * search mechanism when needed, saving context window space.
+   *
+   * @returns `{ eager, deferred }` arrays of tool infos.
+   */
+  partition() {
+    const eager = [];
+    const deferred = [];
+    for (const tool of this.tools.values()) {
+      if (tool.deferred) {
+        deferred.push(tool);
+      } else {
+        eager.push(tool);
+      }
+    }
+    return { eager, deferred };
+  }
+  /**
+   * Search deferred tools by keyword with multi-signal weighted scoring.
+   *
+   * Scoring per term:
+   *  - Exact tool ID match: +10
+   *  - Partial tool ID match (substring): +5
+   *  - Keyword word-boundary match: +4
+   *  - Keyword substring match: +2
+   *
+   * @param query - Space-separated search terms
+   * @param maxResults - Maximum results to return (default: 5)
+   * @returns Matching deferred tools sorted by relevance (highest score first)
+   */
+  searchDeferred(query, maxResults = 5) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0) return [];
+    const { deferred } = this.partition();
+    const scored = deferred.map((tool) => {
+      let score = 0;
+      const id = tool.id.toLowerCase();
+      const keywords = (tool.searchKeywords ?? []).join(" ").toLowerCase();
+      for (const term of terms) {
+        if (id === term) {
+          score += 10;
+          continue;
+        }
+        if (id.includes(term)) {
+          score += 5;
+          continue;
+        }
+        const wordBoundary = new RegExp(`\\b${escapeRegExp(term)}\\b`);
+        if (wordBoundary.test(keywords)) {
+          score += 4;
+          continue;
+        }
+        if (keywords.includes(term)) {
+          score += 2;
+        }
+      }
+      return { tool, score };
+    }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults).map(({ tool }) => tool);
+  }
+  // --------------------------------------------------------------------------
+  // 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();
+
+// src/tool/tool-search.ts
+import { z } from "zod";
+function createToolSearchTool(options) {
+  const { registry, maxResults = 5, onMatch } = options;
+  return Tool.define("tool_search", {
+    description: "Search for additional tools by keyword. Some tools are not loaded by default to save context. Call this when you need a capability that isn't available in your current tool set. Returns matching tool names and descriptions.",
+    parameters: z.object({
+      query: z.string().describe(
+        "Space-separated keywords describing the tool you need (e.g. 'jupyter notebook cells' or 'docker container'). Use 'select:tool_name' to load a specific tool by name, or 'select:foo,bar' for multiple."
+      )
+    }),
+    capabilities: {
+      parallelSafe: true,
+      readOnly: true,
+      riskLevel: "safe"
+    },
+    execute: async ({ query }, ctx) => {
+      if (query.startsWith("select:")) {
+        const ids = query.slice(7).split(",").map((s) => s.trim()).filter(Boolean);
+        const found = [];
+        const missing = [];
+        for (const id of ids) {
+          const tool = registry.get(id);
+          if (tool) {
+            found.push(tool);
+          } else {
+            missing.push(id);
+          }
+        }
+        if (found.length > 0) onMatch(found);
+        const summaries2 = [];
+        for (const t of found) {
+          try {
+            const init = await t.init({ cwd: ctx.cwd });
+            summaries2.push(`- **${t.id}**: ${init.description}`);
+          } catch {
+            summaries2.push(`- **${t.id}**: (description unavailable)`);
+          }
+        }
+        if (missing.length > 0) {
+          summaries2.push(`
+Not found: ${missing.join(", ")}`);
+        }
+        return {
+          title: `Loaded ${found.length} tool(s)`,
+          output: found.length > 0 ? summaries2.join("\n") + "\n\nThese tools are now available for use." : `No tools found: ${missing.join(", ")}`,
+          metadata: {
+            matchCount: found.length,
+            toolIds: found.map((t) => t.id)
+          }
+        };
+      }
+      const matches = registry.searchDeferred(query, maxResults);
+      if (matches.length === 0) {
+        return {
+          title: `No tools found for "${query}"`,
+          output: `No matching tools found for query: "${query}". Try different keywords.`,
+          metadata: { matchCount: 0, toolIds: [] }
+        };
+      }
+      const summaries = [];
+      for (const tool of matches) {
+        try {
+          const init = await tool.init({ cwd: ctx.cwd });
+          summaries.push(`- **${tool.id}**: ${init.description}`);
+        } catch {
+          summaries.push(`- **${tool.id}**: (description unavailable)`);
+        }
+      }
+      onMatch(matches);
+      return {
+        title: `Found ${matches.length} tool(s)`,
+        output: `Found ${matches.length} tool(s) matching "${query}":
+
+` + summaries.join("\n") + "\n\nThese tools are now available for use.",
+        metadata: {
+          matchCount: matches.length,
+          toolIds: matches.map((t) => t.id)
+        }
+      };
+    }
+  });
+}
+
+export {
+  ToolRegistry,
+  defaultRegistry,
+  createToolSearchTool
+};