zidane 1.8.0 → 2.0.1

package/dist/chunk-4C6Y56CC.js

@@ -1,390 +0,0 @@
-// 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");
-}
-var RE_AMP = /&/g;
-var RE_LT = /</g;
-var RE_GT = />/g;
-var RE_QUOT = /"/g;
-function escapeXml(str) {
-  return str.replace(RE_AMP, "&amp;").replace(RE_LT, "&lt;").replace(RE_GT, "&gt;").replace(RE_QUOT, "&quot;");
-}
-
-// src/skills/interpolate.ts
-var SHELL_INTERPOLATION_RE = /!`([^`]+)`/g;
-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;
-}
-
-// src/skills/discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { homedir } from "os";
-import { basename, dirname, join, resolve } from "path";
-var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
-var FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
-var INDENT_RE = /^[ \t]{2,}/;
-var KV_RE = /^([^:]+):(.*)$/;
-var QUOTE_RE = /^(['"])(.*)\1$/;
-var WHITESPACE_SPLIT_RE = /\s+/;
-var PARAGRAPH_SPLIT_RE = /\n\n/;
-var COMMA_OR_SPACE_RE = /[,\s]+/;
-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;
-}
-var RESOURCE_DIRS = {
-  scripts: "script",
-  references: "reference",
-  assets: "asset"
-};
-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;
-  const thinkingValue = frontmatter.thinking ?? frontmatter.effort;
-  if (thinkingValue)
-    config.thinking = thinkingValue;
-  if (frontmatter.paths) {
-    const raw = frontmatter.paths;
-    config.paths = raw.split(COMMA_OR_SPACE_RE).filter(Boolean);
-  }
-  return config;
-}
-var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "dist", "build"]);
-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()];
-}
-
-// 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;
-}
-
-// 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 ?? []])]
-  };
-}
-
-export {
-  buildCatalog,
-  interpolateShellCommands,
-  validateSkillName,
-  parseFrontmatter,
-  parseSkillFile,
-  getDefaultScanPaths,
-  discoverSkills,
-  writeSkillToDisk,
-  writeSkillsToDisk,
-  resolveSkills,
-  mergeSkillsConfig
-};

package/dist/chunk-CFLC2I7D.js

@@ -1,8 +0,0 @@
-// src/skills/index.ts
-function defineSkill(config) {
-  return config;
-}
-
-export {
-  defineSkill
-};

package/dist/glob-j9gbk6xm.d.ts

@@ -1,5 +0,0 @@
-import { X as ToolDef } from './agent-CWQ5XOw6.js';
-
-declare const glob: ToolDef;
-
-export { glob as g };

package/dist/types-CDI8Kmve.d.ts

@@ -1,64 +0,0 @@
-/**
- * Types for the Agent Skills system.
- *
- * Follows the Agent Skills open standard (agentskills.io/specification).
- */
-interface SkillResource {
-    /** Relative path from skill directory */
-    path: string;
-    /** Resource type inferred from directory */
-    type: 'script' | 'reference' | 'asset' | 'other';
-}
-interface SkillConfig {
-    /** Skill name: 1-64 chars, lowercase alphanumeric + hyphens */
-    name: string;
-    /** What the skill does and when to use it (1-1024 chars) */
-    description: string;
-    /** The SKILL.md body content (after YAML frontmatter) */
-    instructions: string;
-    /** Absolute path to SKILL.md (undefined for inline skills) */
-    location?: string;
-    /** Skill directory path for resolving relative references */
-    baseDir?: string;
-    /** License identifier or reference */
-    license?: string;
-    /** Environment requirements */
-    compatibility?: string;
-    /** Arbitrary key-value metadata */
-    metadata?: Record<string, string>;
-    /** Pre-approved tool names (experimental) */
-    allowedTools?: string[];
-    /** Bundled resource files discovered in the skill directory */
-    resources?: SkillResource[];
-    /** Model override when this skill is active */
-    model?: string;
-    /** Thinking/reasoning level override when this skill is active */
-    thinking?: 'off' | 'minimal' | 'low' | 'medium' | 'high';
-    /**
-     * Glob patterns that limit when this skill auto-activates.
-     * Parsed and stored per the Agent Skills spec, but not yet
-     * enforced at runtime — all skills are included in the catalog.
-     */
-    paths?: string[];
-}
-interface SkillsConfig {
-    /**
-     * Control which skills are active.
-     * - `true` (default): all discovered skills are enabled
-     * - `false` or `[]`: fully disable the skills system (no resolution, no catalog, no hooks)
-     * - `string[]`: allowlist — only skills with matching names are enabled
-     */
-    enabled?: boolean | string[];
-    /** Directories to scan for SKILL.md files */
-    scan?: string[];
-    /** Dynamic skills written to disk at agent start, then loaded normally */
-    write?: SkillConfig[];
-    /** Tool name the agent should use to read skill files (default: 'read_file') */
-    readToolName?: string;
-    /** Skill names to exclude from the catalog */
-    exclude?: string[];
-    /** Skip default scan paths (~/.agents/skills, .zidane/skills, etc.) */
-    skipDefaultPaths?: boolean;
-}
-
-export type { SkillConfig as S, SkillResource as a, SkillsConfig as b };