zidane 1.3.1 → 1.4.0

package/dist/{chunk-SWS5624X.js → chunk-YCH7G7YC.js}

@@ -2,11 +2,108 @@ import {
   connectMcpServers,
   init_mcp
 } from "./chunk-26LIQARN.js";
+import {
+  buildCatalog,
+  init_catalog,
+  init_interpolate,
+  init_resolve,
+  interpolateShellCommands,
+  mergeSkillsConfig,
+  resolveSkills
+} from "./chunk-PRNQ7DXE.js";
 import {
   __esm,
-  __export
+  __export,
+  __toCommonJS
 } from "./chunk-PNKVD2UK.js";
 
+// src/tools/list-files.ts
+var listFiles;
+var init_list_files = __esm({
+  "src/tools/list-files.ts"() {
+    "use strict";
+    listFiles = {
+      spec: {
+        name: "list_files",
+        description: "List files and directories at the given path (relative to project root).",
+        input_schema: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: 'Relative directory path (default: ".")' }
+          },
+          required: []
+        }
+      },
+      async execute({ path }, ctx) {
+        try {
+          const entries = await ctx.execution.listFiles(ctx.handle, path || ".");
+          return entries.join("\n") || "(empty directory)";
+        } catch {
+          return `Directory not found: ${path}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/read-file.ts
+var readFile;
+var init_read_file = __esm({
+  "src/tools/read-file.ts"() {
+    "use strict";
+    readFile = {
+      spec: {
+        name: "read_file",
+        description: "Read the contents of a file at the given path (relative to project root).",
+        input_schema: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "Relative file path" }
+          },
+          required: ["path"]
+        }
+      },
+      async execute({ path }, ctx) {
+        try {
+          return await ctx.execution.readFile(ctx.handle, path);
+        } catch {
+          return `File not found: ${path}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/shell.ts
+var shell;
+var init_shell = __esm({
+  "src/tools/shell.ts"() {
+    "use strict";
+    shell = {
+      spec: {
+        name: "shell",
+        description: "Execute a shell command and return stdout+stderr. Runs in the project root.",
+        input_schema: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "The shell command to run" }
+          },
+          required: ["command"]
+        }
+      },
+      async execute({ command }, ctx) {
+        const result = await ctx.execution.exec(ctx.handle, command);
+        if (result.exitCode === 0) {
+          return result.stdout || "(no output)";
+        }
+        return `Exit code ${result.exitCode}
+${result.stdout}
+${result.stderr}`.trim();
+      }
+    };
+  }
+});
+
 // src/contexts/docker.ts
 function createDockerContext(config) {
   let counter = 0;
@@ -35,16 +132,16 @@ function createDockerContext(config) {
       const docker = await getDockerode();
       const id = `docker-${++counter}`;
       const image = overrides?.image ?? defaultImage;
-      const cwd5 = overrides?.cwd ?? defaultCwd;
+      const cwd = overrides?.cwd ?? defaultCwd;
       try {
         await docker.getImage(image).inspect();
       } catch {
-        await new Promise((resolve5, reject) => {
+        await new Promise((resolve2, reject) => {
           docker.pull(image, (err, stream) => {
             if (err)
               return reject(err);
             docker.modem.followProgress(stream, (err2) => {
-              err2 ? reject(err2) : resolve5();
+              err2 ? reject(err2) : resolve2();
             });
           });
         });
@@ -61,12 +158,12 @@ function createDockerContext(config) {
       const container = await docker.createContainer({
         Image: image,
         Cmd: ["sleep", "infinity"],
-        WorkingDir: cwd5,
+        WorkingDir: cwd,
         Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
         HostConfig: hostConfig
       });
       await container.start();
-      const handle = { id, type: "docker", cwd: cwd5 };
+      const handle = { id, type: "docker", cwd };
       containers.set(id, { handle, container, docker });
       return handle;
     },
@@ -84,12 +181,12 @@ function createDockerContext(config) {
         AttachStderr: true
       });
       const stream = await exec.start({ Detach: false });
-      return new Promise((resolve5) => {
+      return new Promise((resolve2) => {
         let stdout = "";
         const stderr = "";
         const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30;
         const timer = setTimeout(() => {
-          resolve5({ stdout, stderr: `${stderr}
+          resolve2({ stdout, stderr: `${stderr}
 [timeout]`, exitCode: 124 });
         }, timeout * 1e3);
         stream.on("data", (chunk) => {
@@ -98,7 +195,7 @@ function createDockerContext(config) {
         stream.on("end", async () => {
           clearTimeout(timer);
           const inspect = await exec.inspect();
-          resolve5({ stdout, stderr, exitCode: inspect.ExitCode ?? 0 });
+          resolve2({ stdout, stderr, exitCode: inspect.ExitCode ?? 0 });
         });
       });
     },
@@ -145,7 +242,7 @@ var init_docker = __esm({
 // src/contexts/process.ts
 import { exec as execCb } from "child_process";
 import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
-import { dirname, resolve as resolve3 } from "path";
+import { dirname, resolve } from "path";
 import { promisify } from "util";
 function createProcessContext(config) {
   let counter = 0;
@@ -162,17 +259,17 @@ function createProcessContext(config) {
     },
     async spawn(overrides) {
       const id = `process-${++counter}`;
-      const cwd5 = overrides?.cwd ?? defaultCwd;
-      await mkdir(cwd5, { recursive: true });
-      const handle = { id, type: "process", cwd: cwd5 };
+      const cwd = overrides?.cwd ?? defaultCwd;
+      await mkdir(cwd, { recursive: true });
+      const handle = { id, type: "process", cwd };
       handles.set(id, handle);
       return handle;
     },
     async exec(handle, command, options) {
-      const cwd5 = options?.cwd ? resolve3(handle.cwd, options.cwd) : handle.cwd;
+      const cwd = options?.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd;
       try {
         const { stdout, stderr } = await execAsync(command, {
-          cwd: cwd5,
+          cwd,
           env: { ...process.env, ...defaultEnv, ...options?.env },
           timeout: (options?.timeout ?? config?.limits?.timeout ?? 30) * 1e3,
           maxBuffer: 10 * 1024 * 1024
@@ -187,15 +284,15 @@ function createProcessContext(config) {
       }
     },
     async readFile(handle, path) {
-      return readFile2(resolve3(handle.cwd, path), "utf-8");
+      return readFile2(resolve(handle.cwd, path), "utf-8");
     },
     async writeFile(handle, path, content) {
-      const fullPath = resolve3(handle.cwd, path);
+      const fullPath = resolve(handle.cwd, path);
       await mkdir(dirname(fullPath), { recursive: true });
       await writeFile(fullPath, content, "utf-8");
     },
     async listFiles(handle, path) {
-      return readdir(resolve3(handle.cwd, path));
+      return readdir(resolve(handle.cwd, path));
     },
     async destroy(handle) {
       handles.delete(handle.id);
@@ -270,6 +367,52 @@ var init_contexts = __esm({
   }
 });
 
+// src/harnesses/basic.ts
+function getSpawn() {
+  if (!_spawn) {
+    _spawn = (init_spawn(), __toCommonJS(spawn_exports)).spawn;
+  }
+  return _spawn;
+}
+var basicTools, _spawn, spawnProxy, basic_default;
+var init_basic = __esm({
+  "src/harnesses/basic.ts"() {
+    "use strict";
+    init_harnesses();
+    init_tools();
+    basicTools = { shell, readFile, writeFile: writeFile2, listFiles };
+    spawnProxy = {
+      get spec() {
+        return getSpawn().spec;
+      },
+      execute(input, ctx) {
+        return getSpawn().execute(input, ctx);
+      }
+    };
+    basic_default = defineHarness({
+      name: "basic",
+      system: "You are a helpful assistant with access to shell, file reading, file writing, directory listing, and sub-agent spawning tools. Use them to accomplish tasks in the project directory.",
+      tools: { ...basicTools, spawn: spawnProxy }
+    });
+  }
+});
+
+// src/harnesses/index.ts
+function defineHarness(config) {
+  return config;
+}
+var noTools;
+var init_harnesses = __esm({
+  "src/harnesses/index.ts"() {
+    init_basic();
+    noTools = defineHarness({
+      name: "none",
+      system: "You are a helpful assistant.",
+      tools: {}
+    });
+  }
+});
+
 // src/tools/validation.ts
 function validateToolArgs(input, schema) {
   const required = schema.required ?? [];
@@ -288,7 +431,7 @@ var init_validation = __esm({
 
 // src/loop.ts
 function turnsToMessages(turns) {
-  return turns.map((t) => ({ role: t.role, content: t.content }));
+  return turns.filter((t) => t.role !== "system").map((t) => ({ role: t.role, content: t.content }));
 }
 async function runLoop(ctx) {
   let totalIn = 0;
@@ -356,7 +499,7 @@ async function executeTurn(ctx, turn) {
   await ctx.hooks.callHook("context:transform", { messages });
   await ctx.hooks.callHook("turn:before", { turn, turnId, options: streamOptions });
   let currentText = "";
-  const blockIndex = 0;
+  let blockIndex = 0;
   const result = await ctx.provider.stream(
     streamOptions,
     {
@@ -368,6 +511,7 @@ async function executeTurn(ctx, turn) {
   );
   if (currentText) {
     await ctx.hooks.callHook("stream:end", { text: currentText, turnId, blockIndex });
+    blockIndex++;
   }
   await ctx.hooks.callHook("turn:after", { turn, turnId, usage: result.usage });
   if (result.done) {
@@ -484,8 +628,9 @@ var init_loop = __esm({
 
 // src/agent.ts
 import { createHooks } from "hookable";
-function createAgent({ harness, provider, toolExecution = "sequential", execution, mcpServers, session, _mcpConnector }) {
+function createAgent({ harness: harnessOption, provider, toolExecution = "sequential", enableTools = true, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
   const hooks = createHooks();
+  const harness = harnessOption ?? noTools;
   const executionContext = execution ?? createProcessContext();
   let abortController;
   let running = false;
@@ -498,6 +643,11 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
   const followUpQueue = [];
   let conversationTurns = session?.turns.slice() ?? [];
   let runCounter = session?.runs.length ?? 0;
+  const mergedSkillsConfig = mergeSkillsConfig(harness.skills, agentSkills);
+  const skillsEnabledValue = mergedSkillsConfig?.enabled;
+  const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
+  let resolvedSkills = null;
+  let skillsCatalog = null;
   async function run(options) {
     if (running) {
       throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
@@ -518,8 +668,8 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         options.signal.addEventListener("abort", onExternalAbort, { once: true });
       }
     }
-    idlePromise = new Promise((resolve5) => {
-      idleResolve = resolve5;
+    idlePromise = new Promise((resolve2) => {
+      idleResolve = resolve2;
     });
     const childrenStats = [];
     const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
@@ -535,10 +685,52 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
       }
     }
+    if (!skillsDisabled && mergedSkillsConfig && !resolvedSkills) {
+      resolvedSkills = await resolveSkills(mergedSkillsConfig);
+      await hooks.callHook("skills:resolve", { skills: resolvedSkills });
+      if (executionHandle) {
+        for (const skill of resolvedSkills) {
+          if (skill.instructions.includes("!`")) {
+            skill.instructions = await interpolateShellCommands(
+              skill.instructions,
+              executionContext,
+              executionHandle
+            );
+          }
+        }
+      }
+      const readToolName = mergedSkillsConfig.readToolName ?? "read_file";
+      const catalogCtx = { catalog: buildCatalog(resolvedSkills, readToolName), skills: resolvedSkills };
+      await hooks.callHook("skills:catalog", catalogCtx);
+      skillsCatalog = catalogCtx.catalog;
+      const fsSkills = resolvedSkills.filter((s) => s.location);
+      if (fsSkills.length > 0) {
+        const skillByLocation = new Map(fsSkills.map((s) => [s.location, s]));
+        hooks.hook("tool:after", (ctx) => {
+          if (ctx.name !== readToolName)
+            return;
+          const path = ctx.input.path;
+          if (!path)
+            return;
+          const matched = skillByLocation.get(path) ?? fsSkills.find((s) => s.location.endsWith(path));
+          if (matched)
+            hooks.callHook("skills:activate", { skill: matched });
+        });
+      }
+    }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const system = options.system || harness.system || "You are a helpful assistant.";
-    const tools = mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
+    let system = options.system || harness.system || "You are a helpful assistant.";
+    if (skillsCatalog) {
+      system = `${system}
+
+${skillsCatalog}`;
+    }
+    const harnessTools = enableTools ? mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools : {};
+    const tools = {};
+    for (const tool of Object.values(harnessTools)) {
+      tools[tool.spec.name] = tool;
+    }
     const toolSpecs = Object.values(tools).map(
       (t) => ({
         name: t.spec.name,
@@ -546,7 +738,7 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         input_schema: t.spec.input_schema
       })
     );
-    const formattedTools = provider.formatTools(toolSpecs);
+    const formattedTools = enableTools ? provider.formatTools(toolSpecs) : [];
     const turns = [];
     const isResume = session && session.turns.length > 0 && session.runs.length > 0;
     if (isResume) {
@@ -751,8 +943,12 @@ var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_contexts();
+    init_harnesses();
     init_loop();
     init_mcp();
+    init_catalog();
+    init_interpolate();
+    init_resolve();
   }
 });
 
@@ -762,6 +958,17 @@ __export(spawn_exports, {
   createSpawnTool: () => createSpawnTool,
   spawn: () => spawn
 });
+function extractText(message) {
+  if (!message || typeof message !== "object")
+    return "";
+  const msg = message;
+  if (typeof msg.content === "string")
+    return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  return "";
+}
 function createSpawnTool(options = {}) {
   const localChildren = /* @__PURE__ */ new Map();
   let localCounter = 0;
@@ -851,257 +1058,71 @@ function createSpawnTool(options = {}) {
     }
   };
 }
-function extractText(message) {
-  if (!message || typeof message !== "object")
-    return "";
-  const msg = message;
-  if (typeof msg.content === "string")
-    return msg.content;
-  if (Array.isArray(msg.content)) {
-    return msg.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
-  }
-  return "";
-}
-var children, childCounter, activeCount, MAX_CONCURRENT, _totalChildStats, spawn;
+var spawn;
 var init_spawn = __esm({
   "src/tools/spawn.ts"() {
     "use strict";
     init_agent();
-    children = /* @__PURE__ */ new Map();
-    childCounter = 0;
-    activeCount = 0;
-    MAX_CONCURRENT = 3;
-    _totalChildStats = {
-      totalIn: 0,
-      totalOut: 0,
-      turns: 0,
-      elapsed: 0
-    };
-    spawn = {
-      get children() {
-        return children;
-      },
-      get totalChildStats() {
-        return { ..._totalChildStats };
-      },
+    spawn = createSpawnTool();
+  }
+});
+
+// src/tools/write-file.ts
+var writeFile2;
+var init_write_file = __esm({
+  "src/tools/write-file.ts"() {
+    "use strict";
+    writeFile2 = {
       spec: {
-        name: "spawn",
-        description: "Spawn a sub-agent to work on a specific task. The sub-agent runs independently with its own tool access and returns its final response. Use this to delegate work, parallelize tasks, or isolate concerns.",
+        name: "write_file",
+        description: "Write content to a file. Creates parent directories if needed.",
         input_schema: {
           type: "object",
           properties: {
-            task: {
-              type: "string",
-              description: "The task prompt for the sub-agent. Be specific about what you want it to accomplish."
-            },
-            system: {
-              type: "string",
-              description: "Optional system prompt override for this specific sub-agent."
-            }
+            path: { type: "string", description: "Relative file path" },
+            content: { type: "string", description: "File content to write" }
           },
-          required: ["task"]
+          required: ["path", "content"]
         }
       },
-      async execute(input, ctx) {
-        const task = input.task;
-        const systemOverride = input.system;
-        if (activeCount >= MAX_CONCURRENT) {
-          return `Cannot spawn: ${activeCount}/${MAX_CONCURRENT} sub-agents already running. Wait for one to complete.`;
-        }
-        const id = `child-${++childCounter}`;
-        const child = { id, task, startedAt: Date.now() };
-        const agent = createAgent({
-          harness: ctx.harness,
-          provider: ctx.provider,
-          execution: ctx.execution
-        });
-        children.set(id, child);
-        activeCount++;
-        await ctx.hooks.callHook("spawn:before", { id, task });
-        try {
-          const stats = await agent.run({
-            prompt: task,
-            system: systemOverride,
-            signal: ctx.signal
-          });
-          _totalChildStats.totalIn += stats.totalIn;
-          _totalChildStats.totalOut += stats.totalOut;
-          _totalChildStats.turns += stats.turns;
-          _totalChildStats.elapsed += stats.elapsed;
-          await ctx.hooks.callHook("spawn:complete", {
-            id,
-            task,
-            stats
-          });
-          const response = extractText(agent.turns.at(-1));
-          return [
-            `[sub-agent ${id}] Completed in ${stats.turns} turns (${stats.elapsed}ms)`,
-            `Tokens: ${stats.totalIn} in / ${stats.totalOut} out`,
-            "",
-            response || "(no text response)"
-          ].join("\n");
-        } catch (err) {
-          await ctx.hooks.callHook("spawn:error", { id, task, error: err });
-          return `[sub-agent ${id}] Error: ${err.message}`;
-        } finally {
-          activeCount--;
-          await agent.destroy();
-          children.delete(id);
-        }
+      async execute({ path, content }, ctx) {
+        await ctx.execution.writeFile(ctx.handle, path, content);
+        return `Wrote ${content.length} bytes to ${path}`;
       }
     };
   }
 });
 
-// src/tools/list-files.ts
-import { existsSync, readdirSync, statSync } from "fs";
-import { resolve } from "path";
-var cwd = process.cwd();
-function safePath(p) {
-  const resolved = resolve(cwd, p);
-  if (!resolved.startsWith(cwd))
-    throw new Error(`Path escapes working directory: ${p}`);
-  return resolved;
-}
-var listFiles = {
-  spec: {
-    name: "list_files",
-    description: "List files and directories at the given path (relative to project root).",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: 'Relative directory path (default: ".")' }
-      },
-      required: []
-    }
-  },
-  async execute({ path }, _ctx) {
-    const target = safePath(path || ".");
-    if (!existsSync(target))
-      return `Directory not found: ${path}`;
-    const entries = readdirSync(target);
-    return entries.map((name) => {
-      const full = resolve(target, name);
-      const isDir = statSync(full).isDirectory();
-      return `${isDir ? "\u{1F4C1}" : "\u{1F4C4}"} ${name}`;
-    }).join("\n");
-  }
-};
-
-// src/tools/read-file.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { resolve as resolve2 } from "path";
-var cwd2 = process.cwd();
-function safePath2(p) {
-  const resolved = resolve2(cwd2, p);
-  if (!resolved.startsWith(cwd2))
-    throw new Error(`Path escapes working directory: ${p}`);
-  return resolved;
-}
-var readFile = {
-  spec: {
-    name: "read_file",
-    description: "Read the contents of a file at the given path (relative to project root).",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Relative file path" }
-      },
-      required: ["path"]
-    }
-  },
-  async execute({ path }, _ctx) {
-    const target = safePath2(path);
-    if (!existsSync2(target))
-      return `File not found: ${path}`;
-    return readFileSync(target, "utf-8");
-  }
-};
-
-// src/tools/shell.ts
-import { execSync } from "child_process";
-var cwd3 = process.cwd();
-var shell = {
-  spec: {
-    name: "shell",
-    description: "Execute a shell command and return stdout+stderr. Runs in the project root.",
-    input_schema: {
-      type: "object",
-      properties: {
-        command: { type: "string", description: "The shell command to run" }
-      },
-      required: ["command"]
-    }
-  },
-  async execute({ command }, _ctx) {
-    try {
-      const out = execSync(command, {
-        cwd: cwd3,
-        encoding: "utf-8",
-        timeout: 3e4,
-        maxBuffer: 1024 * 1024,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return out || "(no output)";
-    } catch (err) {
-      const stderr = err.stderr?.toString() ?? "";
-      const stdout = err.stdout?.toString() ?? "";
-      return `Exit code ${err.status ?? 1}
-${stdout}
-${stderr}`.trim();
-    }
-  }
-};
-
 // src/tools/index.ts
-init_spawn();
-init_validation();
-
-// src/tools/write-file.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname as dirname2, resolve as resolve4 } from "path";
-var cwd4 = process.cwd();
-function safePath3(p) {
-  const resolved = resolve4(cwd4, p);
-  if (!resolved.startsWith(cwd4))
-    throw new Error(`Path escapes working directory: ${p}`);
-  return resolved;
-}
-var writeFile2 = {
-  spec: {
-    name: "write_file",
-    description: "Write content to a file. Creates parent directories if needed.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Relative file path" },
-        content: { type: "string", description: "File content to write" }
-      },
-      required: ["path", "content"]
-    }
-  },
-  async execute({ path, content }, _ctx) {
-    const target = safePath3(path);
-    mkdirSync(dirname2(target), { recursive: true });
-    writeFileSync(target, content);
-    return `Wrote ${content.length} bytes to ${path}`;
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    init_list_files();
+    init_read_file();
+    init_shell();
+    init_spawn();
+    init_validation();
+    init_write_file();
   }
-};
+});
 
 export {
   createDockerContext,
   createProcessContext,
   createSandboxContext,
   init_contexts,
-  validateToolArgs,
-  createAgent,
-  init_agent,
   listFiles,
   readFile,
   shell,
-  spawn,
   createSpawnTool,
-  spawn_exports,
-  init_spawn,
-  writeFile2 as writeFile
+  spawn,
+  validateToolArgs,
+  writeFile2 as writeFile,
+  init_tools,
+  basicTools,
+  basic_default,
+  defineHarness,
+  noTools,
+  init_harnesses,
+  createAgent,
+  init_agent
 };