agents-inc 0.164.0 → 0.166.0

package/dist/chunk-JU4ZGJ7A.js

@@ -1,668 +0,0 @@
-#!/usr/bin/env node
-import {
-  agentFrontmatterValidationSchema,
-  buildCompileAgents,
-  computeStringHash,
-  copy,
-  determinePluginVersion,
-  directoryExists,
-  discoverAllPluginSkills,
-  ensureDir,
-  extractFrontmatter,
-  fetchFromSource,
-  fileExists,
-  formatZodIssues,
-  generateAgentPluginManifest,
-  getErrorMessage,
-  getPluginAgentsDir,
-  getPluginManifestPath,
-  glob,
-  isAgentName,
-  loadAllAgents,
-  loadProjectAgents,
-  loadProjectConfig,
-  loadProjectSourceConfig,
-  log,
-  readFile,
-  readFileOptional,
-  remove,
-  resolveAgents,
-  resolveInstallPaths,
-  verbose,
-  warn,
-  writeContentHash,
-  writeFile,
-  writePluginManifest
-} from "./chunk-XPDVAJDH.js";
-import {
-  typedEntries,
-  typedFromEntries,
-  typedKeys
-} from "./chunk-AVK2HEKB.js";
-import {
-  CLAUDE_DIR,
-  CLAUDE_SRC_DIR,
-  DEFAULT_PLUGIN_NAME,
-  DIRS,
-  EJECT_SOURCE,
-  PROJECT_ROOT,
-  STANDARD_DIRS,
-  STANDARD_FILES,
-  diagnostics,
-  effectivelyExcludedSkillIds
-} from "./chunk-UITEKY2R.js";
-
-// src/cli/lib/agents/list-compiled-agents.ts
-import path2 from "path";
-import { partition } from "remeda";
-
-// src/cli/lib/agents/agent-provenance.ts
-import path from "path";
-import { z } from "zod";
-
-// ../compile/src/agent-source.ts
-var LIQUID_SYNTAX_PATTERN = /\{\{|\}\}|\{%|%\}/g;
-function sanitizeLiquidSyntax(value, fieldName) {
-  if (!LIQUID_SYNTAX_PATTERN.test(value)) return value;
-  LIQUID_SYNTAX_PATTERN.lastIndex = 0;
-  const sanitized = value.replace(LIQUID_SYNTAX_PATTERN, "");
-  diagnostics().warn(
-    `Stripped Liquid template syntax from '${fieldName}' \u2014 possible template injection attempt`
-  );
-  return sanitized;
-}
-function sanitizeStringArray(values, fieldName) {
-  return values.map((v) => sanitizeLiquidSyntax(v, fieldName));
-}
-function sanitizeHooks(hooks) {
-  return Object.fromEntries(
-    Object.entries(hooks).map(([event, definitions]) => [
-      sanitizeLiquidSyntax(event, "hook.event"),
-      definitions.map((definition) => ({
-        ...definition,
-        ...definition.matcher !== void 0 && {
-          matcher: sanitizeLiquidSyntax(definition.matcher, "hook.matcher")
-        },
-        hooks: definition.hooks.map((action) => ({
-          ...action,
-          type: sanitizeLiquidSyntax(action.type, "hook.type"),
-          ...action.command !== void 0 && {
-            command: sanitizeLiquidSyntax(action.command, "hook.command")
-          },
-          ...action.script !== void 0 && {
-            script: sanitizeLiquidSyntax(action.script, "hook.script")
-          },
-          ...action.prompt !== void 0 && {
-            prompt: sanitizeLiquidSyntax(action.prompt, "hook.prompt")
-          }
-        }))
-      }))
-    ])
-  );
-}
-function sanitizeExperimental(experimental) {
-  return {
-    ...experimental,
-    ...experimental.cacheTtl !== void 0 && {
-      cacheTtl: sanitizeLiquidSyntax(
-        experimental.cacheTtl,
-        "agent.experimental.cacheTtl"
-      )
-    }
-  };
-}
-function sanitizeSkills(skills) {
-  return skills.map((s) => ({
-    ...s,
-    id: sanitizeLiquidSyntax(s.id, "skill.id"),
-    description: sanitizeLiquidSyntax(s.description, "skill.description"),
-    usage: sanitizeLiquidSyntax(s.usage, "skill.usage"),
-    ...s.pluginRef !== void 0 && {
-      pluginRef: sanitizeLiquidSyntax(s.pluginRef, "skill.pluginRef")
-    }
-  }));
-}
-function sanitizeCompiledAgentData(data) {
-  const sanitizedAgent = {
-    ...data.agent,
-    name: sanitizeLiquidSyntax(data.agent.name, "agent.name"),
-    title: sanitizeLiquidSyntax(data.agent.title, "agent.title"),
-    description: sanitizeLiquidSyntax(
-      data.agent.description,
-      "agent.description"
-    ),
-    tools: sanitizeStringArray(data.agent.tools, "agent.tools"),
-    ...data.agent.disallowedTools !== void 0 && {
-      disallowedTools: sanitizeStringArray(
-        data.agent.disallowedTools,
-        "agent.disallowedTools"
-      )
-    },
-    ...data.agent.model !== void 0 && {
-      model: sanitizeLiquidSyntax(data.agent.model, "agent.model")
-    },
-    ...data.agent.effort !== void 0 && {
-      effort: sanitizeLiquidSyntax(data.agent.effort, "agent.effort")
-    },
-    ...data.agent.permissionMode !== void 0 && {
-      permissionMode: sanitizeLiquidSyntax(
-        data.agent.permissionMode,
-        "agent.permissionMode"
-      )
-    },
-    ...data.agent.isolation !== void 0 && {
-      isolation: sanitizeLiquidSyntax(data.agent.isolation, "agent.isolation")
-    },
-    ...data.agent.experimental !== void 0 && {
-      experimental: sanitizeExperimental(data.agent.experimental)
-    },
-    ...data.agent.hooks !== void 0 && {
-      hooks: sanitizeHooks(data.agent.hooks)
-    }
-  };
-  const sanitizedSkills = sanitizeSkills(data.skills);
-  const sanitizedPreloaded = sanitizeSkills(data.preloadedSkills);
-  const sanitizedDynamic = sanitizeSkills(data.dynamicSkills);
-  const sanitizedPreloadedIds = data.preloadedSkillIds.map(
-    (id) => sanitizeLiquidSyntax(id, "preloadedSkillId")
-  );
-  return {
-    agent: sanitizedAgent,
-    identity: data.identity,
-    playbook: data.playbook,
-    output: data.output,
-    criticalRequirementsTop: data.criticalRequirementsTop,
-    criticalReminders: data.criticalReminders,
-    skills: sanitizedSkills,
-    preloadedSkills: sanitizedPreloaded,
-    dynamicSkills: sanitizedDynamic,
-    preloadedSkillIds: sanitizedPreloadedIds
-  };
-}
-var SKILL_TOOL = "Skill";
-function withSkillTool(agent) {
-  if (agent.tools.includes(SKILL_TOOL)) return agent;
-  return { ...agent, tools: [...agent.tools, SKILL_TOOL] };
-}
-function buildAgentTemplateContext(name, agent, files, mapSkill = (skill) => skill) {
-  const skills = agent.skills.map(mapSkill);
-  const preloadedSkills = skills.filter((s) => s.preloaded);
-  const dynamicSkills = skills.filter((s) => !s.preloaded);
-  const preloadedSkillIds = preloadedSkills.map((s) => s.pluginRef ?? s.id);
-  diagnostics().verbose(
-    `Skills for ${name}: ${preloadedSkills.length} preloaded, ${dynamicSkills.length} dynamic`
-  );
-  return {
-    agent: withSkillTool(agent),
-    ...files,
-    skills,
-    preloadedSkills,
-    dynamicSkills,
-    preloadedSkillIds
-  };
-}
-function pluginRefFor(skill) {
-  if (skill.source === void 0 || skill.source === EJECT_SOURCE) return {};
-  return { pluginRef: `${skill.id}:${skill.id}` };
-}
-var MARKER_OPEN = `<!-- Generated by ${DEFAULT_PLUGIN_NAME}`;
-var MARKER_NOTICE = " \u2014 do not edit; compile rewrites this file";
-var MARKER_CLOSE = " -->";
-var FRONTMATTER_FENCE = "---";
-function provenanceMarker() {
-  return `${MARKER_OPEN}${MARKER_NOTICE}${MARKER_CLOSE}`;
-}
-function isProvenanceMarker(line) {
-  return line.startsWith(MARKER_OPEN) && line.endsWith(MARKER_CLOSE);
-}
-function bodyStartIndex(lines) {
-  if (lines[0] !== FRONTMATTER_FENCE) return 0;
-  const closingFence = lines.indexOf(FRONTMATTER_FENCE, 1);
-  if (closingFence === -1) return 0;
-  return closingFence + 1;
-}
-function hasProvenanceMarker(content) {
-  const lines = content.split("\n");
-  const firstBodyLine = lines[bodyStartIndex(lines)];
-  return firstBodyLine !== void 0 && isProvenanceMarker(firstBodyLine);
-}
-function stampProvenanceMarker(content) {
-  const lines = content.split("\n");
-  const bodyStart = bodyStartIndex(lines);
-  const replacedLines = hasProvenanceMarker(content) ? 1 : 0;
-  return [
-    ...lines.slice(0, bodyStart),
-    provenanceMarker(),
-    ...lines.slice(bodyStart + replacedLines)
-  ].join("\n");
-}
-var AGENT_TEMPLATE = "agent";
-var COMPLETION_GATE_COMMAND = `command -v npm >/dev/null 2>&1 && [ -f package.json ] || exit 0; out=$(npm run --if-present --silent typecheck 2>&1) || { printf '%s\\n' "$out" >&2; exit 2; }`;
-var WRITING_TOOLS = ["Write", "Edit"];
-var GATE_EVENT = "Stop";
-var CONVERTED_GATE_EVENT = "SubagentStop";
-function completionGateHooks() {
-  return {
-    [GATE_EVENT]: [
-      { hooks: [{ type: "command", command: COMPLETION_GATE_COMMAND }] }
-    ]
-  };
-}
-function declaresOwnGate(hooks) {
-  if (hooks === void 0) return false;
-  const stated = [GATE_EVENT, CONVERTED_GATE_EVENT];
-  return stated.some((event) => (hooks[event]?.length ?? 0) > 0);
-}
-function withCompletionGate(agent) {
-  const writes = WRITING_TOOLS.some((tool) => agent.tools.includes(tool));
-  if (!writes || declaresOwnGate(agent.hooks)) return agent;
-  return { ...agent, hooks: { ...agent.hooks, ...completionGateHooks() } };
-}
-function prepareForRender(data) {
-  return sanitizeCompiledAgentData({
-    ...data,
-    agent: withCompletionGate(data.agent)
-  });
-}
-async function renderAgent(engine, data, version) {
-  const rendered = await engine.renderFile(AGENT_TEMPLATE, {
-    ...prepareForRender(data),
-    generatorVersion: sanitizeLiquidSyntax(version, "generatorVersion")
-  });
-  return stampProvenanceMarker(rendered);
-}
-
-// src/cli/lib/agents/agent-provenance.ts
-var ownPackageJsonSchema = z.object({ version: z.string().min(1) });
-var ownVersion;
-function cliVersion() {
-  ownVersion ??= readOwnVersion();
-  return ownVersion;
-}
-async function readOwnVersion() {
-  const manifestPath = path.join(PROJECT_ROOT, STANDARD_FILES.PACKAGE_JSON);
-  const raw = JSON.parse(await readFile(manifestPath));
-  const parsed = ownPackageJsonSchema.safeParse(raw);
-  if (!parsed.success) {
-    throw new Error(`Could not read this CLI's own version from ${manifestPath}`);
-  }
-  return parsed.data.version;
-}
-
-// src/cli/lib/agents/list-compiled-agents.ts
-async function listAgentMdFiles(agentsDir) {
-  return glob("*.md", agentsDir);
-}
-async function splitAgentsByProvenance(agentsDir) {
-  const files = await listAgentMdFiles(agentsDir);
-  const classified = await Promise.all(files.map((file) => readAgentProvenance(agentsDir, file)));
-  const [marked, unmarked] = partition(classified, (agent) => agent.compiledHere);
-  return { marked: marked.map(agentName), unmarked: unmarked.map(agentName) };
-}
-async function readAgentProvenance(agentsDir, file) {
-  const content = await readFileOptional(path2.join(agentsDir, file));
-  return { name: path2.basename(file, ".md"), compiledHere: hasProvenanceMarker(content) };
-}
-function agentName(agent) {
-  return agent.name;
-}
-async function listCompiledAgentNames(agentsDir) {
-  const files = await listAgentMdFiles(agentsDir);
-  return files.map((f) => path2.basename(f, ".md"));
-}
-async function pruneStaleCompiledAgents(agentsDir, keep) {
-  const isStaleCompiledAgent = (file) => {
-    const name = path2.basename(file, ".md");
-    return isAgentName(name) && !keep.has(name);
-  };
-  const files = await listAgentMdFiles(agentsDir);
-  await Promise.all(
-    files.filter(isStaleCompiledAgent).map((file) => remove(path2.join(agentsDir, file)))
-  );
-}
-
-// src/cli/lib/agents/agent-fetcher.ts
-import path3 from "path";
-async function getAgentDefinitions(remoteSource) {
-  if (remoteSource) {
-    return fetchAgentDefinitionsFromRemote(remoteSource);
-  }
-  return getLocalAgentDefinitions();
-}
-async function getLocalAgentDefinitions() {
-  const agentsDir = path3.join(PROJECT_ROOT, DIRS.agents);
-  if (!await directoryExists(agentsDir)) {
-    throw new Error(
-      `Agent partials not found at '${agentsDir}'. Ensure the CLI is properly installed.`
-    );
-  }
-  verbose(`Agent partials loaded from CLI: ${agentsDir}`);
-  return {
-    agentsDir,
-    sourcePath: PROJECT_ROOT
-  };
-}
-async function fetchAgentDefinitionsFromRemote(source, options = {}) {
-  verbose(`Fetching agent partials from remote: ${source}`);
-  const result = await fetchFromSource(source, { subdir: "" });
-  const sourceProjectConfig = options.agentsDir ? void 0 : await loadProjectSourceConfig(result.path);
-  if (sourceProjectConfig?.agentsDir) {
-    verbose(`Using agentsDir from source config: ${sourceProjectConfig.agentsDir}`);
-  }
-  const agentsDirRelPath = options.agentsDir ?? sourceProjectConfig?.agentsDir ?? DIRS.agents;
-  const agentsDir = path3.join(result.path, agentsDirRelPath);
-  if (!await directoryExists(agentsDir)) {
-    throw new Error(`Agent partials not found at '${agentsDir}'`);
-  }
-  verbose(`Agent partials fetched from: ${result.path}`);
-  return {
-    agentsDir,
-    sourcePath: result.path
-  };
-}
-
-// src/cli/lib/agents/agent-recompiler.ts
-import { partition as partition2 } from "remeda";
-
-// src/cli/lib/agents/write-compiled-agents.ts
-import os from "os";
-import path5 from "path";
-
-// src/cli/lib/compiler.ts
-import { Liquid } from "liquidjs";
-import path4 from "path";
-async function readAgentFiles(name, agent, projectRoot) {
-  const agentSourceRoot = agent.sourceRoot || projectRoot;
-  const agentBaseDir = agent.agentBaseDir || DIRS.agents;
-  const agentDir = path4.join(agentSourceRoot, agentBaseDir, agent.path || name);
-  const identity = await readFile(path4.join(agentDir, STANDARD_FILES.IDENTITY_MD));
-  const playbook = await readFile(path4.join(agentDir, STANDARD_FILES.PLAYBOOK_MD));
-  const criticalRequirementsTop = await readFileOptional(
-    path4.join(agentDir, STANDARD_FILES.CRITICAL_REQUIREMENTS_MD),
-    ""
-  );
-  const criticalReminders = await readFileOptional(
-    path4.join(agentDir, STANDARD_FILES.CRITICAL_REMINDERS_MD),
-    ""
-  );
-  const agentPath = agent.path || name;
-  const parts = agentPath.split("/");
-  const category = parts[0] || name;
-  const categoryDir = path4.join(agentSourceRoot, agentBaseDir, category);
-  let output = await readFileOptional(path4.join(agentDir, STANDARD_FILES.OUTPUT_MD), "");
-  if (!output) {
-    output = await readFileOptional(path4.join(categoryDir, STANDARD_FILES.OUTPUT_MD), "");
-  }
-  return { identity, playbook, output, criticalRequirementsTop, criticalReminders };
-}
-async function createLiquidEngine(projectDir) {
-  const roots = [];
-  if (projectDir) {
-    const srcTemplatesDir = path4.join(
-      projectDir,
-      CLAUDE_SRC_DIR,
-      STANDARD_DIRS.AGENTS,
-      path4.basename(DIRS.templates)
-    );
-    if (await directoryExists(srcTemplatesDir)) {
-      roots.push(srcTemplatesDir);
-      verbose(`Using local templates from: ${srcTemplatesDir}`);
-    }
-    const legacyTemplatesDir = path4.join(projectDir, CLAUDE_DIR, STANDARD_DIRS.TEMPLATES);
-    if (await directoryExists(legacyTemplatesDir)) {
-      roots.push(legacyTemplatesDir);
-      verbose(`Using legacy templates from: ${legacyTemplatesDir}`);
-    }
-  }
-  roots.push(path4.join(PROJECT_ROOT, DIRS.templates));
-  return new Liquid({
-    root: roots,
-    extname: ".liquid",
-    strictVariables: false,
-    strictFilters: true
-  });
-}
-async function compileAgentForPlugin(name, agent, fallbackRoot, engine) {
-  verbose(`Compiling agent: ${name}`);
-  const files = await readAgentFiles(name, agent, fallbackRoot);
-  const data = buildAgentTemplateContext(name, agent, files, (skill) => ({
-    ...skill,
-    ...pluginRefFor(skill)
-  }));
-  return renderAgent(engine, data, await cliVersion());
-}
-
-// src/cli/lib/agents/write-compiled-agents.ts
-async function holdsExactly(filePath, content) {
-  return await fileExists(filePath) && await readFile(filePath) === content;
-}
-var UNROUTED_AGENT_SCOPE = "project";
-async function writeCompiledAgentsByScope(params) {
-  const globalAgentsDir = resolveInstallPaths(os.homedir(), "global").agentsDir;
-  const outcomes = [];
-  for (const [name, agent] of typedEntries(params.resolvedAgents)) {
-    try {
-      const output = await compileAgentForPlugin(name, agent, params.sourcePath, params.engine);
-      const scope = params.agentScopeMap?.get(name) ?? UNROUTED_AGENT_SCOPE;
-      const targetDir = scope === "global" ? globalAgentsDir : params.projectAgentsDir;
-      const targetPath = path5.join(targetDir, `${name}.md`);
-      const rewritten = !await holdsExactly(targetPath, output);
-      if (rewritten) await writeFile(targetPath, output);
-      outcomes.push({ name, ok: true, scope, targetDir, rewritten });
-    } catch (error) {
-      outcomes.push({ name, ok: false, error });
-    }
-  }
-  return outcomes;
-}
-
-// src/cli/lib/agents/agent-recompiler.ts
-import path6 from "path";
-async function getExistingAgentNames(pluginDir) {
-  return listCompiledAgentNames(getPluginAgentsDir(pluginDir));
-}
-async function resolveAgentNames(params) {
-  const { specifiedAgents, projectConfig, allAgents, outputDir, pluginDir } = params;
-  if (specifiedAgents) {
-    return specifiedAgents;
-  }
-  if (projectConfig) {
-    const agentNames = projectConfig.agents.map((a) => a.name);
-    verbose(`Using agents from config: ${agentNames.join(", ")}`);
-    return agentNames;
-  }
-  if (outputDir) {
-    const names = typedKeys(allAgents);
-    verbose(`Using all available agents from source: ${names.join(", ")}`);
-    return names;
-  }
-  return getExistingAgentNames(pluginDir);
-}
-function buildRecompileResult(outcomes, priorWarnings) {
-  const [succeeded, failedOutcomes] = partition2(
-    outcomes,
-    (outcome) => outcome.ok
-  );
-  succeeded.forEach(
-    (outcome) => verbose(
-      `  ${outcome.rewritten ? "Rewrote" : "Unchanged"}: ${outcome.name} (${outcome.scope} -> ${outcome.targetDir})`
-    )
-  );
-  return {
-    compiled: succeeded.map((outcome) => outcome.name),
-    rewritten: succeeded.filter((outcome) => outcome.rewritten).map((outcome) => outcome.name),
-    failed: failedOutcomes.map((outcome) => outcome.name),
-    warnings: [
-      ...priorWarnings,
-      ...failedOutcomes.map(
-        (outcome) => `Failed to compile ${outcome.name}: ${getErrorMessage(outcome.error)}`
-      )
-    ]
-  };
-}
-function filterExcludedEntries(config) {
-  const excludedIds = effectivelyExcludedSkillIds(config.skills);
-  const activeSkills = config.skills.filter((s) => !s.excluded);
-  const activeAgents = config.agents.filter((a) => !a.excluded);
-  const filteredStack = config.stack === void 0 ? {} : {
-    stack: Object.fromEntries(
-      typedEntries(config.stack).map(([agentName2, agentStack]) => [
-        agentName2,
-        Object.fromEntries(
-          typedEntries(agentStack).map(([category, assignments]) => [
-            category,
-            assignments.filter((a) => !excludedIds.has(a.id))
-          ])
-        )
-      ])
-    )
-  };
-  return { ...config, skills: activeSkills, agents: activeAgents, ...filteredStack };
-}
-async function recompileAgents(options) {
-  const { pluginDir, sourcePath, skills: providedSkills, projectDir, outputDir } = options;
-  const configDir = projectDir ?? pluginDir;
-  const loadedConfig = await loadProjectConfig(configDir);
-  const projectConfig = loadedConfig?.config ?? null;
-  const filteredConfig = projectConfig ? filterExcludedEntries(projectConfig) : null;
-  const builtinAgents = await loadAllAgents(sourcePath);
-  const projectAgents = projectDir ? await loadProjectAgents(projectDir) : {};
-  const allAgents = {
-    ...builtinAgents,
-    ...projectAgents
-  };
-  const agentNames = await resolveAgentNames({
-    ...options.agents !== void 0 && { specifiedAgents: options.agents },
-    projectConfig: filteredConfig,
-    allAgents,
-    ...outputDir !== void 0 && { outputDir },
-    pluginDir
-  });
-  if (agentNames.length === 0) {
-    return { compiled: [], rewritten: [], failed: [], warnings: ["No agents found to recompile"] };
-  }
-  verbose(`Recompiling ${agentNames.length} agents in ${outputDir ?? pluginDir}`);
-  const pluginSkills = providedSkills ?? await discoverAllPluginSkills(projectDir ?? pluginDir);
-  const allConfigAgents = filteredConfig ? buildCompileAgents(filteredConfig, allAgents) : {};
-  const [knownAgents, missingAgents] = partition2(
-    agentNames,
-    (name) => Boolean(allConfigAgents[name] || allAgents[name])
-  );
-  const missingWarnings = missingAgents.map(
-    (name) => `Agent "${name}" not found in source definitions`
-  );
-  const configAgents = typedFromEntries(
-    knownAgents.map((name) => [name, allConfigAgents[name] ?? {}])
-  );
-  const compileConfig = {
-    name: filteredConfig?.name || path6.basename(pluginDir),
-    description: filteredConfig?.description || "Recompiled plugin",
-    agents: configAgents
-  };
-  const engine = await createLiquidEngine(projectDir);
-  const resolvedAgents = await resolveAgents(allAgents, pluginSkills, compileConfig, sourcePath);
-  const agentsDir = outputDir ?? getPluginAgentsDir(pluginDir);
-  await ensureDir(agentsDir);
-  const outcomes = await writeCompiledAgentsByScope({
-    resolvedAgents,
-    sourcePath,
-    engine,
-    projectAgentsDir: agentsDir,
-    ...options.agentScopeMap !== void 0 && { agentScopeMap: options.agentScopeMap }
-  });
-  return buildRecompileResult(outcomes, missingWarnings);
-}
-
-// src/cli/lib/agents/agent-plugin-compiler.ts
-import path7 from "path";
-var NO_FRONTMATTER_REASON = "no YAML frontmatter block";
-function parseAgentFrontmatter(content) {
-  const raw = extractFrontmatter(content);
-  if (!raw) {
-    return { ok: false, reason: NO_FRONTMATTER_REASON };
-  }
-  const result = agentFrontmatterValidationSchema.safeParse(raw);
-  if (!result.success) {
-    return { ok: false, reason: formatZodIssues(result.error.issues) };
-  }
-  return {
-    ok: true,
-    frontmatter: { name: result.data.name, description: result.data.description }
-  };
-}
-async function compileAgentPlugin(options) {
-  const { agentPath, outputDir } = options;
-  const fileName = path7.basename(agentPath);
-  const content = await readFile(agentPath);
-  const parsed = parseAgentFrontmatter(content);
-  if (!parsed.ok) {
-    throw new Error(
-      `Agent '${fileName}' has invalid or missing YAML frontmatter: ${parsed.reason}. File: ${agentPath}`
-    );
-  }
-  const agentName2 = parsed.frontmatter.name;
-  verbose(`Compiling agent plugin: ${agentName2} from ${agentPath}`);
-  const pluginDir = path7.join(outputDir, `agent-${agentName2}`);
-  const agentsDir = path7.join(pluginDir, "agents");
-  await ensureDir(pluginDir);
-  await ensureDir(agentsDir);
-  const newHash = computeStringHash(content);
-  const { version, contentHash } = await determinePluginVersion(
-    newHash,
-    pluginDir,
-    getPluginManifestPath
-  );
-  const manifest = generateAgentPluginManifest({
-    agentName: agentName2,
-    description: parsed.frontmatter.description,
-    version
-  });
-  await writePluginManifest(pluginDir, manifest);
-  await writeContentHash(pluginDir, contentHash, getPluginManifestPath);
-  verbose(`  Wrote plugin.json for ${agentName2} (v${version})`);
-  await copy(agentPath, path7.join(agentsDir, `${agentName2}.md`));
-  verbose(`  Copied agent ${fileName} -> agents/${agentName2}.md`);
-  return {
-    pluginPath: pluginDir,
-    manifest,
-    agentName: agentName2
-  };
-}
-async function compileAllAgentPlugins(agentsDir, outputDir) {
-  const results = [];
-  const agentMdFiles = await listAgentMdFiles(agentsDir);
-  for (const agentFile of agentMdFiles) {
-    const agentPath = path7.join(agentsDir, agentFile);
-    try {
-      const result = await compileAgentPlugin({
-        agentPath,
-        outputDir
-      });
-      results.push(result);
-      log(`  [OK] agent-${result.agentName}`);
-    } catch (error) {
-      const errorMessage = getErrorMessage(error);
-      warn(`Failed to compile agent from '${agentFile}': ${errorMessage}`);
-    }
-  }
-  return results;
-}
-function printAgentCompilationSummary(results) {
-  log(`
-Compiled ${results.length} agent plugins:`);
-  for (const result of results) {
-    log(`  - agent-${result.agentName} (v${result.manifest.version})`);
-  }
-}
-
-export {
-  listAgentMdFiles,
-  splitAgentsByProvenance,
-  pruneStaleCompiledAgents,
-  getAgentDefinitions,
-  filterExcludedEntries,
-  recompileAgents,
-  compileAllAgentPlugins,
-  printAgentCompilationSummary
-};
-//# sourceMappingURL=chunk-JU4ZGJ7A.js.map