zidane 4.0.2 → 4.1.3

package/dist/chunk-6STZTA4N.js

@@ -1,830 +0,0 @@
-import {
-  AgentToolNotAllowedError
-} from "./chunk-LNN5UTS2.js";
-
-// src/skills/activation.ts
-function createSkillActivationState(options = {}) {
-  const byName = /* @__PURE__ */ new Map();
-  const maxActive = typeof options.maxActive === "number" && options.maxActive > 0 ? options.maxActive : void 0;
-  return {
-    active() {
-      return [...byName.values()];
-    },
-    isActive(name) {
-      return byName.has(name);
-    },
-    get(name) {
-      return byName.get(name);
-    },
-    activate(skill, via) {
-      if (byName.has(skill.name))
-        return "already-active";
-      if (maxActive !== void 0 && byName.size >= maxActive)
-        return "cap-reached";
-      byName.set(skill.name, {
-        skill,
-        activatedAt: Date.now(),
-        activatedVia: via
-      });
-      return "ok";
-    },
-    deactivate(name) {
-      const existing = byName.get(name);
-      if (!existing)
-        return void 0;
-      byName.delete(name);
-      return existing;
-    },
-    clear() {
-      const snapshot = [...byName.values()];
-      byName.clear();
-      return snapshot;
-    }
-  };
-}
-
-// src/skills/validate.ts
-import { basename } from "path";
-var NAME_MAX = 64;
-var DESCRIPTION_MAX = 1024;
-var COMPATIBILITY_MAX = 500;
-var SKILL_NAME_RE = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
-var CONSECUTIVE_HYPHENS_RE = /--/;
-var ALLOWED_TOOL_PATTERN_RE = /^([\w-]+)(?:\(([^)]*)\))?$/;
-var ABS_WINDOWS_PATH_RE = /^[a-z]:[\\/]/i;
-var PATH_SEPARATOR_RE = /[\\/]/;
-var TRAILING_SLASHES_RE = /\/+$/;
-function validateSkillName(name) {
-  if (typeof name !== "string")
-    return false;
-  if (name.length < 1 || name.length > NAME_MAX)
-    return false;
-  if (CONSECUTIVE_HYPHENS_RE.test(name))
-    return false;
-  return SKILL_NAME_RE.test(name);
-}
-function validateSkillForWrite(skill) {
-  const errors = [];
-  if (!validateSkillName(skill.name)) {
-    errors.push({
-      code: "invalid-name",
-      message: `Skill name "${skill.name}" must be 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.`,
-      field: "name"
-    });
-  }
-  if (skill.location) {
-    const dirName = basename(skill.baseDir ?? "");
-    if (dirName && dirName !== skill.name) {
-      errors.push({
-        code: "name-mismatch-directory",
-        message: `Skill name "${skill.name}" must match parent directory name "${dirName}".`,
-        field: "name"
-      });
-    }
-  }
-  if (typeof skill.description !== "string" || skill.description.length < 1) {
-    errors.push({
-      code: "missing-description",
-      message: "Skill description is required (non-empty).",
-      field: "description"
-    });
-  } else if (skill.description.length > DESCRIPTION_MAX) {
-    errors.push({
-      code: "description-too-long",
-      message: `Skill description must be at most ${DESCRIPTION_MAX} characters (got ${skill.description.length}).`,
-      field: "description"
-    });
-  }
-  if (skill.compatibility !== void 0) {
-    if (typeof skill.compatibility !== "string" || skill.compatibility.length === 0) {
-      errors.push({
-        code: "invalid-compatibility",
-        message: "Compatibility must be a non-empty string when provided.",
-        field: "compatibility"
-      });
-    } else if (skill.compatibility.length > COMPATIBILITY_MAX) {
-      errors.push({
-        code: "compatibility-too-long",
-        message: `Compatibility must be at most ${COMPATIBILITY_MAX} characters (got ${skill.compatibility.length}).`,
-        field: "compatibility"
-      });
-    }
-  }
-  if (skill.metadata) {
-    for (const [key, value] of Object.entries(skill.metadata)) {
-      if (typeof value !== "string") {
-        errors.push({
-          code: "invalid-metadata-value",
-          message: `Metadata value for "${key}" must be a string (spec: "A map from string keys to string values").`,
-          field: "metadata"
-        });
-      }
-    }
-  }
-  if (skill.allowedTools) {
-    for (const pattern of skill.allowedTools) {
-      if (!ALLOWED_TOOL_PATTERN_RE.test(pattern)) {
-        errors.push({
-          code: "invalid-allowed-tool-pattern",
-          message: `Allowed-tools entry "${pattern}" is not a recognized pattern (expected "ToolName" or "ToolName(arg:*)").`,
-          field: "allowed-tools"
-        });
-      }
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function validateResourcePath(relPath, baseDir) {
-  if (typeof relPath !== "string" || relPath.length === 0)
-    return { valid: false, error: "Resource path must be a non-empty string." };
-  if (relPath.includes("\0"))
-    return { valid: false, error: "Resource path contains a null byte." };
-  if (relPath.startsWith("/") || ABS_WINDOWS_PATH_RE.test(relPath))
-    return { valid: false, error: `Absolute paths are not allowed ("${relPath}").` };
-  const segments = [];
-  for (const segment of relPath.split(PATH_SEPARATOR_RE)) {
-    if (segment === "" || segment === ".")
-      continue;
-    if (segment === "..") {
-      if (segments.length === 0) {
-        return {
-          valid: false,
-          error: `Resource path "${relPath}" escapes the skill directory.`
-        };
-      }
-      segments.pop();
-      continue;
-    }
-    segments.push(segment);
-  }
-  if (segments.length === 0)
-    return { valid: false, error: "Resource path resolves to the skill root itself." };
-  const absolutePath = `${baseDir.replace(TRAILING_SLASHES_RE, "")}/${segments.join("/")}`;
-  return { valid: true, absolutePath };
-}
-function parseAllowedToolPattern(entry) {
-  const m = entry.trim().match(ALLOWED_TOOL_PATTERN_RE);
-  if (!m)
-    return null;
-  const tool = m[1];
-  const arg = m[2];
-  if (!arg)
-    return { tool };
-  if (arg.endsWith(":*"))
-    return { tool, argPrefix: arg.slice(0, -2) };
-  return { tool, argPrefix: arg };
-}
-function matchesAllowedTool(displayName, input, pattern) {
-  const parsed = parseAllowedToolPattern(pattern);
-  if (!parsed)
-    return false;
-  if (parsed.tool !== displayName)
-    return false;
-  if (parsed.argPrefix === void 0)
-    return true;
-  for (const value of Object.values(input)) {
-    if (typeof value === "string" && value.startsWith(parsed.argPrefix))
-      return true;
-  }
-  return false;
-}
-function isToolAllowedByUnion(displayName, input, union) {
-  if (union.length === 0)
-    return true;
-  return union.some((pattern) => matchesAllowedTool(displayName, input, pattern));
-}
-
-// src/skills/allowed-tools.ts
-var IMPLICITLY_ALLOWED_SKILL_TOOLS = [
-  "skills_use",
-  "skills_read",
-  "skills_run_script"
-];
-function installAllowedToolsGate(hooks, state) {
-  function effectiveUnion() {
-    const active = state.active();
-    const declared = [];
-    for (const record of active) {
-      if (record.skill.allowedTools?.length)
-        declared.push(...record.skill.allowedTools);
-    }
-    return {
-      union: declared.length > 0 ? [...declared, ...IMPLICITLY_ALLOWED_SKILL_TOOLS] : [],
-      active: active.map((a) => a.skill.name)
-    };
-  }
-  function gateHandler(ctx) {
-    const { union, active } = effectiveUnion();
-    if (union.length === 0)
-      return;
-    if (isToolAllowedByUnion(ctx.displayName, ctx.input, union))
-      return;
-    const err = new AgentToolNotAllowedError({
-      toolName: ctx.name,
-      displayName: ctx.displayName,
-      allowedUnion: union,
-      activeSkills: active
-    });
-    ctx.block = true;
-    ctx.reason = err.message;
-  }
-  function mcpGateHandler(ctx) {
-    const { union, active } = effectiveUnion();
-    if (union.length === 0)
-      return;
-    if (isToolAllowedByUnion(ctx.displayName, ctx.input, union))
-      return;
-    const err = new AgentToolNotAllowedError({
-      toolName: `mcp_${ctx.server}_${ctx.tool}`,
-      displayName: ctx.displayName,
-      allowedUnion: union,
-      activeSkills: active
-    });
-    ctx.block = true;
-    ctx.reason = err.message;
-  }
-  const unregisterTool = hooks.hook("tool:gate", gateHandler);
-  const unregisterMcp = hooks.hook("mcp:tool:gate", mcpGateHandler);
-  return function uninstall() {
-    unregisterTool();
-    unregisterMcp();
-  };
-}
-
-// src/xml.ts
-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/catalog.ts
-function buildCatalog(skills, options = {}) {
-  if (skills.length === 0)
-    return "";
-  const skillsToolRegistered = options.skillsToolRegistered ?? true;
-  const readToolName = options.readToolName ?? "read_file";
-  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 (skillsToolRegistered) {
-    behavioralParts.push(
-      "To activate a skill, call the `skills_use` tool with the skill's name. The response contains the full instructions and any bundled resources you can then load via `skills_read` (reference files) or execute via `skills_run_script` (scripts/ directory).",
-      "Relative paths referenced in a skill's instructions resolve against the skill directory noted in the `skills_use` response."
-    );
-  } else 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 && !skillsToolRegistered) {
-    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 && !skillsToolRegistered) {
-    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");
-}
-
-// src/skills/discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { homedir } from "os";
-import { basename as basename2, dirname, join, resolve } from "path";
-var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-var INDENT_RE = /^[ \t]{2,}/;
-var KV_RE = /^([^:]+):(.*)$/;
-var DOUBLE_QUOTED_RE = /^"((?:\\.|[^"\\])*)"$/;
-var SINGLE_QUOTED_RE = /^'((?:''|[^'])*)'$/;
-var DQ_ESCAPE_RE = /\\(["\\/bfnrt])/g;
-var WHITESPACE_SPLIT_RE = /\s+/;
-var PARAGRAPH_SPLIT_RE = /\n\n/;
-var COMMA_OR_SPACE_RE = /[,\s]+/;
-function parseFrontmatter(content) {
-  const diagnostics = [];
-  const match = content.match(FRONTMATTER_RE);
-  if (!match) {
-    return { frontmatter: {}, body: content.trim(), diagnostics };
-  }
-  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 = matchFirstColon(line);
-    if (!kvMatch)
-      continue;
-    const key = kvMatch.key.trim();
-    const rawValue = kvMatch.value.trim();
-    if (!rawValue) {
-      currentKey = key;
-      currentMap = {};
-    } else {
-      frontmatter[key] = unquoteYaml(rawValue);
-    }
-  }
-  if (currentKey && currentMap) {
-    frontmatter[currentKey] = currentMap;
-  }
-  return { frontmatter, body, diagnostics };
-}
-function matchFirstColon(line) {
-  const idx = line.indexOf(":");
-  if (idx < 0)
-    return null;
-  const key = line.slice(0, idx);
-  const value = line.slice(idx + 1);
-  if (!KV_RE.test(`${key}:`))
-    return null;
-  return { key, value };
-}
-function unquoteYaml(val) {
-  const dq = val.match(DOUBLE_QUOTED_RE);
-  if (dq) {
-    return dq[1].replace(DQ_ESCAPE_RE, (_, ch) => {
-      switch (ch) {
-        case '"':
-          return '"';
-        case "\\":
-          return "\\";
-        case "/":
-          return "/";
-        case "b":
-          return "\b";
-        case "f":
-          return "\f";
-        case "n":
-          return "\n";
-        case "r":
-          return "\r";
-        case "t":
-          return "	";
-        default:
-          return ch;
-      }
-    });
-  }
-  const sq = val.match(SINGLE_QUOTED_RE);
-  if (sq) {
-    return sq[1].replace(/''/g, "'");
-  }
-  const hashIdx = val.indexOf(" #");
-  if (hashIdx >= 0)
-    return val.slice(0, hashIdx).trimEnd();
-  return val;
-}
-function takeString(frontmatter, key, diagnostics) {
-  const raw = frontmatter[key];
-  if (raw === void 0 || raw === null)
-    return void 0;
-  if (typeof raw === "string")
-    return raw;
-  diagnostics.push({
-    severity: "warning",
-    code: "invalid-field-type",
-    message: `Frontmatter field "${key}" expected string, got ${typeof raw}. Coerced.`,
-    field: key
-  });
-  return String(raw);
-}
-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 rel = typeof file === "string" ? file : file.toString("utf-8");
-        const fullPath = join(dirPath, rel);
-        if (statSync(fullPath).isFile()) {
-          resources.push({ path: join(dir, rel), 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, options = {}) {
-  const absPath = resolve(filePath);
-  if (!existsSync(absPath))
-    return null;
-  const content = readFileSync(absPath, "utf-8");
-  const { frontmatter, body, diagnostics } = parseFrontmatter(content);
-  let description = takeString(frontmatter, "description", diagnostics);
-  if (!description && body) {
-    const firstParagraph = body.split(PARAGRAPH_SPLIT_RE)[0]?.trim();
-    if (firstParagraph)
-      description = firstParagraph;
-  }
-  if (!description)
-    return null;
-  if (description.length > 1024) {
-    diagnostics.push({
-      severity: "warning",
-      code: "description-too-long",
-      message: `Description exceeds spec limit of 1024 characters (got ${description.length}). Loading anyway.`,
-      field: "description"
-    });
-  }
-  const baseDir = dirname(absPath);
-  const dirName = basename2(baseDir);
-  const frontmatterName = takeString(frontmatter, "name", diagnostics);
-  const name = frontmatterName || dirName;
-  if (frontmatterName && frontmatterName !== dirName) {
-    diagnostics.push({
-      severity: "warning",
-      code: "name-mismatch-directory",
-      message: `Skill name "${frontmatterName}" does not match parent directory "${dirName}". Loading anyway.`,
-      field: "name"
-    });
-  }
-  if (name.length > 64) {
-    diagnostics.push({
-      severity: "warning",
-      code: "name-too-long",
-      message: `Skill name "${name}" exceeds spec limit of 64 characters. Loading anyway.`,
-      field: "name"
-    });
-  }
-  if (!validateSkillName(name)) {
-    diagnostics.push({
-      severity: "warning",
-      code: "invalid-name-format",
-      message: `Skill name "${name}" does not match spec format (lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens). Loading anyway.`,
-      field: "name"
-    });
-  }
-  const config = {
-    name,
-    description,
-    instructions: body,
-    source: options.source ?? "project",
-    location: absPath,
-    baseDir,
-    resources: enumerateResources(baseDir)
-  };
-  const license = takeString(frontmatter, "license", diagnostics);
-  if (license)
-    config.license = license;
-  const compatibility = takeString(frontmatter, "compatibility", diagnostics);
-  if (compatibility) {
-    if (compatibility.length > 500) {
-      diagnostics.push({
-        severity: "warning",
-        code: "compatibility-too-long",
-        message: `Compatibility exceeds spec limit of 500 characters (got ${compatibility.length}). Loading anyway.`,
-        field: "compatibility"
-      });
-    }
-    config.compatibility = compatibility;
-  }
-  const metadata = {};
-  const rawMetadata = frontmatter.metadata;
-  if (rawMetadata && typeof rawMetadata === "object" && !Array.isArray(rawMetadata)) {
-    for (const [k, v] of Object.entries(rawMetadata)) {
-      if (typeof v !== "string") {
-        diagnostics.push({
-          severity: "warning",
-          code: "invalid-metadata-value",
-          message: `Metadata value for "${k}" is not a string; coerced. (Spec requires string values.)`,
-          field: "metadata"
-        });
-        metadata[k] = String(v);
-        continue;
-      }
-      metadata[k] = v;
-    }
-  } else if (rawMetadata !== void 0) {
-    diagnostics.push({
-      severity: "warning",
-      code: "invalid-metadata-shape",
-      message: `Frontmatter "metadata" expected a map, got ${Array.isArray(rawMetadata) ? "array" : typeof rawMetadata}. Ignored.`,
-      field: "metadata"
-    });
-  }
-  const pathsField = takeString(frontmatter, "paths", diagnostics);
-  if (pathsField) {
-    metadata["zidane.paths"] = pathsField.split(COMMA_OR_SPACE_RE).filter(Boolean).join(",");
-    diagnostics.push({
-      severity: "warning",
-      code: "deprecated-top-level-field",
-      message: '`paths` is not a spec field and is deprecated \u2014 moved to `metadata["zidane.paths"]`.',
-      field: "paths"
-    });
-  }
-  const modelField = takeString(frontmatter, "model", diagnostics);
-  if (modelField) {
-    metadata["zidane.model"] = modelField;
-    diagnostics.push({
-      severity: "warning",
-      code: "deprecated-top-level-field",
-      message: '`model` is not a spec field and is deprecated \u2014 moved to `metadata["zidane.model"]`.',
-      field: "model"
-    });
-  }
-  const thinkingField = takeString(frontmatter, "thinking", diagnostics);
-  const effortField = thinkingField ? void 0 : takeString(frontmatter, "effort", diagnostics);
-  const legacyThinking = thinkingField ?? effortField;
-  if (legacyThinking) {
-    metadata["zidane.thinking"] = legacyThinking;
-    diagnostics.push({
-      severity: "warning",
-      code: "deprecated-top-level-field",
-      message: `\`${thinkingField ? "thinking" : "effort"}\` is not a spec field and is deprecated \u2014 moved to \`metadata["zidane.thinking"]\`.`,
-      field: thinkingField ? "thinking" : "effort"
-    });
-  }
-  if (Object.keys(metadata).length > 0)
-    config.metadata = metadata;
-  const allowedTools = takeString(frontmatter, "allowed-tools", diagnostics);
-  if (allowedTools) {
-    config.allowedTools = allowedTools.split(WHITESPACE_SPLIT_RE).filter(Boolean);
-  }
-  if (diagnostics.length > 0)
-    config.diagnostics = diagnostics;
-  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)
-    { path: join(cwd, ".agents", "skills"), source: "project" },
-    { path: join(cwd, ".zidane", "skills"), source: "project" },
-    // User-level (lower priority)
-    { path: join(home, ".agents", "skills"), source: "user" },
-    { path: join(home, ".zidane", "skills"), source: "user" }
-  ];
-}
-function inferSource(path) {
-  return path.startsWith(homedir()) ? "user" : "project";
-}
-async function discoverSkills(paths) {
-  const skillsByName = /* @__PURE__ */ new Map();
-  for (const { path: scanPath, source } of paths) {
-    const skillFiles = findSkillDirs(resolve(scanPath));
-    for (const file of skillFiles) {
-      const skill = await parseSkillFile(file, { source });
-      if (!skill)
-        continue;
-      if (skillsByName.has(skill.name)) {
-        const existing = skillsByName.get(skill.name);
-        const diag = {
-          severity: "warning",
-          code: "name-collision-shadowed",
-          message: `A skill with name "${skill.name}" was also found at ${file} (source: ${source}); shadowed by ${existing.location} (source: ${existing.source}).`
-        };
-        existing.diagnostics = [...existing.diagnostics ?? [], diag];
-        continue;
-      }
-      skillsByName.set(skill.name, skill);
-    }
-  }
-  return [...skillsByName.values()];
-}
-
-// src/skills/writer.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { join as join2 } from "path";
-var YAML_RESERVED_RE = /[:#&*!|>%@`]/;
-var YAML_EDGE_OR_QUOTE_RE = /^\s|\s$|["']/;
-var DQUOTE_RE = /"/g;
-var LEADING_NEWLINES_RE = /^\n+/;
-function yamlEscape(value) {
-  if (YAML_RESERVED_RE.test(value) || YAML_EDGE_OR_QUOTE_RE.test(value) || value === "")
-    return `"${value.replace(DQUOTE_RE, '\\"')}"`;
-  return value;
-}
-function serializeFrontmatter(skill) {
-  const lines = ["---"];
-  lines.push(`name: ${yamlEscape(skill.name)}`);
-  lines.push(`description: ${yamlEscape(skill.description)}`);
-  if (skill.license)
-    lines.push(`license: ${yamlEscape(skill.license)}`);
-  if (skill.compatibility)
-    lines.push(`compatibility: ${yamlEscape(skill.compatibility)}`);
-  if (skill.allowedTools?.length)
-    lines.push(`allowed-tools: ${skill.allowedTools.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.replace(DQUOTE_RE, '\\"')}"`);
-    }
-  }
-  lines.push("---");
-  return lines.join("\n");
-}
-function writeSkillToDisk(skill, targetDir) {
-  const result = validateSkillForWrite(skill);
-  if (!result.valid) {
-    const summary = result.errors.map((e) => `  - [${e.code}] ${e.message}`).join("\n");
-    throw new Error(`Cannot write invalid skill "${skill.name}":
-${summary}`);
-  }
-  const skillDir = join2(targetDir, skill.name);
-  mkdirSync(skillDir, { recursive: true });
-  const frontmatter = serializeFrontmatter(skill);
-  const bodyTrimmed = skill.instructions ? skill.instructions.replace(LEADING_NEWLINES_RE, "") : "";
-  const content = bodyTrimmed ? `${frontmatter}
-
-${bodyTrimmed}
-` : `${frontmatter}
-`;
-  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, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3 } from "path";
-async function resolveSkills(config) {
-  const sourcedPaths = [];
-  let writeDir;
-  if (!config.skipDefaultPaths) {
-    sourcedPaths.push(...getDefaultScanPaths());
-  }
-  for (const p of config.scan ?? []) {
-    sourcedPaths.push({ path: p, source: inferSource(p) });
-  }
-  if (config.write?.length) {
-    writeDir = mkdtempSync(join3(tmpdir(), "zidane-skills-"));
-    writeSkillsToDisk(config.write, writeDir);
-    sourcedPaths.push({ path: writeDir, source: "inline" });
-  }
-  let skills = await discoverSkills(sourcedPaths);
-  if (config.trustProjectSkills === false) {
-    skills = skills.filter((s) => s.source !== void 0 && s.source !== "project");
-  }
-  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));
-  }
-  const cleanup = writeDir ? () => {
-    try {
-      rmSync(writeDir, { recursive: true, force: true });
-    } catch {
-    }
-  } : () => {
-  };
-  return { skills: filtered, cleanup };
-}
-
-// 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) {
-      const message = err instanceof Error ? err.message : String(err);
-      replacements.push({ index, length, output: `[command error: ${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;
-}
-
-export {
-  createSkillActivationState,
-  validateSkillName,
-  validateSkillForWrite,
-  validateResourcePath,
-  parseAllowedToolPattern,
-  matchesAllowedTool,
-  isToolAllowedByUnion,
-  IMPLICITLY_ALLOWED_SKILL_TOOLS,
-  installAllowedToolsGate,
-  escapeXml,
-  buildCatalog,
-  parseFrontmatter,
-  parseSkillFile,
-  getDefaultScanPaths,
-  inferSource,
-  discoverSkills,
-  writeSkillToDisk,
-  writeSkillsToDisk,
-  resolveSkills,
-  interpolateShellCommands
-};