zidane 1.3.1 → 1.4.0

package/dist/{agent-DxIUxou4.d.ts → agent-B4wguzkU.d.ts}

@@ -1,87 +1,11 @@
 import { Hookable } from 'hookable';
+import { E as ExecutionContext, c as ExecutionHandle, f as SkillsConfig, d as SkillConfig } from './types-D8fzooXc.js';
 import Anthropic from '@anthropic-ai/sdk';
 import { M as McpServerConfig, e as TurnUsage, b as SessionMessage, C as ChildRunStats, a as AgentStats, A as AgentRunOptions, c as SessionTurn, d as ToolExecutionMode } from './types-CLRMCak3.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { Provider, StreamOptions } from './providers.js';
 import { Session } from './session.js';
 
-/**
- * Execution context types.
- *
- * An execution context defines *where* and *how* an agent's tools run.
- * The agent loop and tools interact through this interface without knowing
- * whether they're running in-process, in a Docker container, or in a
- * remote sandbox.
- */
-interface ContextCapabilities {
-    /** Can execute shell commands */
-    shell: boolean;
-    /** Can read/write files in a workspace */
-    filesystem: boolean;
-    /** Can make outbound network requests */
-    network: boolean;
-    /** Has GPU access */
-    gpu: boolean;
-}
-/** Opaque handle to a running execution context instance */
-interface ExecutionHandle {
-    id: string;
-    type: ContextType;
-    /** Working directory within the context */
-    cwd: string;
-}
-interface ExecResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-interface SpawnConfig {
-    /** Working directory (created if it doesn't exist) */
-    cwd?: string;
-    /** Environment variables */
-    env?: Record<string, string>;
-    /** Docker image (only for 'docker' context) */
-    image?: string;
-    /** Resource limits */
-    limits?: {
-        /** Memory limit in MB */
-        memory?: number;
-        /** CPU limit (e.g. '1.0' = 1 core) */
-        cpu?: string;
-        /** Timeout in seconds for the entire context lifetime */
-        timeout?: number;
-    };
-    /** Sandbox provider config (only for 'sandbox' context) */
-    sandbox?: {
-        provider: string;
-        apiKey?: string;
-        [key: string]: unknown;
-    };
-}
-type ContextType = 'process' | 'docker' | 'sandbox';
-interface ExecutionContext {
-    /** Context type identifier */
-    readonly type: ContextType;
-    /** What this context supports */
-    readonly capabilities: ContextCapabilities;
-    /** Spawn a new execution environment */
-    spawn: (config?: SpawnConfig) => Promise<ExecutionHandle>;
-    /** Execute a shell command in the context */
-    exec: (handle: ExecutionHandle, command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string>;
-        timeout?: number;
-    }) => Promise<ExecResult>;
-    /** Read a file from the context's filesystem */
-    readFile: (handle: ExecutionHandle, path: string) => Promise<string>;
-    /** Write a file to the context's filesystem */
-    writeFile: (handle: ExecutionHandle, path: string, content: string) => Promise<void>;
-    /** List files in a directory */
-    listFiles: (handle: ExecutionHandle, path: string) => Promise<string[]>;
-    /** Destroy the execution environment and clean up resources */
-    destroy: (handle: ExecutionHandle) => Promise<void>;
-}
-
 /** Core tools available in every basic harness (without spawn) */
 declare const basicTools: {
     shell: ToolDef;
@@ -123,12 +47,19 @@ interface HarnessConfig {
     tools: Record<string, ToolDef>;
     /** MCP servers to connect and expose as tools */
     mcpServers?: McpServerConfig[];
+    /** Skills configuration at the harness level */
+    skills?: SkillsConfig;
 }
 /**
  * Define a harness with a name, optional system prompt, and tools.
  */
 declare function defineHarness(config: HarnessConfig): HarnessConfig;
 type Harness = HarnessConfig;
+/**
+ * A harness with no tools — for pure chat mode.
+ * Use with `enableTools: false` or when no tool access is needed.
+ */
+declare const noTools: HarnessConfig;
 
 /**
  * MCP (Model Context Protocol) server support.
@@ -258,6 +189,16 @@ interface AgentHooks {
         input: Record<string, unknown>;
         error: Error;
     }) => void;
+    'skills:resolve': (ctx: {
+        skills: SkillConfig[];
+    }) => void;
+    'skills:catalog': (ctx: {
+        catalog: string;
+        skills: SkillConfig[];
+    }) => void;
+    'skills:activate': (ctx: {
+        skill: SkillConfig;
+    }) => void;
     'agent:abort': (ctx: object) => void;
     'agent:done': (ctx: AgentStats) => void;
     'session:start': (ctx: {
@@ -284,16 +225,21 @@ interface AgentHooks {
     }) => void;
 }
 interface AgentOptions {
-    harness: HarnessConfig;
+    /** Harness (tools + system prompt). Defaults to a no-tools harness if omitted. */
+    harness?: HarnessConfig;
     provider: Provider;
     /** Tool execution mode: 'sequential' (default) or 'parallel' */
     toolExecution?: ToolExecutionMode;
+    /** Enable tool use. When false, no tools are sent to the provider (pure chat mode). Default: true. */
+    enableTools?: boolean;
     /** Execution context: where tools run. Defaults to in-process. */
     execution?: ExecutionContext;
     /** MCP servers to connect and expose as tools */
     mcpServers?: McpServerConfig[];
     /** Session for identity, turn persistence, and run tracking */
     session?: Session;
+    /** Skills configuration (merged with harness-level skills, agent takes precedence) */
+    skills?: SkillsConfig;
     /** @internal */
     _mcpConnector?: (configs: McpServerConfig[]) => Promise<McpConnection>;
 }
@@ -314,6 +260,6 @@ interface Agent {
     readonly session: Session | null;
     meta: Record<string, unknown>;
 }
-declare function createAgent({ harness, provider, toolExecution, execution, mcpServers, session, _mcpConnector }: AgentOptions): Agent;
+declare function createAgent({ harness: harnessOption, provider, toolExecution, enableTools, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
 
-export { type Agent as A, type ContextCapabilities as C, type ExecutionContext as E, type Harness as H, type McpConnection as M, type SpawnConfig as S, type ToolContext as T, _default as _, type ExecResult as a, type AgentHooks as b, type AgentOptions as c, type ContextType as d, type ExecutionHandle as e, type HarnessConfig as f, type ToolDef as g, type ToolMap as h, connectMcpServers as i, createAgent as j, defineHarness as k, basicTools as l, resultToString as r };
+export { type Agent as A, type Harness as H, type McpConnection as M, type ToolContext as T, _default as _, type AgentHooks as a, type AgentOptions as b, type HarnessConfig as c, type ToolDef as d, type ToolMap as e, connectMcpServers as f, createAgent as g, defineHarness as h, basicTools as i, noTools as n, resultToString as r };

package/dist/chunk-PRNQ7DXE.js

@@ -0,0 +1,430 @@
+import {
+  __esm
+} from "./chunk-PNKVD2UK.js";
+
+// src/skills/catalog.ts
+function buildCatalog(skills, readToolName = "read_file") {
+  if (skills.length === 0)
+    return "";
+  const entries = skills.map((skill) => {
+    const locationLine = skill.location ? `
+    <location>${escapeXml(skill.location)}</location>` : "";
+    return `  <skill>
+    <name>${escapeXml(skill.name)}</name>
+    <description>${escapeXml(skill.description)}</description>${locationLine}
+  </skill>`;
+  }).join("\n");
+  const hasFsSkills = skills.some((s) => s.location);
+  const hasInlineSkills = skills.some((s) => !s.location);
+  const behavioralParts = [];
+  behavioralParts.push(
+    "The following skills provide specialized instructions for specific tasks.",
+    "When a task matches a skill's description, activate the skill to load its full instructions before proceeding."
+  );
+  if (hasFsSkills) {
+    behavioralParts.push(
+      `For skills with a <location>, use the ${readToolName} tool to read the SKILL.md file at that path.`,
+      "When a skill references relative paths, resolve them against the skill's directory (the parent of SKILL.md) and use absolute paths in tool calls."
+    );
+  }
+  if (hasInlineSkills) {
+    behavioralParts.push(
+      "Skills without a <location> have their instructions included directly in <instructions> tags below."
+    );
+  }
+  const parts = [
+    behavioralParts.join("\n"),
+    "",
+    "<available_skills>",
+    entries,
+    "</available_skills>"
+  ];
+  if (hasInlineSkills) {
+    parts.push("");
+    for (const skill of skills) {
+      if (!skill.location && skill.instructions) {
+        parts.push(`<skill_instructions name="${escapeXml(skill.name)}">`);
+        parts.push(skill.instructions);
+        if (skill.resources && skill.resources.length > 0) {
+          parts.push("");
+          parts.push("<skill_resources>");
+          for (const res of skill.resources) {
+            parts.push(`  <file type="${res.type}">${escapeXml(res.path)}</file>`);
+          }
+          parts.push("</skill_resources>");
+        }
+        parts.push("</skill_instructions>");
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function escapeXml(str) {
+  return str.replace(RE_AMP, "&amp;").replace(RE_LT, "&lt;").replace(RE_GT, "&gt;").replace(RE_QUOT, "&quot;");
+}
+var RE_AMP, RE_LT, RE_GT, RE_QUOT;
+var init_catalog = __esm({
+  "src/skills/catalog.ts"() {
+    "use strict";
+    RE_AMP = /&/g;
+    RE_LT = /</g;
+    RE_GT = />/g;
+    RE_QUOT = /"/g;
+  }
+});
+
+// src/skills/interpolate.ts
+async function interpolateShellCommands(instructions, execution, handle) {
+  const matches = [...instructions.matchAll(SHELL_INTERPOLATION_RE)];
+  if (matches.length === 0)
+    return instructions;
+  const replacements = [];
+  for (const match of matches) {
+    const command = match[1];
+    const index = match.index;
+    const length = match[0].length;
+    try {
+      const result2 = await execution.exec(handle, command, { timeout: 30 });
+      const output = result2.exitCode === 0 ? result2.stdout.trim() : `[command failed (exit ${result2.exitCode}): ${result2.stderr.trim() || result2.stdout.trim()}]`;
+      replacements.push({ index, length, output });
+    } catch (err) {
+      replacements.push({ index, length, output: `[command error: ${err.message}]` });
+    }
+  }
+  let result = instructions;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const { index, length, output } = replacements[i];
+    result = result.slice(0, index) + output + result.slice(index + length);
+  }
+  return result;
+}
+var SHELL_INTERPOLATION_RE;
+var init_interpolate = __esm({
+  "src/skills/interpolate.ts"() {
+    "use strict";
+    SHELL_INTERPOLATION_RE = /!`([^`]+)`/g;
+  }
+});
+
+// src/skills/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, join, resolve } from "path";
+function validateSkillName(name) {
+  if (name.length < 1 || name.length > 64)
+    return false;
+  if (name.includes("--"))
+    return false;
+  return SKILL_NAME_RE.test(name);
+}
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) {
+    return { frontmatter: {}, body: content.trim() };
+  }
+  const yamlBlock = match[1];
+  const body = match[2].trim();
+  const frontmatter = {};
+  let currentKey = null;
+  let currentMap = null;
+  for (const line of yamlBlock.split("\n")) {
+    if (!line.trim() || line.trim().startsWith("#"))
+      continue;
+    if (currentKey && currentMap && INDENT_RE.test(line)) {
+      const nestedMatch = line.trim().match(KV_RE);
+      if (nestedMatch) {
+        const val = nestedMatch[2].trim();
+        currentMap[nestedMatch[1].trim()] = unquoteYaml(val);
+      }
+      continue;
+    }
+    if (currentKey && currentMap) {
+      frontmatter[currentKey] = currentMap;
+      currentKey = null;
+      currentMap = null;
+    }
+    const kvMatch = line.match(KV_RE);
+    if (!kvMatch)
+      continue;
+    const key = kvMatch[1].trim();
+    const value = kvMatch[2].trim();
+    if (!value) {
+      currentKey = key;
+      currentMap = {};
+    } else {
+      frontmatter[key] = unquoteYaml(value);
+    }
+  }
+  if (currentKey && currentMap) {
+    frontmatter[currentKey] = currentMap;
+  }
+  return { frontmatter, body };
+}
+function unquoteYaml(val) {
+  const m = val.match(QUOTE_RE);
+  if (m)
+    return m[2];
+  return val;
+}
+function enumerateResources(baseDir) {
+  const resources = [];
+  for (const [dir, type] of Object.entries(RESOURCE_DIRS)) {
+    const dirPath = join(baseDir, dir);
+    if (!existsSync(dirPath) || !statSync(dirPath).isDirectory())
+      continue;
+    try {
+      const files = readdirSync(dirPath, { recursive: true });
+      for (const file of files) {
+        const fullPath = join(dirPath, file);
+        if (statSync(fullPath).isFile()) {
+          resources.push({ path: join(dir, file), type });
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    for (const entry of readdirSync(baseDir)) {
+      if (entry === "SKILL.md")
+        continue;
+      const entryPath = join(baseDir, entry);
+      if (statSync(entryPath).isFile()) {
+        resources.push({ path: entry, type: "other" });
+      }
+    }
+  } catch {
+  }
+  return resources;
+}
+async function parseSkillFile(filePath) {
+  const absPath = resolve(filePath);
+  if (!existsSync(absPath))
+    return null;
+  const content = readFileSync(absPath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  const name = frontmatter.name;
+  let description = frontmatter.description;
+  if (!description && body) {
+    const firstParagraph = body.split(PARAGRAPH_SPLIT_RE)[0]?.trim();
+    if (firstParagraph)
+      description = firstParagraph;
+  }
+  if (!description)
+    return null;
+  const baseDir = dirname(absPath);
+  const dirName = basename(baseDir);
+  const skillName = name || dirName;
+  const config = {
+    name: skillName,
+    description,
+    instructions: body,
+    location: absPath,
+    baseDir,
+    resources: enumerateResources(baseDir)
+  };
+  if (frontmatter.license)
+    config.license = frontmatter.license;
+  if (frontmatter.compatibility)
+    config.compatibility = frontmatter.compatibility;
+  if (frontmatter.metadata && typeof frontmatter.metadata === "object")
+    config.metadata = frontmatter.metadata;
+  if (frontmatter["allowed-tools"])
+    config.allowedTools = frontmatter["allowed-tools"].split(WHITESPACE_SPLIT_RE);
+  if (frontmatter.model)
+    config.model = frontmatter.model;
+  if (frontmatter.thinking)
+    config.thinking = frontmatter.thinking;
+  if (frontmatter.effort)
+    config.thinking = frontmatter.effort;
+  if (frontmatter.paths) {
+    const raw = frontmatter.paths;
+    config.paths = raw.split(COMMA_OR_SPACE_RE).filter(Boolean);
+  }
+  return config;
+}
+function findSkillDirs(root, maxDepth = 4, _depth = 0) {
+  if (_depth > maxDepth)
+    return [];
+  if (!existsSync(root) || !statSync(root).isDirectory())
+    return [];
+  const results = [];
+  try {
+    for (const entry of readdirSync(root)) {
+      if (SKIP_DIRS.has(entry))
+        continue;
+      const entryPath = join(root, entry);
+      if (!statSync(entryPath).isDirectory())
+        continue;
+      const skillFile = join(entryPath, "SKILL.md");
+      if (existsSync(skillFile) && statSync(skillFile).isFile()) {
+        results.push(skillFile);
+      } else {
+        results.push(...findSkillDirs(entryPath, maxDepth, _depth + 1));
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function getDefaultScanPaths() {
+  const home = homedir();
+  const cwd = process.cwd();
+  return [
+    // Project-level (higher priority)
+    join(cwd, ".agents", "skills"),
+    join(cwd, ".zidane", "skills"),
+    // User-level (lower priority)
+    join(home, ".agents", "skills"),
+    join(home, ".zidane", "skills")
+  ];
+}
+async function discoverSkills(paths) {
+  const skillsByName = /* @__PURE__ */ new Map();
+  for (const scanPath of paths) {
+    const skillFiles = findSkillDirs(resolve(scanPath));
+    for (const file of skillFiles) {
+      const skill = await parseSkillFile(file);
+      if (skill && !skillsByName.has(skill.name)) {
+        skillsByName.set(skill.name, skill);
+      }
+    }
+  }
+  return [...skillsByName.values()];
+}
+var SKILL_NAME_RE, FRONTMATTER_RE, INDENT_RE, KV_RE, QUOTE_RE, WHITESPACE_SPLIT_RE, PARAGRAPH_SPLIT_RE, COMMA_OR_SPACE_RE, RESOURCE_DIRS, SKIP_DIRS;
+var init_discovery = __esm({
+  "src/skills/discovery.ts"() {
+    "use strict";
+    SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+    FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    INDENT_RE = /^[ \t]{2,}/;
+    KV_RE = /^([^:]+):(.*)$/;
+    QUOTE_RE = /^(['"])(.*)\1$/;
+    WHITESPACE_SPLIT_RE = /\s+/;
+    PARAGRAPH_SPLIT_RE = /\n\n/;
+    COMMA_OR_SPACE_RE = /[,\s]+/;
+    RESOURCE_DIRS = {
+      scripts: "script",
+      references: "reference",
+      assets: "asset"
+    };
+    SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "dist", "build"]);
+  }
+});
+
+// src/skills/writer.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function serializeFrontmatter(skill) {
+  const lines = ["---"];
+  lines.push(`name: ${skill.name}`);
+  lines.push(`description: ${skill.description}`);
+  if (skill.license)
+    lines.push(`license: ${skill.license}`);
+  if (skill.compatibility)
+    lines.push(`compatibility: ${skill.compatibility}`);
+  if (skill.allowedTools?.length)
+    lines.push(`allowed-tools: ${skill.allowedTools.join(" ")}`);
+  if (skill.model)
+    lines.push(`model: ${skill.model}`);
+  if (skill.thinking)
+    lines.push(`thinking: ${skill.thinking}`);
+  if (skill.paths?.length)
+    lines.push(`paths: ${skill.paths.join(", ")}`);
+  if (skill.metadata && Object.keys(skill.metadata).length > 0) {
+    lines.push("metadata:");
+    for (const [key, value] of Object.entries(skill.metadata)) {
+      lines.push(`  ${key}: "${value}"`);
+    }
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function writeSkillToDisk(skill, targetDir) {
+  const skillDir = join2(targetDir, skill.name);
+  mkdirSync(skillDir, { recursive: true });
+  const frontmatter = serializeFrontmatter(skill);
+  const body = skill.instructions ? `
+${skill.instructions}` : "";
+  const content = `${frontmatter}
+${body}
+`;
+  const skillPath = join2(skillDir, "SKILL.md");
+  writeFileSync(skillPath, content);
+  return skillPath;
+}
+function writeSkillsToDisk(skills, targetDir) {
+  mkdirSync(targetDir, { recursive: true });
+  for (const skill of skills) {
+    writeSkillToDisk(skill, targetDir);
+  }
+  return targetDir;
+}
+var init_writer = __esm({
+  "src/skills/writer.ts"() {
+    "use strict";
+  }
+});
+
+// src/skills/resolve.ts
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+async function resolveSkills(config) {
+  const scanPaths = config.skipDefaultPaths ? [...config.scan ?? []] : [...getDefaultScanPaths(), ...config.scan ?? []];
+  if (config.write?.length) {
+    const writeDir = mkdtempSync(join3(tmpdir(), "zidane-skills-"));
+    writeSkillsToDisk(config.write, writeDir);
+    scanPaths.push(writeDir);
+  }
+  const skills = await discoverSkills(scanPaths);
+  const exclude = new Set(config.exclude ?? []);
+  let filtered = skills.filter((s) => !exclude.has(s.name));
+  if (Array.isArray(config.enabled)) {
+    const allowlist = new Set(config.enabled);
+    filtered = filtered.filter((s) => allowlist.has(s.name));
+  }
+  return filtered;
+}
+function mergeSkillsConfig(harness, agent) {
+  if (!harness && !agent)
+    return void 0;
+  if (!harness)
+    return agent;
+  if (!agent)
+    return harness;
+  return {
+    // Agent-level enabled takes precedence when explicitly set
+    enabled: agent.enabled !== void 0 ? agent.enabled : harness.enabled,
+    scan: [...harness.scan ?? [], ...agent.scan ?? []],
+    write: [...harness.write ?? [], ...agent.write ?? []],
+    readToolName: agent.readToolName ?? harness.readToolName,
+    exclude: [.../* @__PURE__ */ new Set([...harness.exclude ?? [], ...agent.exclude ?? []])]
+  };
+}
+var init_resolve = __esm({
+  "src/skills/resolve.ts"() {
+    "use strict";
+    init_discovery();
+    init_writer();
+  }
+});
+
+export {
+  buildCatalog,
+  init_catalog,
+  interpolateShellCommands,
+  init_interpolate,
+  validateSkillName,
+  parseFrontmatter,
+  parseSkillFile,
+  getDefaultScanPaths,
+  discoverSkills,
+  init_discovery,
+  writeSkillToDisk,
+  writeSkillsToDisk,
+  init_writer,
+  resolveSkills,
+  mergeSkillsConfig,
+  init_resolve
+};

package/dist/chunk-QPYZR2QM.js

@@ -0,0 +1,21 @@
+import {
+  init_catalog,
+  init_discovery,
+  init_interpolate,
+  init_resolve,
+  init_writer
+} from "./chunk-PRNQ7DXE.js";
+
+// src/skills/index.ts
+init_catalog();
+init_discovery();
+init_interpolate();
+init_resolve();
+init_writer();
+function defineSkill(config) {
+  return config;
+}
+
+export {
+  defineSkill
+};