zidane 1.2.0 → 1.4.0

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
+};