zidane 5.14.5 → 6.0.1

package/dist/glob-DluQFSw1.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob-DluQFSw1.js","names":[],"sources":["../src/contexts/git-ls-files.ts","../src/contexts/git-ls-files-local.ts","../src/contexts/glob.ts"],"sourcesContent":["/**\n * Pure (node-free) `git ls-files` helpers shared by the gitignore-aware paths\n * of the `glob` and `grep` tools.\n *\n * `git ls-files --cached --others --exclude-standard` lists tracked files plus\n * untracked-but-not-ignored files, applying `.gitignore`, `.git/info/exclude`,\n * and the user's global excludes. Git never descends ignored directories\n * (`node_modules`, build output, …), so this is both correct and sub-second on\n * large repos — unlike a raw filesystem walk.\n *\n * This module has ZERO node imports so it can be pulled into edge/workerd\n * bundles (e.g. via the `grep` tool, which drives git through the execution\n * context's `exec` seam). The node-spawn variant lives in\n * `./git-ls-files-local`.\n */\n\n/** Argv for `git ls-files`, NUL-delimited so paths with newlines stay intact. */\nexport const GIT_LS_FILES_ARGS = ['ls-files', '--cached', '--others', '--exclude-standard', '-z'] as const\n\n/** The same invocation as a shell command string for the `exec` seam. */\nexport const GIT_LS_FILES_COMMAND = `git ${GIT_LS_FILES_ARGS.join(' ')}`\n\n/** Split NUL-delimited `git ls-files -z` output into paths. */\nexport function parseGitLsFiles(stdout: string): string[] {\n  return stdout.split('\\0').filter(p => p.length > 0)\n}\n","/**\n * Node-spawn `git ls-files` runner used by the local process context's glob.\n *\n * Kept separate from `./git-ls-files` (which stays node-free for edge bundles)\n * because this leg imports `node:child_process`.\n */\n\nimport { spawn } from 'node:child_process'\nimport { GIT_LS_FILES_ARGS, parseGitLsFiles } from './git-ls-files'\n\n/**\n * Run `git ls-files` in `cwd` and return its non-ignored paths (relative to\n * `cwd`). Returns `null` when the directory is not a git repo, git is missing,\n * or the call aborts — callers treat `null` as \"fall back to a filesystem\n * walk\". Never throws.\n */\nexport async function gitListFilesLocal(cwd: string, signal?: AbortSignal): Promise<string[] | null> {\n  return new Promise<string[] | null>((resolveP) => {\n    let child: ReturnType<typeof spawn>\n    try {\n      child = spawn('git', [...GIT_LS_FILES_ARGS], { cwd, stdio: ['ignore', 'pipe', 'pipe'] })\n    }\n    catch {\n      resolveP(null)\n      return\n    }\n    if (signal?.aborted) {\n      child.kill('SIGTERM')\n      resolveP(null)\n      return\n    }\n    const stdoutChunks: string[] = []\n    const onAbort = () => child.kill('SIGTERM')\n    signal?.addEventListener('abort', onAbort, { once: true })\n    child.stdout?.setEncoding('utf8')\n    child.stdout?.on('data', chunk => stdoutChunks.push(chunk as string))\n    child.on('error', () => {\n      signal?.removeEventListener('abort', onAbort)\n      resolveP(null)\n    })\n    child.on('close', (code) => {\n      signal?.removeEventListener('abort', onAbort)\n      if (code !== 0 || signal?.aborted) {\n        resolveP(null)\n        return\n      }\n      resolveP(parseGitLsFiles(stdoutChunks.join('')))\n    })\n  })\n}\n","import type { ListFileMetadata } from './types'\nimport { readdir, stat } from 'node:fs/promises'\nimport { dirname, resolve, sep } from 'node:path'\nimport { lazyAsync } from '../lazy'\nimport { gitListFilesLocal } from './git-ls-files-local'\n\ntype NodeGlob = (pattern: string, options: { cwd: string }) => AsyncIterable<string>\n\ninterface BunGlobInstance { scan: (options: { cwd: string, onlyFiles?: boolean, dot?: boolean }) => AsyncIterable<string> }\ntype BunGlobCtor = new (pattern: string) => BunGlobInstance\n\nconst loadNativeNodeGlob = lazyAsync(async (): Promise<NodeGlob | undefined> => {\n  const candidate = (await import('node:fs/promises') as { glob?: unknown }).glob\n  return typeof candidate === 'function' ? candidate as NodeGlob : undefined\n})\n\nfunction forcePortable(): boolean {\n  return (globalThis as { __zidaneForcePortableGlobForTests?: boolean }).__zidaneForcePortableGlobForTests === true\n}\n\nasync function loadNodeGlob(): Promise<NodeGlob | undefined> {\n  if (forcePortable())\n    return undefined\n  return loadNativeNodeGlob()\n}\n\n/**\n * Bun's `node:fs/promises.glob` buffers the entire directory walk before\n * yielding (so an early `limit` break never fires — a broad `**` pattern over\n * a large `node_modules` hangs). `Bun.Glob().scan()` streams incrementally and\n * is the fast path under Bun. Returns undefined off Bun or when tests force the\n * portable walker.\n */\nfunction loadBunGlob(): BunGlobCtor | undefined {\n  if (forcePortable())\n    return undefined\n  const bun = (globalThis as { Bun?: { Glob?: unknown } }).Bun\n  return bun && typeof bun.Glob === 'function' ? bun.Glob as BunGlobCtor : undefined\n}\n\nfunction escapeRegexChar(char: string): string {\n  return /[\\\\^$.*+?()[\\]{}|]/.test(char) ? `\\\\${char}` : char\n}\n\nexport function expandBraces(pattern: string): string[] {\n  const start = pattern.indexOf('{')\n  if (start === -1)\n    return [pattern]\n  const end = pattern.indexOf('}', start + 1)\n  if (end === -1)\n    return [pattern]\n  const body = pattern.slice(start + 1, end)\n  if (!body || !body.includes(','))\n    return [pattern]\n  return body\n    .split(',')\n    .flatMap(part => expandBraces(`${pattern.slice(0, start)}${part}${pattern.slice(end + 1)}`))\n}\n\nexport function globPatternToRegex(pattern: string): RegExp {\n  let out = '^'\n  for (let i = 0; i < pattern.length; i++) {\n    const char = pattern[i]\n    const next = pattern[i + 1]\n    if (char === '*') {\n      if (next === '*') {\n        const after = pattern[i + 2]\n        if (after === '/') {\n          out += '(?:[^/]+/)*'\n          i += 2\n        }\n        else {\n          out += '.*'\n          i += 1\n        }\n      }\n      else {\n        out += '[^/]*'\n      }\n    }\n    else if (char === '?') {\n      out += '[^/]'\n    }\n    else if (char === '[') {\n      const end = pattern.indexOf(']', i + 1)\n      if (end === -1) {\n        out += '\\\\['\n      }\n      else {\n        let cls = pattern.slice(i + 1, end)\n        if (cls.startsWith('!'))\n          cls = `^${cls.slice(1)}`\n        out += `[${cls}]`\n        i = end\n      }\n    }\n    else {\n      out += escapeRegexChar(char)\n    }\n  }\n  return new RegExp(`${out}$`)\n}\n\nexport function globLiteralPrefix(pattern: string): string {\n  const firstMeta = pattern.search(/[*?[\\]{}]/)\n  const prefix = firstMeta === -1 ? dirname(pattern) : pattern.slice(0, firstMeta)\n  const slash = prefix.lastIndexOf('/')\n  if (slash === -1)\n    return ''\n  return prefix.slice(0, slash)\n}\n\nexport function hasGlobPattern(path: string): boolean {\n  return /[*?[\\]{}]/.test(path)\n}\n\n/**\n * True when a pattern can match files outside `cwd` — an absolute path, a\n * Windows drive, or any `..` segment. Such patterns can't use the `git\n * ls-files` path (git only knows files under the repo) and fall back to the\n * filesystem walk.\n */\nfunction patternEscapesCwd(pattern: string): boolean {\n  const norm = pattern.split(sep).join('/')\n  if (norm.startsWith('/') || /^[a-z]:/i.test(norm))\n    return true\n  return norm.split('/').includes('..')\n}\n\nasync function addMetadata(cwd: string, rel: string, includeMetadata: boolean): Promise<ListFileMetadata | null> {\n  try {\n    const s = await stat(resolve(cwd, rel))\n    if (!s.isFile())\n      return null\n    return includeMetadata ? { path: rel, size: s.size, mtimeMs: s.mtimeMs } : { path: rel }\n  }\n  catch {\n    return null\n  }\n}\n\nfunction compilePattern(pattern: string): RegExp[] {\n  return expandBraces(pattern.split(sep).join('/')).map(globPatternToRegex)\n}\n\n/** Match the (already non-ignored) `git ls-files` set against the glob pattern. */\nasync function matchGitFiles(\n  gitFiles: readonly string[],\n  pattern: string,\n  cwd: string,\n  limit: number,\n  includeMetadata: boolean,\n  signal: AbortSignal | undefined,\n): Promise<ListFileMetadata[]> {\n  const regexes = compilePattern(pattern)\n  const out: ListFileMetadata[] = []\n  for (const rel of gitFiles) {\n    if (signal?.aborted || out.length >= limit)\n      break\n    if (!regexes.some(regex => regex.test(rel)))\n      continue\n    out.push(includeMetadata ? await addMetadata(cwd, rel, true) ?? { path: rel } : { path: rel })\n  }\n  return out.sort((a, b) => a.path.localeCompare(b.path))\n}\n\n/** Depth-first walk that matches against `regexes` and stops at `limit`. */\nasync function walkMatch(\n  root: string,\n  prefix: string,\n  regexes: RegExp[],\n  cwd: string,\n  limit: number,\n  includeMetadata: boolean,\n  signal: AbortSignal | undefined,\n  out: ListFileMetadata[],\n): Promise<void> {\n  if (out.length >= limit || signal?.aborted)\n    return\n  let entries: Array<{ name: string, isDirectory: () => boolean, isFile: () => boolean }>\n  try {\n    entries = await readdir(resolve(root, prefix), { encoding: 'utf8', withFileTypes: true })\n  }\n  catch {\n    return\n  }\n  for (const entry of entries) {\n    if (out.length >= limit || signal?.aborted)\n      return\n    const rel = prefix ? `${prefix}/${entry.name}` : entry.name\n    if (entry.isDirectory()) {\n      await walkMatch(root, rel, regexes, cwd, limit, includeMetadata, signal, out)\n    }\n    else if (entry.isFile() && regexes.some(regex => regex.test(rel))) {\n      out.push(includeMetadata ? await addMetadata(cwd, rel, true) ?? { path: rel } : { path: rel })\n    }\n  }\n}\n\nasync function globPortable(\n  pattern: string,\n  cwd: string,\n  limit: number,\n  includeMetadata: boolean,\n  signal: AbortSignal | undefined,\n): Promise<ListFileMetadata[]> {\n  const normalized = pattern.split(sep).join('/')\n  const startPrefix = globLiteralPrefix(normalized)\n  const regexes = expandBraces(normalized).map(globPatternToRegex)\n  const out: ListFileMetadata[] = []\n  await walkMatch(cwd, startPrefix, regexes, cwd, limit, includeMetadata, signal, out)\n  return out.sort((a, b) => a.path.localeCompare(b.path))\n}\n\nasync function collectFromIterable(\n  iter: AsyncIterable<string>,\n  cwd: string,\n  limit: number,\n  includeMetadata: boolean,\n  signal: AbortSignal | undefined,\n): Promise<ListFileMetadata[] | null> {\n  const results: ListFileMetadata[] = []\n  // A native scan can throw mid-iteration on a pathological tree (e.g. a\n  // recursive symlink cycle → ENAMETOOLONG) and there's no way to resume it.\n  // Signal the caller (null) to recover via the portable walk, which recurses\n  // only into real directories and isolates per-directory errors.\n  try {\n    for await (const rel of iter) {\n      if (signal?.aborted)\n        break\n      const entry = await addMetadata(cwd, rel, includeMetadata)\n      if (!entry)\n        continue\n      results.push(entry)\n      if (results.length >= limit)\n        break\n    }\n  }\n  catch {\n    return null\n  }\n  return results.sort((a, b) => a.path.localeCompare(b.path))\n}\n\nfunction globViaBun(\n  BunGlob: BunGlobCtor,\n  pattern: string,\n  cwd: string,\n  limit: number,\n  includeMetadata: boolean,\n  signal: AbortSignal | undefined,\n): Promise<ListFileMetadata[] | null> {\n  // `dot: true` keeps dotfile matching consistent with the Node + portable\n  // paths; `onlyFiles: true` mirrors their file-only results.\n  const scan = new BunGlob(pattern).scan({ cwd, onlyFiles: true, dot: true })\n  return collectFromIterable(scan, cwd, limit, includeMetadata, signal)\n}\n\nexport async function globFilesLocal(\n  pattern: string,\n  cwd: string,\n  options: { limit: number, metadata?: boolean, gitignore?: boolean, signal?: AbortSignal },\n): Promise<ListFileMetadata[]> {\n  const includeMetadata = options.metadata === true\n  const { limit, signal } = options\n\n  // Default path: intersect the pattern with git's non-ignored file set. Git\n  // skips `.gitignore`d trees (`node_modules`, build dirs) entirely, so this is\n  // both correct and fast — and never triggers the Bun `fs.glob` hang. The\n  // test-only force-portable flag also bypasses it so the filesystem walker\n  // stays directly exercisable.\n  if (options.gitignore !== false && !forcePortable() && !patternEscapesCwd(pattern)) {\n    const gitFiles = await gitListFilesLocal(cwd, signal)\n    if (gitFiles)\n      return matchGitFiles(gitFiles, pattern, cwd, limit, includeMetadata, signal)\n  }\n\n  // Fallback path: filesystem glob (gitignore disabled, not a git repo, or the\n  // pattern escapes cwd). Prefer a fast native scanner; if it throws on a\n  // pathological tree (null), recover via the portable walk.\n  const bunGlob = loadBunGlob()\n  if (bunGlob) {\n    const viaBun = await globViaBun(bunGlob, pattern, cwd, limit, includeMetadata, signal)\n    if (viaBun)\n      return viaBun\n  }\n  else {\n    const nodeGlob = await loadNodeGlob()\n    if (nodeGlob) {\n      const viaNode = await collectFromIterable(nodeGlob(pattern, { cwd }), cwd, limit, includeMetadata, signal)\n      if (viaNode)\n        return viaNode\n    }\n  }\n\n  return globPortable(pattern, cwd, limit, includeMetadata, signal)\n}\n\n// `globFilesViaShell` moved to `./glob-shell` (node-free) so remote-only\n// contexts can import it without pulling this module's `node:fs` imports.\n// Re-exported here for back-compat.\nexport { globFilesViaShell } from './glob-shell'\n"],"mappings":"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"}

package/dist/glob-shell-rJMoCIGb.js

@@ -1,21 +0,0 @@
-//#region src/contexts/glob-shell.ts
-const SAFE_GLOB_PATTERN_RE = /^[\w./*?[\]{}!,^@+-]+$/;
-/**
-* Match files under the execution context's cwd by shelling out to `find`.
-* The `exec` callback runs the command in the target context (sandbox, docker,
-* remote); results are returned as cwd-relative paths, sorted, capped at
-* `limit`.
-*/
-async function globFilesViaShell(pattern, exec, limit) {
-	if (!SAFE_GLOB_PATTERN_RE.test(pattern)) throw new Error("Glob pattern contains unsupported characters (shell fallback only allows path/glob metacharacters)");
-	const result = await exec(!pattern.includes("/") ? `find . -type f -name '${pattern}'` : `find . -type f -path './${pattern}'`);
-	if (result.exitCode !== 0 && !result.stdout.trim()) {
-		const detail = result.stderr.trim() || `find exited with code ${result.exitCode}`;
-		throw new Error(`file matching requires \`find\` in the execution context (${detail}). Use the \`shell\` tool, or \`list_files\` for a single directory.`);
-	}
-	return result.stdout.split("\n").map((line) => line.replace(/^\.\//, "")).filter((line) => line.length > 0).sort().slice(0, limit);
-}
-//#endregion
-export { globFilesViaShell as t };
-
-//# sourceMappingURL=glob-shell-rJMoCIGb.js.map

package/dist/glob-shell-rJMoCIGb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"glob-shell-rJMoCIGb.js","names":[],"sources":["../src/contexts/glob-shell.ts"],"sourcesContent":["/**\n * Shell-driven file matching — the node-free half of `./glob`.\n *\n * `globFilesViaShell` runs `find` through a caller-supplied `exec` callback, so\n * it has ZERO Node imports (no `node:fs`, no `node:child_process`). It lives in\n * its own module so remote-only contexts (`createSandboxContext`) can import it\n * without dragging the local-filesystem glob (and its `node:fs/promises`\n * imports) into a workerd/edge bundle. `./glob` re-exports it for back-compat.\n */\n\nimport type { ExecResult } from './types'\n\nconst SAFE_GLOB_PATTERN_RE = /^[\\w./*?[\\]{}!,^@+-]+$/\n\n/**\n * Match files under the execution context's cwd by shelling out to `find`.\n * The `exec` callback runs the command in the target context (sandbox, docker,\n * remote); results are returned as cwd-relative paths, sorted, capped at\n * `limit`.\n */\nexport async function globFilesViaShell(\n  pattern: string,\n  exec: (command: string) => Promise<ExecResult>,\n  limit: number,\n): Promise<string[]> {\n  if (!SAFE_GLOB_PATTERN_RE.test(pattern))\n    throw new Error('Glob pattern contains unsupported characters (shell fallback only allows path/glob metacharacters)')\n\n  const useBasename = !pattern.includes('/')\n  const finder = useBasename\n    ? `find . -type f -name '${pattern}'`\n    : `find . -type f -path './${pattern}'`\n  const result = await exec(finder)\n  if (result.exitCode !== 0 && !result.stdout.trim()) {\n    const detail = result.stderr.trim() || `find exited with code ${result.exitCode}`\n    throw new Error(`file matching requires \\`find\\` in the execution context (${detail}). Use the \\`shell\\` tool, or \\`list_files\\` for a single directory.`)\n  }\n\n  return result.stdout\n    .split('\\n')\n    .map(line => line.replace(/^\\.\\//, ''))\n    .filter(line => line.length > 0)\n    .sort()\n    .slice(0, limit)\n}\n"],"mappings":";AAYA,MAAM,uBAAuB;;;;;;;AAQ7B,eAAsB,kBACpB,SACA,MACA,OACmB;CACnB,IAAI,CAAC,qBAAqB,KAAK,OAAO,GACpC,MAAM,IAAI,MAAM,oGAAoG;CAMtH,MAAM,SAAS,MAAM,KAHN,CADM,QAAQ,SAAS,GAAG,IAErC,yBAAyB,QAAQ,KACjC,2BAA2B,QAAQ,EACP;CAChC,IAAI,OAAO,aAAa,KAAK,CAAC,OAAO,OAAO,KAAK,GAAG;EAClD,MAAM,SAAS,OAAO,OAAO,KAAK,KAAK,yBAAyB,OAAO;EACvE,MAAM,IAAI,MAAM,6DAA6D,OAAO,qEAAqE;CAC3J;CAEA,OAAO,OAAO,OACX,MAAM,IAAI,EACV,KAAI,SAAQ,KAAK,QAAQ,SAAS,EAAE,CAAC,EACrC,QAAO,SAAQ,KAAK,SAAS,CAAC,EAC9B,KAAK,EACL,MAAM,GAAG,KAAK;AACnB"}

package/dist/index-B3ciFUZx.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B3ciFUZx.d.ts","names":[],"sources":["../src/contexts/process.ts"],"mappings":";;;iBA2HgB,oBAAA,CAAqB,MAAA,GAAS,WAAA,GAAc,gBAAgB"}

package/dist/index-CIbemeZd.d.ts

@@ -1,316 +0,0 @@
-import { B as SkillSource, L as SkillConfig, R as SkillDiagnostic, V as SkillsConfig, f as SkillActivationState, r as AgentHooks } from "./agent-DCtsviti.js";
-import { c as ExecutionContext, l as ExecutionHandle } from "./types-BqdTeBaC.js";
-import { Hookable } from "hookable";
-
-//#region src/skills/allowed-tools.d.ts
-/** Tools that are always allowed regardless of the active skills' allow-list. */
-declare const IMPLICITLY_ALLOWED_SKILL_TOOLS: readonly string[];
-/**
- * Register `tool:gate` / `mcp:tool:gate` handlers that enforce the union of
- * `allowedTools` across active skills.
- *
- * No-op when no active skill declares an allow-list (permissive default —
- * matches the spec's "experimental" note for `allowed-tools`).
- *
- * Returns an `uninstall` fn. The agent calls this at run end to detach the
- * handlers and prevent cross-run hook leaks.
- */
-declare function installAllowedToolsGate(hooks: Hookable<AgentHooks>, state: SkillActivationState): () => void;
-//#endregion
-//#region src/skills/catalog.d.ts
-interface BuildCatalogOptions {
-  /**
-   * When true (the default), the prose instructs the model to call
-   * `skills_use`. Set to false when `SkillsConfig.tool === false` so the
-   * system prompt matches the active activation mechanism.
-   */
-  skillsToolRegistered?: boolean;
-  /**
-   * Name of the tool the model should use to read `SKILL.md` files when
-   * `skillsToolRegistered` is false. Defaults to `'read_file'`.
-   */
-  readToolName?: string;
-}
-/**
- * Build the skill catalog XML and behavioral instructions for the system prompt.
- */
-declare function buildCatalog(skills: SkillConfig[], options?: BuildCatalogOptions): string;
-//#endregion
-//#region src/skills/discovery.d.ts
-interface ParsedSkillFile {
-  frontmatter: Record<string, unknown>;
-  body: string;
-  diagnostics: SkillDiagnostic[];
-}
-/**
- * Parse a SKILL.md file into frontmatter + body.
- *
- * Uses a simple regex-based YAML extractor that handles:
- * - Flat key: value pairs
- * - Quoted values
- * - One-level nested maps (for `metadata:`)
- * - One-level nested block lists, `key:` followed by indented `- item`
- *   lines (for `allowed-tools` and any future array fields). Items are
- *   unquoted with the same rules as scalar values.
- * - Flow-style scalars are preserved verbatim — interpretation (e.g.
- *   `[a, b]` as a list) is left to per-field consumers via
- *   {@link takeStringOrArray}.
- * - Lenient recovery from unquoted-colon values (e.g.
- *   `description: Use when: the user asks …`) via a quote-wrap retry.
- */
-declare function parseFrontmatter(content: string): ParsedSkillFile;
-interface ParseSkillOptions {
-  /** Source tag to attach to the returned SkillConfig. */
-  source?: SkillSource;
-}
-/**
- * Parse a SKILL.md file into a SkillConfig (lenient).
- *
- * Returns `null` only when the skill is fundamentally unusable:
- * - The file is missing
- * - The description is absent (required by spec for disclosure)
- *
- * All other issues are surfaced as `SkillConfig.diagnostics` with severity
- * `warning`. Deprecated top-level fields (`paths`, `model`, `thinking`) are
- * auto-migrated into `metadata['zidane.*']`.
- */
-declare function parseSkillFile(filePath: string, options?: ParseSkillOptions): Promise<SkillConfig | null>;
-/** A scan path paired with the source tag that should be attached to any skills found in it. */
-interface SourcedScanPath {
-  path: string;
-  source: SkillSource;
-}
-/**
- * Return the default scan paths tagged by source. Project-scope paths come
- * first; their skills therefore win on name collisions against user-scope
- * skills (first-found wins in discovery).
- */
-declare function getDefaultScanPaths(): SourcedScanPath[];
-/**
- * Infer a source tag for a user-provided scan path.
- * Paths under `$HOME` are treated as 'user'; everything else as 'project'.
- */
-declare function inferSource(path: string): SkillSource;
-/**
- * Discover skills from sourced filesystem paths.
- * Each path is scanned for subdirectories containing SKILL.md.
- * Earlier paths have higher priority (first-found wins on name collision).
- *
- * `signal` is checked between each `parseSkillFile` so a rapid `cwd` switch
- * in the host (TUI / GUI) can stop a long scan without leaking I/O. Aborts
- * reject with the signal's `reason` (or a default `AbortError`) — same shape
- * `AbortSignal.throwIfAborted()` produces in modern runtimes.
- */
-declare function discoverSkills(paths: SourcedScanPath[], signal?: AbortSignal): Promise<SkillConfig[]>;
-//#endregion
-//#region src/skills/interpolate.d.ts
-/**
- * Replace every !\`command\` pattern with a static placeholder, without
- * executing anything. Used when shell interpolation is disabled
- * (`SkillsConfig.allowShellInterpolation: false`): skill content can be
- * third-party input, and running its embedded commands on activation
- * bypasses the allowed-tools gate.
- */
-declare function stripShellInterpolations(instructions: string): string;
-interface InterpolateShellCommandsOptions {
-  /**
-   * Called once per !\`command\` that failed (non-zero exit or exec throw)
-   * with the command text and the inline placeholder it was replaced with.
-   * Lets callers surface a visible warning instead of activation silently
-   * proceeding on partial content.
-   */
-  onFailure?: (command: string, placeholder: string) => void;
-  /**
-   * Optional per-command approval gate, invoked BEFORE each !\`command\` runs.
-   * Return `false` to skip executing that command — it is replaced with a
-   * `[shell interpolation not approved]` placeholder instead of its output.
-   * When omitted, every command runs (back-compat).
-   */
-  approve?: (command: string) => boolean | Promise<boolean>;
-}
-/**
- * Interpolate shell commands in skill instructions.
- *
- * Runs each !\`command\` through the execution context and replaces
- * the placeholder with the command's stdout. If a command fails,
- * the placeholder is replaced with an error message (and
- * `options.onFailure` is notified when provided).
- *
- * @param instructions - Raw skill instructions with potential !\`command\` patterns
- * @param execution - The execution context to run commands in
- * @param handle - The active execution handle
- * @returns Instructions with all !\`command\` patterns replaced by output
- */
-declare function interpolateShellCommands(instructions: string, execution: ExecutionContext, handle: ExecutionHandle, options?: InterpolateShellCommandsOptions): Promise<string>;
-//#endregion
-//#region src/skills/resolve.d.ts
-/**
- * Resolved-skills bundle: the materialized list plus a `cleanup` fn that
- * removes any temporary directory created for `config.write` skills.
- *
- * Inline skills must live on disk for the lifetime of the agent (the
- * `skills_read` / `skills_run_script` tools resolve relative paths against
- * `baseDir`), so cleanup is deferred to `agent.destroy()`. When no temp
- * directory was created, `cleanup` is a no-op.
- */
-interface ResolvedSkillsBundle {
-  skills: SkillConfig[];
-  cleanup: () => void;
-}
-/**
- * Resolve all skills from a SkillsConfig:
- *
- * 1. Materialize `config.write` entries to a temp directory, tagged as `inline`
- * 2. Combine with default + user-provided scan paths (project-first, user-next)
- * 3. Run lenient disk discovery
- * 4. Merge with any host-provided `config.catalog`. Catalog entries seed the
- *    resolution map FIRST, so they shadow disk-discovered skills with the
- *    same name (shadow diagnostic attached to the winner — same shape as
- *    the disk-vs-disk collision case).
- * 5. Apply filters: optional project-skill trust gate, `exclude`,
- *    `enabled` allowlist
- *
- * Returns `{ skills, cleanup }` — call `cleanup()` on agent destroy to remove
- * the temp directory created for inline `config.write` skills. The agent
- * factory wires this automatically; standalone callers must invoke it
- * themselves to avoid leaking OS temp.
- */
-declare function resolveSkills(config: SkillsConfig): Promise<ResolvedSkillsBundle>;
-//#endregion
-//#region src/skills/validate.d.ts
-/**
- * A single issue surfaced by skill-authoring validation.
- * Distinct from `ValidationResult` in `tools/validation.ts` (tool-input JSON
- * schema validation) — different domain, different module.
- */
-interface SkillValidationIssue {
-  /** Stable machine-readable code for consumer matching. */
-  code: string;
-  /** Human-readable description. */
-  message: string;
-  /** Frontmatter field name the issue relates to, when applicable. */
-  field?: string;
-}
-interface SkillValidationResult {
-  valid: boolean;
-  errors: SkillValidationIssue[];
-}
-/**
- * Validate a skill name per the spec:
- * - 1–64 characters
- * - Lowercase alphanumeric + hyphens only
- * - Must not start or end with a hyphen
- * - Must not contain consecutive hyphens
- *
- * The parent-directory match is validated separately (it requires knowing the
- * skill's `location`, which this function does not).
- */
-declare function validateSkillName(name: string): boolean;
-/**
- * Strict validation for a skill that is about to be authored / written to disk.
- * Rejects anything that would violate the spec. Use the lenient parser path
- * (`parseSkillFile`) for loading third-party skills.
- */
-declare function validateSkillForWrite(skill: SkillConfig): SkillValidationResult;
-/**
- * Validate that `relPath` stays inside `baseDir` when resolved.
- *
- * Rejects:
- * - Absolute paths (`/etc/passwd`, `C:\…`)
- * - Parent traversal (`..` segments that escape baseDir)
- * - Null-byte tricks
- *
- * Returns `{ valid: true, absolutePath }` on success or `{ valid: false, error }`
- * with a human-readable reason.
- */
-declare function validateResourcePath(relPath: string, baseDir: string): {
-  valid: true;
-  absolutePath: string;
-} | {
-  valid: false;
-  error: string;
-};
-/**
- * Symlink-hardened variant of {@link validateResourcePath}: after the lexical
- * check passes, resolve both the target and `baseDir` through `realpath` and
- * re-confirm the target still lives under the skill directory. A symlink
- * placed inside the skill dir pointing at e.g. `/etc/passwd` passes the
- * lexical check but fails here.
- *
- * Falls back to the lexical verdict when `realpath` fails (target or baseDir
- * not present on the LOCAL filesystem) — the common causes are a remote
- * execution context (docker/sandbox, where the local realpath is meaningless
- * and the remote side resolves the path itself) or a not-yet-existing file.
- * The returned `absolutePath` is always the lexical one: it's what the
- * execution context resolves; realpath here is verification only.
- */
-declare function validateResourcePathReal(relPath: string, baseDir: string): Promise<{
-  valid: true;
-  absolutePath: string;
-} | {
-  valid: false;
-  error: string;
-}>;
-/**
- * Parse a single `allowed-tools` entry into its tool name + optional argument pattern.
- *
- * Examples:
- * - `Read` → `{ tool: 'Read' }`
- * - `Bash(git:*)` → `{ tool: 'Bash', argPrefix: 'git' }`
- */
-declare function parseAllowedToolPattern(entry: string): {
-  tool: string;
-  argPrefix?: string;
-} | null;
-/**
- * Check whether a tool call (identified by its wire/displayName and argument input)
- * matches a skill's allow-list entry.
- *
- * Matching rules (Zidane's interpretation of the spec's unspecified syntax):
- * - Exact match: displayName === pattern (no parens).
- * - Prefix match: for `Tool(arg:*)`, displayName === 'Tool' AND **any** string
- *   value in the input object starts with `arg`. This is intentionally
- *   permissive: it doesn't depend on a convention about which property carries
- *   the "command" (schemas vary across tools), and for the common
- *   `shell({ command: 'git …' })` shape it behaves identically to a "primary
- *   string" rule.
- * - For tools whose inputs carry no string values, the arg-match returns false.
- */
-declare function matchesAllowedTool(displayName: string, input: Record<string, unknown>, pattern: string): boolean;
-/**
- * Test whether a tool call is allowed by the union of `allowedTools` across a set
- * of active skills. Returns `true` when the union is empty (permissive default)
- * OR when any entry matches.
- */
-declare function isToolAllowedByUnion(displayName: string, input: Record<string, unknown>, union: readonly string[]): boolean;
-//#endregion
-//#region src/skills/writer.d.ts
-/**
- * Write a `SkillConfig` to disk as a proper skill directory with SKILL.md.
- * Returns the path to the written SKILL.md file.
- *
- * Throws if the skill fails `validateSkillForWrite` — the authoring path is
- * strict on purpose. For loading third-party skills, use `parseSkillFile`
- * directly (lenient).
- */
-declare function writeSkillToDisk(skill: SkillConfig, targetDir: string): string;
-/**
- * Write multiple `SkillConfig` objects to a target directory.
- * Each skill gets its own subdirectory with a SKILL.md file.
- * Returns the target directory path (for use as a scan path).
- */
-declare function writeSkillsToDisk(skills: SkillConfig[], targetDir: string): string;
-//#endregion
-//#region src/skills/index.d.ts
-/**
- * Define an inline skill configuration.
- *
- * Strict-validates at author-time — throws if the config would be rejected by
- * `writeSkillToDisk` or the spec. Source defaults to `'inline'`.
- */
-declare function defineSkill(config: Omit<SkillConfig, 'source'> & {
-  source?: SkillConfig['source'];
-}): SkillConfig;
-//#endregion
-export { buildCatalog as C, parseSkillFile as S, installAllowedToolsGate as T, SourcedScanPath as _, SkillValidationResult as a, inferSource as b, parseAllowedToolPattern as c, validateSkillForWrite as d, validateSkillName as f, stripShellInterpolations as g, interpolateShellCommands as h, SkillValidationIssue as i, validateResourcePath as l, InterpolateShellCommandsOptions as m, writeSkillToDisk as n, isToolAllowedByUnion as o, resolveSkills as p, writeSkillsToDisk as r, matchesAllowedTool as s, defineSkill as t, validateResourcePathReal as u, discoverSkills as v, IMPLICITLY_ALLOWED_SKILL_TOOLS as w, parseFrontmatter as x, getDefaultScanPaths as y };
-//# sourceMappingURL=index-CIbemeZd.d.ts.map

package/dist/index-CIbemeZd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CIbemeZd.d.ts","names":[],"sources":["../src/skills/allowed-tools.ts","../src/skills/catalog.ts","../src/skills/discovery.ts","../src/skills/interpolate.ts","../src/skills/resolve.ts","../src/skills/validate.ts","../src/skills/writer.ts","../src/skills/index.ts"],"mappings":"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"}