@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/chunk-7VKQ4WPB.js

@@ -0,0 +1,73 @@
+import {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline
+} from "./chunk-VEKUXUVF.js";
+import {
+  snapshotScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
+
+// src/tool/executor.ts
+async function executeAgentToolCall(options) {
+  return withinScope(
+    {
+      kind: "tool",
+      name: "tool-call",
+      sessionId: options.sessionID,
+      attributes: {
+        toolName: options.toolName,
+        messageId: options.messageID,
+        agent: options.agent ?? "default"
+      }
+    },
+    async () => {
+      const initialized = await options.tool.init({ cwd: options.cwd });
+      const ctx = {
+        cwd: options.cwd,
+        abort: options.abort,
+        sessionID: options.sessionID,
+        messageID: options.messageID,
+        agent: options.agent ?? "default",
+        scope: snapshotScope(),
+        ...options.host ? { host: options.host } : {},
+        ...options.turnTracker ? { turnTracker: options.turnTracker } : {}
+      };
+      if (options.middleware?.hasMiddleware) {
+        const decision = await options.middleware.runBeforeToolCall(
+          options.toolName,
+          options.params,
+          ctx
+        );
+        if (decision.action === "deny") {
+          return {
+            output: decision.reason ?? `Tool call denied: ${options.toolName}`
+          };
+        }
+      }
+      if (options.turnTracker && initialized.fileOps && shouldCaptureBaseline(initialized.fileOps)) {
+        const paths = extractFilePathsFromArgs(
+          options.params,
+          initialized.fileOps
+        );
+        for (const path of paths) {
+          await options.turnTracker.beforeWrite(path);
+        }
+      }
+      const result = await initialized.execute(options.params, ctx);
+      if (options.middleware?.hasMiddleware) {
+        const transformed = await options.middleware.runAfterToolCall(
+          options.toolName,
+          options.params,
+          result,
+          ctx
+        );
+        return { output: transformed.output };
+      }
+      return { output: result.output };
+    }
+  );
+}
+
+export {
+  executeAgentToolCall
+};

package/dist/chunk-BFM2YHNM.js

@@ -0,0 +1,222 @@
+// src/safety/approval/risk.ts
+var DEFAULT_TOOL_RISKS = {
+  read: "safe",
+  read_file: "safe",
+  grep: "safe",
+  glob: "safe",
+  list_dir: "safe",
+  plan: "safe",
+  invoke_agent: "safe",
+  wait_agent: "safe",
+  close_agent: "safe",
+  skill: "safe",
+  skill_resource: "safe",
+  write: "moderate",
+  write_file: "moderate",
+  edit: "moderate",
+  edit_file: "moderate",
+  create_file: "moderate",
+  bash: "dangerous",
+  shell: "dangerous",
+  delete_file: "dangerous",
+  remove: "dangerous"
+};
+function getToolRisk(tool, customRisks) {
+  if (customRisks?.[tool]) {
+    return customRisks[tool];
+  }
+  if (DEFAULT_TOOL_RISKS[tool]) {
+    return DEFAULT_TOOL_RISKS[tool];
+  }
+  return "moderate";
+}
+
+// src/safety/approval/errors.ts
+var ApprovalDeniedError = class extends Error {
+  constructor(tool, args, message) {
+    super(message || `Operation denied: ${tool}`);
+    this.tool = tool;
+    this.args = args;
+    this.name = "ApprovalDeniedError";
+  }
+};
+var ApprovalTimeoutError = class extends Error {
+  constructor(tool, timeoutMs) {
+    super(`Approval timeout after ${timeoutMs}ms for: ${tool}`);
+    this.tool = tool;
+    this.timeoutMs = timeoutMs;
+    this.name = "ApprovalTimeoutError";
+  }
+};
+
+// src/safety/approval/patterns.ts
+function matchApprovalPattern(pattern, value) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regex}$`, "i").test(value);
+}
+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:
+      return `${tool}(${JSON.stringify(args).slice(0, 50)}...)`;
+  }
+}
+
+// src/safety/approval/handler.ts
+var requestCounter = 0;
+function findMatchingRule(rules, tool, patterns) {
+  for (let index = rules.length - 1; index >= 0; index--) {
+    const rule = rules[index];
+    const toolMatches = rule.tool === "*" || matchApprovalPattern(rule.tool, tool);
+    const patternMatches = patterns.some(
+      (pattern) => matchApprovalPattern(rule.pattern, pattern)
+    );
+    if (toolMatches && patternMatches) {
+      return rule;
+    }
+  }
+  return void 0;
+}
+function createApprovalHandler(config = {}) {
+  const {
+    defaultAction = "ask",
+    timeout = 5 * 60 * 1e3,
+    onRequest
+  } = config;
+  const rules = [...config.rules ?? []];
+  const pending = /* @__PURE__ */ new Map();
+  async function request(sessionId, tool, args, customRisks) {
+    const risk = getToolRisk(tool, customRisks);
+    const patterns = extractApprovalPatterns(tool, args);
+    const matchingRule = findMatchingRule(rules, tool, patterns);
+    if (matchingRule) {
+      if (matchingRule.action === "allow") {
+        return;
+      }
+      throw new ApprovalDeniedError(
+        tool,
+        args,
+        `Denied by rule: ${matchingRule.pattern}`
+      );
+    }
+    if (risk === "safe" && defaultAction !== "deny") {
+      return;
+    }
+    if (!onRequest) {
+      if (defaultAction === "allow") {
+        return;
+      }
+      if (defaultAction === "deny") {
+        throw new ApprovalDeniedError(tool, args);
+      }
+      throw new ApprovalDeniedError(tool, args, "No approval handler configured");
+    }
+    const id = `approval-${++requestCounter}-${Date.now()}`;
+    const requestData = {
+      id,
+      sessionId,
+      tool,
+      args,
+      description: describeApprovalOperation(tool, args),
+      risk,
+      patterns,
+      timestamp: Date.now()
+    };
+    const action = await Promise.race([
+      new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        onRequest(requestData).then(resolve).catch(reject).finally(() => pending.delete(id));
+      }),
+      new Promise((_, reject) => {
+        setTimeout(() => {
+          pending.delete(id);
+          reject(new ApprovalTimeoutError(tool, timeout));
+        }, timeout);
+      })
+    ]);
+    switch (action) {
+      case "allow":
+        return;
+      case "deny":
+        throw new ApprovalDeniedError(tool, args);
+      case "remember":
+        for (const pattern of patterns) {
+          rules.push({ pattern, tool, action: "allow" });
+        }
+        return;
+    }
+  }
+  function cancelAll(reason) {
+    for (const [id, { reject }] of pending) {
+      reject(new Error(reason ?? "Cancelled"));
+      pending.delete(id);
+    }
+  }
+  function addRule(rule) {
+    rules.push(rule);
+  }
+  function getRules() {
+    return rules;
+  }
+  function clearSessionRules() {
+    rules.length = config.rules?.length ?? 0;
+  }
+  return {
+    request,
+    cancelAll,
+    addRule,
+    getRules,
+    clearSessionRules
+  };
+}
+
+export {
+  getToolRisk,
+  ApprovalDeniedError,
+  ApprovalTimeoutError,
+  createApprovalHandler
+};

package/dist/chunk-CAA7FHIH.js

@@ -0,0 +1,280 @@
+// src/presets/patterns.ts
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+function matchesPatterns(id, patterns) {
+  return patterns.some((pattern) => globToRegex(pattern).test(id));
+}
+function filterTools(tools, options) {
+  const allowPatterns = options.allow ?? [];
+  const denyPatterns = options.deny ?? [];
+  return tools.filter((tool) => {
+    const matchesAllow = allowPatterns.length === 0 || matchesPatterns(tool.id, allowPatterns);
+    if (!matchesAllow) {
+      return false;
+    }
+    const matchesDeny = denyPatterns.length > 0 && matchesPatterns(tool.id, denyPatterns);
+    if (matchesDeny && allowPatterns.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+
+// src/presets/apply.ts
+function applyPreset(preset, availableTools, baseSystemPrompt) {
+  const tools = filterTools(availableTools, {
+    allow: preset.allowTools,
+    deny: preset.denyTools
+  });
+  let systemPrompt = preset.systemPrompt;
+  if (systemPrompt && baseSystemPrompt) {
+    systemPrompt = systemPrompt.replace("{basePrompt}", baseSystemPrompt);
+  }
+  return {
+    name: preset.name,
+    systemPrompt,
+    tools: tools.length > 0 ? tools : void 0,
+    temperature: preset.temperature,
+    maxSteps: preset.maxSteps,
+    reasoningLevel: preset.reasoningLevel,
+    model: preset.model
+  };
+}
+function mergePresets(...presets) {
+  if (presets.length === 0) {
+    throw new Error("mergePresets requires at least one preset");
+  }
+  if (presets.length === 1) {
+    return presets[0];
+  }
+  const [first, ...rest] = presets;
+  const allAllow = [];
+  const allDeny = [];
+  for (const preset of presets) {
+    if (preset.allowTools?.length) {
+      allAllow.push(preset.allowTools);
+    }
+    if (preset.denyTools?.length) {
+      allDeny.push(...preset.denyTools);
+    }
+  }
+  const combinedAllow = allAllow.length > 0 ? allAllow.reduce(
+    (left, right) => left.length <= right.length ? left : right
+  ) : void 0;
+  return {
+    name: presets.map((preset) => preset.name).join("+"),
+    description: presets.map((preset) => preset.description).join(" | "),
+    allowTools: combinedAllow,
+    denyTools: allDeny.length > 0 ? [...new Set(allDeny)] : void 0,
+    systemPrompt: rest.reduce(
+      (value, preset) => preset.systemPrompt ?? value,
+      first.systemPrompt
+    ),
+    temperature: rest.reduce(
+      (value, preset) => preset.temperature ?? value,
+      first.temperature
+    ),
+    maxSteps: rest.reduce(
+      (value, preset) => preset.maxSteps ?? value,
+      first.maxSteps
+    ),
+    reasoningLevel: rest.reduce(
+      (value, preset) => preset.reasoningLevel ?? value,
+      first.reasoningLevel
+    ),
+    model: rest.reduce((value, preset) => preset.model ?? value, first.model)
+  };
+}
+function createPreset(options) {
+  return {
+    description: options.description ?? `Custom preset: ${options.name}`,
+    ...options
+  };
+}
+
+// src/presets/builtins.ts
+var explore = {
+  name: "explore",
+  description: "Read-only exploration mode for understanding content",
+  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
+  systemPrompt: `{basePrompt}
+
+## EXPLORATION MODE
+
+You are in **exploration mode**. Your goal is to thoroughly understand the content.
+
+Guidelines:
+- **Always start with glob or grep to discover correct paths** \u2014 never assume directory structure
+- Use search and read tools extensively to build understanding
+- Map out structures, dependencies, and patterns
+- Look for conventions, common patterns, and documentation
+- DO NOT modify anything \u2014 only read and analyse
+- Summarise findings clearly with references to specific locations
+
+Error recovery:
+- If a tool returns an error (ENOENT, not found, etc.), try a different path or approach
+- Use glob with broader patterns to discover the correct location
+- Keep going until you have a thorough answer \u2014 do not give up after one failure
+- You have multiple steps available \u2014 use them all if needed`,
+  temperature: 0.3,
+  maxSteps: 30
+};
+var plan = {
+  name: "plan",
+  description: "Planning mode for analyzing tasks and creating detailed plans",
+  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
+  systemPrompt: `{basePrompt}
+
+## PLANNING MODE
+
+You are in **planning mode**. Your goal is to analyze and plan before implementation.
+
+Guidelines:
+- Analyse the task requirements thoroughly
+- Research existing patterns and conventions
+- Identify potential impacts and dependencies
+- Create a clear, step-by-step implementation plan
+- DO NOT implement anything \u2014 only plan and document
+- Output a numbered list of specific, actionable steps`,
+  temperature: 0.2,
+  maxSteps: 20
+};
+var review = {
+  name: "review",
+  description: "Thorough review and analysis mode",
+  allowTools: ["read*", "grep*", "search*", "glob*", "list*"],
+  denyTools: ["*"],
+  systemPrompt: `{basePrompt}
+
+## REVIEW MODE
+
+You are in **review mode**. Your goal is to perform a thorough analysis.
+
+Review checklist:
+- [ ] Logic errors and edge cases
+- [ ] Security vulnerabilities
+- [ ] Performance issues
+- [ ] Error handling and recovery
+- [ ] Clarity and maintainability
+- [ ] Coverage gaps
+
+Guidelines:
+- Be thorough and systematic
+- Cite specific locations and details
+- Explain WHY something is an issue
+- Suggest concrete fixes
+- Rate severity: Critical / High / Medium / Low`,
+  temperature: 0.1,
+  maxSteps: 25
+};
+var quick = {
+  name: "quick",
+  description: "Fast mode for simple questions and quick operations",
+  systemPrompt: `{basePrompt}
+
+## QUICK MODE
+
+You are in **quick mode**. Be fast and focused.
+
+Guidelines:
+- Answer directly without lengthy explanations
+- Use minimal tool calls (1-3 max)
+- If you can't answer quickly, say so
+- Prioritize speed over thoroughness`,
+  temperature: 0,
+  maxSteps: 5
+};
+var careful = {
+  name: "careful",
+  description: "Extra cautious mode for sensitive operations",
+  denyTools: ["bash*", "exec*", "run*", "delete*", "remove*"],
+  systemPrompt: `{basePrompt}
+
+## CAREFUL MODE
+
+You are in **careful mode**. Every action must be verified.
+
+Guidelines:
+- Double-check before any file modifications
+- Explain what you're about to do BEFORE doing it
+- Prefer smaller, incremental changes
+- Always verify changes after making them
+- If uncertain, ask for clarification rather than guessing`,
+  temperature: 0,
+  maxSteps: 50
+};
+var code = {
+  name: "code",
+  description: "Full-power implementation mode for writing and modifying code",
+  systemPrompt: `{basePrompt}
+
+## IMPLEMENTATION MODE
+
+You are a focused **implementation agent**. Your goal is to complete the assigned task fully and correctly.
+
+Guidelines:
+- Read existing code first to understand context and conventions before making changes
+- Follow the project's existing patterns, naming conventions, and style
+- Make minimal, targeted changes \u2014 do not refactor unrelated code
+- Verify your work: re-read modified files, run tests or lint if available
+- If the task requires multiple files, handle them systematically one at a time
+
+Error recovery:
+- If a command fails, read the error output carefully and fix the root cause
+- If a test fails, read the failure details and iterate until it passes
+- If you cannot find a file, use glob or grep to discover the correct path
+- Keep iterating until the task is DONE \u2014 do not stop at a partial solution
+- You have many steps available \u2014 use them all if needed`,
+  temperature: 0,
+  maxSteps: 50
+};
+var watch = {
+  name: "watch",
+  description: "Process monitoring mode for running and watching long commands",
+  allowTools: ["bash*", "exec*", "run*", "read*", "grep*", "glob*", "list*", "find*"],
+  denyTools: ["write*", "edit*", "delete*", "remove*"],
+  systemPrompt: `{basePrompt}
+
+## WATCH MODE
+
+You are a **process monitor**. Your goal is to execute a command, observe its output, and report the result.
+
+Guidelines:
+- Run the command as given \u2014 do not modify or "improve" it
+- Wait for completion and capture the full output
+- Parse the output for success/failure status, error counts, warnings
+- Report a clear summary: what ran, whether it passed, key details
+- If the process fails, include the relevant error output verbatim
+- Do NOT attempt to fix issues \u2014 only observe and report`,
+  temperature: 0,
+  maxSteps: 10,
+  reasoningLevel: "low"
+};
+var Presets = {
+  explore,
+  plan,
+  review,
+  quick,
+  careful,
+  code,
+  watch
+};
+
+export {
+  filterTools,
+  applyPreset,
+  mergePresets,
+  createPreset,
+  explore,
+  plan,
+  review,
+  quick,
+  careful,
+  code,
+  watch,
+  Presets
+};

package/dist/chunk-KUVSERLJ.js

@@ -0,0 +1,50 @@
+// src/signal/local.ts
+var LocalSignal = class {
+  /** type → Set<handler> for typed subscriptions */
+  typed = /* @__PURE__ */ new Map();
+  /** handlers that receive every event */
+  wildcard = /* @__PURE__ */ new Set();
+  on(type, handler) {
+    let set = this.typed.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.typed.set(type, set);
+    }
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+      if (set.size === 0) this.typed.delete(type);
+    };
+  }
+  onAny(handler) {
+    this.wildcard.add(handler);
+    return () => {
+      this.wildcard.delete(handler);
+    };
+  }
+  emit(event) {
+    const set = this.typed.get(event.type);
+    if (set) {
+      for (const fn of set) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+    for (const fn of this.wildcard) {
+      try {
+        fn(event);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.typed.clear();
+    this.wildcard.clear();
+  }
+};
+
+export {
+  LocalSignal
+};