@agentv/core 2.11.0 → 2.11.1

package/dist/index.cjs

@@ -2032,9 +2032,14 @@ async function loadConfig(evalFilePath, repoRoot) {
         logWarning(`Invalid eval_patterns in ${configPath}, all entries must be strings`);
         continue;
       }
+      const executionDefaults = parseExecutionDefaults(
+        parsed.execution,
+        configPath
+      );
       return {
         guideline_patterns: guidelinePatterns,
-        eval_patterns: evalPatterns
+        eval_patterns: evalPatterns,
+        execution: executionDefaults
       };
     } catch (error) {
       logWarning(
@@ -2175,6 +2180,36 @@ function extractTotalBudgetUsd(suite) {
   );
   return void 0;
 }
+function parseExecutionDefaults(raw, configPath) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  const obj = raw;
+  const result = {};
+  if (typeof obj.verbose === "boolean") {
+    result.verbose = obj.verbose;
+  } else if (obj.verbose !== void 0) {
+    logWarning(`Invalid execution.verbose in ${configPath}, expected boolean`);
+  }
+  const traceFile = obj.trace_file;
+  if (typeof traceFile === "string" && traceFile.trim().length > 0) {
+    result.trace_file = traceFile.trim();
+  } else if (traceFile !== void 0) {
+    logWarning(`Invalid execution.trace_file in ${configPath}, expected non-empty string`);
+  }
+  if (typeof obj.keep_workspaces === "boolean") {
+    result.keep_workspaces = obj.keep_workspaces;
+  } else if (obj.keep_workspaces !== void 0) {
+    logWarning(`Invalid execution.keep_workspaces in ${configPath}, expected boolean`);
+  }
+  const otelFile = obj.otel_file;
+  if (typeof otelFile === "string" && otelFile.trim().length > 0) {
+    result.otel_file = otelFile.trim();
+  } else if (otelFile !== void 0) {
+    logWarning(`Invalid execution.otel_file in ${configPath}, expected non-empty string`);
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
 function logWarning(message) {
   console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET2}`);
 }
@@ -7027,6 +7062,16 @@ var CopilotCliProvider = class {
       }
       const endTime = (/* @__PURE__ */ new Date()).toISOString();
       const durationMs = Date.now() - startMs;
+      const rejectedCalls = completedToolCalls.filter((tc) => {
+        const out = tc.output;
+        return out && (out.code === "rejected" || out.code === "denied");
+      });
+      if (rejectedCalls.length > 0) {
+        const tools = rejectedCalls.map((tc) => tc.tool).join(", ");
+        throw new Error(
+          `Copilot rejected ${rejectedCalls.length} tool call(s): ${tools}. Add args: ["--yolo"] to your target config or re-run with --yolo to bypass permission checks.`
+        );
+      }
       const outputMessages = [];
       if (completedToolCalls.length > 0) {
         outputMessages.push({
@@ -7059,7 +7104,7 @@ var CopilotCliProvider = class {
     }
   }
   buildCliArgs() {
-    const args = ["--acp", "--stdio", "--allow-all-tools"];
+    const args = ["--acp", "--stdio", "--allow-all-tools", "--yolo"];
     if (this.config.model) {
       args.push("--model", this.config.model);
     }
@@ -15467,7 +15512,7 @@ var RepoManager = class {
    * Creates on first access, fetches updates on subsequent calls.
    * Returns the absolute path to the cache directory.
    */
-  async ensureCache(source) {
+  async ensureCache(source, depth) {
     const key = cacheKey(source);
     const cachePath = import_node_path38.default.join(this.cacheDir, key);
     const lockPath = `${cachePath}.lock`;
@@ -15475,9 +15520,20 @@ var RepoManager = class {
     await acquireLock(lockPath);
     try {
       if ((0, import_node_fs11.existsSync)(import_node_path38.default.join(cachePath, "HEAD"))) {
-        await git(["fetch", "--prune"], { cwd: cachePath });
+        const fetchArgs = ["fetch", "--prune"];
+        if (depth) {
+          fetchArgs.push("--depth", String(depth));
+        }
+        await git(fetchArgs, { cwd: cachePath });
       } else {
-        await git(["clone", "--mirror", "--bare", getSourceUrl(source), cachePath]);
+        const cloneArgs = ["clone", "--mirror", "--bare"];
+        if (depth) {
+          cloneArgs.push("--depth", String(depth));
+        }
+        const sourceUrl = getSourceUrl(source);
+        const cloneUrl = depth && source.type === "local" ? `file://${sourceUrl}` : sourceUrl;
+        cloneArgs.push(cloneUrl, cachePath);
+        await git(cloneArgs);
       }
     } finally {
       await releaseLock(lockPath);
@@ -15490,7 +15546,7 @@ var RepoManager = class {
    */
   async materialize(repo, workspacePath) {
     const targetDir = import_node_path38.default.join(workspacePath, repo.path);
-    const cachePath = await this.ensureCache(repo.source);
+    const cachePath = await this.ensureCache(repo.source, repo.clone?.depth);
     const cloneArgs = ["clone"];
     if (repo.clone?.depth) {
       cloneArgs.push("--depth", String(repo.clone.depth));
@@ -15566,6 +15622,33 @@ var RepoManager = class {
       await git(["clean", "-fd"], { cwd: targetDir });
     }
   }
+  /**
+   * Seed the cache from a local repository, setting the remote to a given URL.
+   * Useful for avoiding slow network clones when a local clone already exists.
+   */
+  async seedCache(localPath, remoteUrl, opts) {
+    const source = { type: "git", url: remoteUrl };
+    const key = cacheKey(source);
+    const cachePath = import_node_path38.default.join(this.cacheDir, key);
+    const lockPath = `${cachePath}.lock`;
+    await (0, import_promises27.mkdir)(this.cacheDir, { recursive: true });
+    await acquireLock(lockPath);
+    try {
+      if ((0, import_node_fs11.existsSync)(import_node_path38.default.join(cachePath, "HEAD"))) {
+        if (!opts?.force) {
+          throw new Error(
+            `Cache already exists for ${remoteUrl} at ${cachePath}. Use force to overwrite.`
+          );
+        }
+        await (0, import_promises27.rm)(cachePath, { recursive: true, force: true });
+      }
+      await git(["clone", "--mirror", "--bare", localPath, cachePath]);
+      await git(["remote", "set-url", "origin", remoteUrl], { cwd: cachePath });
+    } finally {
+      await releaseLock(lockPath);
+    }
+    return cachePath;
+  }
   /** Remove the entire cache directory. */
   async cleanCache() {
     await (0, import_promises27.rm)(this.cacheDir, { recursive: true, force: true });