@skillkit/core 1.6.1 → 1.6.2

package/dist/index.js

@@ -15782,13 +15782,864 @@ var AuditLogger = class {
     }).join("\n\n");
   }
 };
+
+// src/agents/types.ts
+import { z as z5 } from "zod";
+var AgentPermissionMode = z5.enum([
+  "default",
+  // Normal permission prompts
+  "plan",
+  // Plan mode - ask before executing
+  "auto-edit",
+  // Auto-accept edits
+  "full-auto",
+  // Auto-accept everything (dangerous)
+  "bypassPermissions"
+  // Skip all permission checks
+]);
+var AgentHook = z5.object({
+  /** Hook event type */
+  type: z5.enum([
+    "PreToolUse",
+    "PostToolUse",
+    "Stop",
+    "SubagentStop",
+    "SessionStart",
+    "SessionEnd"
+  ]),
+  /** Command to run */
+  command: z5.string(),
+  /** Timeout in milliseconds */
+  timeout: z5.number().optional(),
+  /** Run only once */
+  once: z5.boolean().optional(),
+  /** Tool matcher (for PreToolUse/PostToolUse) */
+  matcher: z5.string().optional()
+});
+var AgentFrontmatter = z5.object({
+  /** Agent name (kebab-case) */
+  name: z5.string().min(1).max(64).regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "Agent name must be lowercase alphanumeric with hyphens"),
+  /** Description of what this agent does */
+  description: z5.string().min(1).max(1024),
+  /** Model to use (e.g., 'opus', 'sonnet', 'haiku') */
+  model: z5.string().optional(),
+  /** Permission mode for this agent */
+  permissionMode: AgentPermissionMode.optional(),
+  /** Tools this agent cannot use */
+  disallowedTools: z5.array(z5.string()).optional(),
+  /** Allowed tools for this agent */
+  allowedTools: z5.union([
+    z5.array(z5.string()),
+    z5.string()
+    // YAML-style list in frontmatter
+  ]).optional(),
+  /** Agent-scoped hooks */
+  hooks: z5.array(AgentHook).optional(),
+  /** Skills to auto-load for this agent */
+  skills: z5.array(z5.string()).optional(),
+  /** Run in forked sub-agent context */
+  context: z5.enum(["fork", "inline"]).optional(),
+  /** Version */
+  version: z5.string().optional(),
+  /** Author */
+  author: z5.string().optional(),
+  /** Tags for categorization */
+  tags: z5.array(z5.string()).optional(),
+  /** Whether agent is user-invocable via @mention */
+  "user-invocable": z5.boolean().optional(),
+  /** Argument hint for agent invocation */
+  "argument-hint": z5.string().optional()
+});
+var AgentLocation = z5.enum(["project", "global"]);
+var AgentMetadata = z5.object({
+  name: z5.string(),
+  description: z5.string(),
+  source: z5.string(),
+  sourceType: z5.enum(["github", "gitlab", "bitbucket", "local"]),
+  subpath: z5.string().optional(),
+  installedAt: z5.string().datetime(),
+  updatedAt: z5.string().datetime().optional(),
+  enabled: z5.boolean().default(true),
+  version: z5.string().optional(),
+  checksum: z5.string().optional()
+});
+var AGENT_DISCOVERY_PATHS = {
+  "claude-code": [".claude/agents"],
+  "cursor": [".cursor/agents"],
+  "codex": [".codex/agents"],
+  "gemini-cli": [".gemini/agents"],
+  "opencode": [".opencode/agents"],
+  "antigravity": [".antigravity/agents"],
+  "amp": [".amp/agents"],
+  "clawdbot": [".clawdbot/agents", "agents"],
+  "droid": [".factory/agents"],
+  "github-copilot": [".github/agents", ".github/copilot/agents"],
+  "goose": [".goose/agents"],
+  "kilo": [".kilocode/agents"],
+  "kiro-cli": [".kiro/agents"],
+  "roo": [".roo/agents"],
+  "trae": [".trae/agents"],
+  "windsurf": [".windsurf/agents"],
+  "universal": ["agents", ".agents"]
+};
+var ALL_AGENT_DISCOVERY_PATHS = [
+  "agents",
+  ".agents",
+  ".claude/agents",
+  ".cursor/agents",
+  ".codex/agents",
+  ".gemini/agents",
+  ".opencode/agents",
+  ".antigravity/agents",
+  ".amp/agents",
+  ".clawdbot/agents",
+  ".factory/agents",
+  ".github/agents",
+  ".github/copilot/agents",
+  ".goose/agents",
+  ".kilocode/agents",
+  ".kiro/agents",
+  ".roo/agents",
+  ".trae/agents",
+  ".windsurf/agents"
+];
+var CUSTOM_AGENT_FORMAT_MAP = {
+  "claude-code": "claude-agent",
+  "cursor": "cursor-agent",
+  "codex": "claude-agent",
+  "gemini-cli": "claude-agent",
+  "opencode": "claude-agent",
+  "antigravity": "claude-agent",
+  "amp": "claude-agent",
+  "clawdbot": "claude-agent",
+  "droid": "claude-agent",
+  "github-copilot": "universal",
+  "goose": "claude-agent",
+  "kilo": "claude-agent",
+  "kiro-cli": "claude-agent",
+  "roo": "claude-agent",
+  "trae": "claude-agent",
+  "windsurf": "universal",
+  "universal": "universal"
+};
+
+// src/agents/parser.ts
+import { existsSync as existsSync30, readFileSync as readFileSync23, statSync as statSync7 } from "fs";
+import { join as join30, basename as basename10, extname as extname2 } from "path";
+import { parse as parseYaml10 } from "yaml";
+function extractAgentFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) {
+    return null;
+  }
+  try {
+    return parseYaml10(match[1]);
+  } catch {
+    return null;
+  }
+}
+function extractAgentContent(content) {
+  const withoutFrontmatter = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n?/, "");
+  return withoutFrontmatter.trim();
+}
+function parseAgentFile(filePath, location = "project") {
+  if (!existsSync30(filePath)) {
+    return null;
+  }
+  if (extname2(filePath) !== ".md") {
+    return null;
+  }
+  try {
+    const content = readFileSync23(filePath, "utf-8");
+    const rawFrontmatter = extractAgentFrontmatter(content);
+    const agentContent = extractAgentContent(content);
+    if (!rawFrontmatter) {
+      const name = basename10(filePath, ".md");
+      return {
+        name,
+        description: "No description available",
+        path: filePath,
+        location,
+        frontmatter: {
+          name,
+          description: "No description available"
+        },
+        content: agentContent,
+        enabled: true
+      };
+    }
+    const parsed = AgentFrontmatter.safeParse(rawFrontmatter);
+    if (!parsed.success) {
+      const name = rawFrontmatter.name || basename10(filePath, ".md");
+      return {
+        name,
+        description: rawFrontmatter.description || "No description available",
+        path: filePath,
+        location,
+        frontmatter: {
+          name,
+          description: rawFrontmatter.description || "No description available",
+          ...rawFrontmatter
+        },
+        content: agentContent,
+        enabled: true
+      };
+    }
+    const metadataPath = filePath.replace(/\.md$/, ".skillkit-agent.json");
+    const metadata = loadAgentMetadata(metadataPath);
+    return {
+      name: parsed.data.name,
+      description: parsed.data.description,
+      path: filePath,
+      location,
+      frontmatter: parsed.data,
+      content: agentContent,
+      metadata: metadata ?? void 0,
+      enabled: metadata?.enabled ?? true
+    };
+  } catch {
+    return null;
+  }
+}
+function parseAgentDir(dirPath, location = "project") {
+  const agentMdPath = join30(dirPath, "AGENT.md");
+  if (existsSync30(agentMdPath)) {
+    const agent = parseAgentFile(agentMdPath, location);
+    if (agent) {
+      agent.path = dirPath;
+    }
+    return agent;
+  }
+  const indexMdPath = join30(dirPath, "index.md");
+  if (existsSync30(indexMdPath)) {
+    const agent = parseAgentFile(indexMdPath, location);
+    if (agent) {
+      agent.path = dirPath;
+    }
+    return agent;
+  }
+  return null;
+}
+function loadAgentMetadata(metadataPath) {
+  if (!existsSync30(metadataPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync23(metadataPath, "utf-8");
+    const data = JSON.parse(content);
+    const parsed = AgentMetadata.safeParse(data);
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+function toCanonicalAgent(agent, sourceAgent) {
+  const fm = agent.frontmatter;
+  let allowedTools;
+  if (fm.allowedTools) {
+    if (typeof fm.allowedTools === "string") {
+      allowedTools = fm.allowedTools.split(/[,\n]/).map((t) => t.trim()).filter(Boolean);
+    } else {
+      allowedTools = fm.allowedTools;
+    }
+  }
+  return {
+    name: agent.name,
+    description: agent.description,
+    model: fm.model,
+    permissionMode: fm.permissionMode,
+    disallowedTools: fm.disallowedTools,
+    allowedTools,
+    hooks: fm.hooks,
+    skills: fm.skills,
+    context: fm.context,
+    version: fm.version,
+    author: fm.author,
+    tags: fm.tags,
+    userInvocable: fm["user-invocable"],
+    argumentHint: fm["argument-hint"],
+    content: agent.content,
+    sourceFormat: "claude-agent",
+    sourceAgent
+  };
+}
+function fromCanonicalAgent(canonical, _targetFormat = "claude-agent") {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${canonical.name}`);
+  lines.push(`description: ${canonical.description}`);
+  if (canonical.model) {
+    lines.push(`model: ${canonical.model}`);
+  }
+  if (canonical.permissionMode) {
+    lines.push(`permissionMode: ${canonical.permissionMode}`);
+  }
+  if (canonical.disallowedTools && canonical.disallowedTools.length > 0) {
+    lines.push("disallowedTools:");
+    for (const tool of canonical.disallowedTools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  if (canonical.allowedTools && canonical.allowedTools.length > 0) {
+    lines.push("allowed-tools:");
+    for (const tool of canonical.allowedTools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  if (canonical.hooks && canonical.hooks.length > 0) {
+    lines.push("hooks:");
+    for (const hook of canonical.hooks) {
+      lines.push(`  - type: ${hook.type}`);
+      lines.push(`    command: ${hook.command}`);
+      if (hook.timeout) lines.push(`    timeout: ${hook.timeout}`);
+      if (hook.once) lines.push(`    once: ${hook.once}`);
+      if (hook.matcher) lines.push(`    matcher: ${hook.matcher}`);
+    }
+  }
+  if (canonical.skills && canonical.skills.length > 0) {
+    lines.push("skills:");
+    for (const skill of canonical.skills) {
+      lines.push(`  - ${skill}`);
+    }
+  }
+  if (canonical.context) {
+    lines.push(`context: ${canonical.context}`);
+  }
+  if (canonical.version) {
+    lines.push(`version: "${canonical.version}"`);
+  }
+  if (canonical.author) {
+    lines.push(`author: ${canonical.author}`);
+  }
+  if (canonical.tags && canonical.tags.length > 0) {
+    lines.push(`tags: [${canonical.tags.join(", ")}]`);
+  }
+  if (canonical.userInvocable !== void 0) {
+    lines.push(`user-invocable: ${canonical.userInvocable}`);
+  }
+  if (canonical.argumentHint) {
+    lines.push(`argument-hint: "${canonical.argumentHint}"`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(canonical.content);
+  return lines.join("\n");
+}
+function readAgentContent(agentPath) {
+  if (existsSync30(agentPath) && extname2(agentPath) === ".md") {
+    try {
+      return readFileSync23(agentPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  const agentMdPath = join30(agentPath, "AGENT.md");
+  if (existsSync30(agentMdPath)) {
+    try {
+      return readFileSync23(agentMdPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  const indexMdPath = join30(agentPath, "index.md");
+  if (existsSync30(indexMdPath)) {
+    try {
+      return readFileSync23(indexMdPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function validateAgent(agentPath) {
+  const errors = [];
+  const warnings = [];
+  let filePath = agentPath;
+  if (!existsSync30(agentPath)) {
+    errors.push(`Agent file not found: ${agentPath}`);
+    return { valid: false, errors, warnings };
+  }
+  const stats = statSync7(agentPath);
+  if (stats.isDirectory()) {
+    const agentMd = join30(agentPath, "AGENT.md");
+    const indexMd = join30(agentPath, "index.md");
+    if (existsSync30(agentMd)) {
+      filePath = agentMd;
+    } else if (existsSync30(indexMd)) {
+      filePath = indexMd;
+    } else {
+      errors.push("Directory must contain AGENT.md or index.md");
+      return { valid: false, errors, warnings };
+    }
+  }
+  let content;
+  try {
+    content = readFileSync23(filePath, "utf-8");
+  } catch {
+    errors.push(`Cannot read file: ${filePath}`);
+    return { valid: false, errors, warnings };
+  }
+  const frontmatter = extractAgentFrontmatter(content);
+  if (!frontmatter) {
+    errors.push("Missing YAML frontmatter");
+    return { valid: false, errors, warnings };
+  }
+  const parsed = AgentFrontmatter.safeParse(frontmatter);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) {
+      errors.push(`${issue.path.join(".") || "frontmatter"}: ${issue.message}`);
+    }
+  }
+  if (parsed.success) {
+    const data = parsed.data;
+    const fileName = basename10(filePath, ".md");
+    if (data.name !== fileName && fileName !== "AGENT" && fileName !== "index") {
+      warnings.push(`name "${data.name}" does not match filename "${fileName}"`);
+    }
+    if (data.description && data.description.length < 20) {
+      warnings.push("description is short; consider adding more detail");
+    }
+    if (data.permissionMode === "full-auto" || data.permissionMode === "bypassPermissions") {
+      warnings.push(`permissionMode "${data.permissionMode}" is potentially dangerous`);
+    }
+  }
+  const agentContent = extractAgentContent(content);
+  if (agentContent.length < 50) {
+    warnings.push("Agent system prompt is very short");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/agents/discovery.ts
+import { existsSync as existsSync31, readdirSync as readdirSync9, statSync as statSync8 } from "fs";
+import { join as join31, extname as extname3 } from "path";
+import { homedir as homedir9 } from "os";
+function discoverAgentsInDir(dir, location) {
+  const agents = [];
+  if (!existsSync31(dir)) {
+    return agents;
+  }
+  try {
+    const entries = readdirSync9(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = join31(dir, entry.name);
+      if (entry.isFile() && extname3(entry.name) === ".md") {
+        const agent = parseAgentFile(entryPath, location);
+        if (agent) {
+          agents.push(agent);
+        }
+      } else if (entry.isDirectory()) {
+        const agent = parseAgentDir(entryPath, location);
+        if (agent) {
+          agents.push(agent);
+        }
+      }
+    }
+  } catch {
+  }
+  return agents;
+}
+function discoverAgents(rootDir) {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
+    const fullPath = join31(rootDir, searchPath);
+    if (existsSync31(fullPath)) {
+      for (const agent of discoverAgentsInDir(fullPath, "project")) {
+        if (!seen.has(agent.name)) {
+          seen.add(agent.name);
+          agents.push(agent);
+        }
+      }
+    }
+  }
+  return agents;
+}
+function discoverAgentsForAgent(rootDir, agentType) {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  const paths = AGENT_DISCOVERY_PATHS[agentType] || [];
+  for (const searchPath of paths) {
+    const fullPath = join31(rootDir, searchPath);
+    if (existsSync31(fullPath)) {
+      for (const agent of discoverAgentsInDir(fullPath, "project")) {
+        if (!seen.has(agent.name)) {
+          seen.add(agent.name);
+          agents.push(agent);
+        }
+      }
+    }
+  }
+  return agents;
+}
+function discoverGlobalAgents() {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  const home = homedir9();
+  const globalPaths = [
+    join31(home, ".claude", "agents"),
+    join31(home, ".skillkit", "agents"),
+    join31(home, ".config", "skillkit", "agents")
+  ];
+  for (const searchPath of globalPaths) {
+    if (existsSync31(searchPath)) {
+      for (const agent of discoverAgentsInDir(searchPath, "global")) {
+        if (!seen.has(agent.name)) {
+          seen.add(agent.name);
+          agents.push(agent);
+        }
+      }
+    }
+  }
+  return agents;
+}
+function findAllAgents(searchDirs) {
+  const agents = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of searchDirs) {
+    if (!existsSync31(dir)) continue;
+    const discovered = discoverAgents(dir);
+    for (const agent of discovered) {
+      if (!seen.has(agent.name)) {
+        seen.add(agent.name);
+        agents.push(agent);
+      }
+    }
+  }
+  for (const agent of discoverGlobalAgents()) {
+    if (!seen.has(agent.name)) {
+      seen.add(agent.name);
+      agents.push(agent);
+    }
+  }
+  return agents;
+}
+function findAgent(name, searchDirs) {
+  for (const dir of searchDirs) {
+    if (!existsSync31(dir)) continue;
+    for (const searchPath of ALL_AGENT_DISCOVERY_PATHS) {
+      const agentsDir = join31(dir, searchPath);
+      if (!existsSync31(agentsDir)) continue;
+      const agentFile = join31(agentsDir, `${name}.md`);
+      if (existsSync31(agentFile)) {
+        return parseAgentFile(agentFile, "project");
+      }
+      const agentDir = join31(agentsDir, name);
+      if (existsSync31(agentDir) && statSync8(agentDir).isDirectory()) {
+        return parseAgentDir(agentDir, "project");
+      }
+    }
+  }
+  const home = homedir9();
+  const globalPaths = [
+    join31(home, ".claude", "agents"),
+    join31(home, ".skillkit", "agents")
+  ];
+  for (const agentsDir of globalPaths) {
+    if (!existsSync31(agentsDir)) continue;
+    const agentFile = join31(agentsDir, `${name}.md`);
+    if (existsSync31(agentFile)) {
+      return parseAgentFile(agentFile, "global");
+    }
+    const agentDir = join31(agentsDir, name);
+    if (existsSync31(agentDir) && statSync8(agentDir).isDirectory()) {
+      return parseAgentDir(agentDir, "global");
+    }
+  }
+  return null;
+}
+function getAgentsDirectory(rootDir, agentType) {
+  const paths = AGENT_DISCOVERY_PATHS[agentType];
+  if (paths && paths.length > 0) {
+    return join31(rootDir, paths[0]);
+  }
+  return join31(rootDir, "agents");
+}
+function agentExists(name, searchDirs) {
+  return findAgent(name, searchDirs) !== null;
+}
+function getAgentStats(searchDirs) {
+  const allAgents = findAllAgents(searchDirs);
+  return {
+    total: allAgents.length,
+    project: allAgents.filter((a) => a.location === "project").length,
+    global: allAgents.filter((a) => a.location === "global").length,
+    enabled: allAgents.filter((a) => a.enabled).length,
+    disabled: allAgents.filter((a) => !a.enabled).length
+  };
+}
+
+// src/agents/translator.ts
+import { join as join32 } from "path";
+function translateAgent(agent, targetAgent, options) {
+  const canonical = toCanonicalAgent(agent);
+  return translateCanonicalAgent(canonical, targetAgent, options);
+}
+function translateCanonicalAgent(canonical, targetAgent, options) {
+  const targetFormat = CUSTOM_AGENT_FORMAT_MAP[targetAgent];
+  const warnings = [];
+  const incompatible = [];
+  if (targetFormat === "universal") {
+    if (canonical.hooks && canonical.hooks.length > 0) {
+      incompatible.push("hooks (not supported in universal format)");
+    }
+    if (canonical.permissionMode) {
+      incompatible.push("permissionMode (not supported in universal format)");
+    }
+  }
+  if (targetFormat === "cursor-agent") {
+    if (canonical.hooks && canonical.hooks.length > 0) {
+      warnings.push("Hooks may require manual adjustment for Cursor");
+    }
+  }
+  let content;
+  switch (targetFormat) {
+    case "claude-agent":
+      content = generateClaudeAgent(canonical, options);
+      break;
+    case "cursor-agent":
+      content = generateCursorAgent(canonical, options);
+      break;
+    case "universal":
+      content = generateUniversalAgent(canonical, options);
+      break;
+    default:
+      content = fromCanonicalAgent(canonical, targetFormat);
+  }
+  const filename = options?.outputFilename || getAgentFilename(canonical.name, targetAgent);
+  return {
+    success: true,
+    content,
+    filename,
+    warnings,
+    incompatible,
+    targetFormat,
+    targetAgent
+  };
+}
+function translateAgentContent(content, _sourceAgent, targetAgent, options) {
+  const agent = parseAgentFromContent(content);
+  if (!agent) {
+    return {
+      success: false,
+      content: "",
+      filename: "",
+      warnings: ["Failed to parse agent content"],
+      incompatible: [],
+      targetFormat: CUSTOM_AGENT_FORMAT_MAP[targetAgent],
+      targetAgent
+    };
+  }
+  return translateAgent(agent, targetAgent, options);
+}
+function parseAgentFromContent(content) {
+  const rawFrontmatter = extractAgentFrontmatter(content);
+  const agentContent = extractAgentContent(content);
+  if (!rawFrontmatter) {
+    return null;
+  }
+  const parsed = AgentFrontmatter.safeParse(rawFrontmatter);
+  const frontmatter = parsed.success ? parsed.data : {
+    name: rawFrontmatter.name || "unnamed-agent",
+    description: rawFrontmatter.description || "No description",
+    ...rawFrontmatter
+  };
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    path: "",
+    location: "project",
+    frontmatter,
+    content: agentContent,
+    enabled: true
+  };
+}
+function generateClaudeAgent(canonical, options) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${canonical.name}`);
+  lines.push(`description: ${escapeYamlString(canonical.description)}`);
+  if (canonical.model) {
+    lines.push(`model: ${canonical.model}`);
+  }
+  if (canonical.permissionMode) {
+    lines.push(`permissionMode: ${canonical.permissionMode}`);
+  }
+  if (canonical.disallowedTools && canonical.disallowedTools.length > 0) {
+    lines.push("disallowedTools:");
+    for (const tool of canonical.disallowedTools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  if (canonical.allowedTools && canonical.allowedTools.length > 0) {
+    lines.push("allowed-tools:");
+    for (const tool of canonical.allowedTools) {
+      lines.push(`  - ${tool}`);
+    }
+  }
+  if (canonical.hooks && canonical.hooks.length > 0) {
+    lines.push("hooks:");
+    for (const hook of canonical.hooks) {
+      lines.push(`  - type: ${hook.type}`);
+      lines.push(`    command: "${escapeYamlString(hook.command)}"`);
+      if (hook.timeout) lines.push(`    timeout: ${hook.timeout}`);
+      if (hook.once) lines.push(`    once: true`);
+      if (hook.matcher) lines.push(`    matcher: "${hook.matcher}"`);
+    }
+  }
+  if (canonical.skills && canonical.skills.length > 0) {
+    lines.push("skills:");
+    for (const skill of canonical.skills) {
+      lines.push(`  - ${skill}`);
+    }
+  }
+  if (canonical.context) {
+    lines.push(`context: ${canonical.context}`);
+  }
+  if (canonical.version) {
+    lines.push(`version: "${canonical.version}"`);
+  }
+  if (canonical.author) {
+    lines.push(`author: ${canonical.author}`);
+  }
+  if (canonical.tags && canonical.tags.length > 0) {
+    lines.push(`tags: [${canonical.tags.join(", ")}]`);
+  }
+  if (canonical.userInvocable !== void 0) {
+    lines.push(`user-invocable: ${canonical.userInvocable}`);
+  }
+  if (canonical.argumentHint) {
+    lines.push(`argument-hint: "${escapeYamlString(canonical.argumentHint)}"`);
+  }
+  if (options?.addMetadata) {
+    lines.push(`# Translated by SkillKit from ${canonical.sourceAgent || "unknown"}`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(canonical.content);
+  return lines.join("\n");
+}
+function generateCursorAgent(canonical, options) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${canonical.name}`);
+  lines.push(`description: ${escapeYamlString(canonical.description)}`);
+  if (canonical.model) {
+    lines.push(`model: ${canonical.model}`);
+  }
+  if (canonical.allowedTools && canonical.allowedTools.length > 0) {
+    lines.push(`tools: [${canonical.allowedTools.join(", ")}]`);
+  }
+  if (canonical.version) {
+    lines.push(`version: "${canonical.version}"`);
+  }
+  if (canonical.tags && canonical.tags.length > 0) {
+    lines.push(`tags: [${canonical.tags.join(", ")}]`);
+  }
+  if (options?.addMetadata) {
+    lines.push(`# Translated by SkillKit from ${canonical.sourceAgent || "unknown"}`);
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(canonical.content);
+  if (canonical.hooks && canonical.hooks.length > 0) {
+    lines.push("");
+    lines.push("<!-- Note: Hooks from original agent may need manual configuration -->");
+  }
+  return lines.join("\n");
+}
+function generateUniversalAgent(canonical, options) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${canonical.name}`);
+  lines.push(`description: ${escapeYamlString(canonical.description)}`);
+  if (canonical.model) {
+    lines.push(`model: ${canonical.model}`);
+  }
+  if (canonical.version) {
+    lines.push(`version: "${canonical.version}"`);
+  }
+  if (canonical.author) {
+    lines.push(`author: ${canonical.author}`);
+  }
+  if (canonical.tags && canonical.tags.length > 0) {
+    lines.push(`tags: [${canonical.tags.join(", ")}]`);
+  }
+  if (options?.addMetadata) {
+    lines.push(`# Translated by SkillKit`);
+    if (canonical.sourceAgent) {
+      lines.push(`# Original format: ${canonical.sourceAgent}`);
+    }
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${canonical.name}`);
+  lines.push("");
+  lines.push(canonical.content);
+  return lines.join("\n");
+}
+function getAgentFilename(agentName, targetAgent) {
+  const format = CUSTOM_AGENT_FORMAT_MAP[targetAgent];
+  switch (format) {
+    case "cursor-agent":
+      return `${agentName}.md`;
+    // Or .mdc if Cursor uses that for agents
+    default:
+      return `${agentName}.md`;
+  }
+}
+function getAgentTargetDirectory(rootDir, targetAgent) {
+  const paths = AGENT_DISCOVERY_PATHS[targetAgent];
+  if (paths && paths.length > 0) {
+    return join32(rootDir, paths[0]);
+  }
+  return join32(rootDir, "agents");
+}
+function escapeYamlString(str) {
+  if (/[:\{\}\[\],&*#?|\-<>=!%@`]/.test(str) || str.includes("\n")) {
+    return `"${str.replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+  }
+  return str;
+}
+function translateAgents(agents, targetAgent, options) {
+  return agents.map((agent) => translateAgent(agent, targetAgent, options));
+}
+function isAgentCompatible(sourceFormat, targetFormat) {
+  const warnings = [];
+  if (sourceFormat === targetFormat) {
+    return { compatible: true, warnings };
+  }
+  if (targetFormat === "claude-agent") {
+    return { compatible: true, warnings };
+  }
+  if (targetFormat === "universal") {
+    if (sourceFormat === "claude-agent") {
+      warnings.push("Hooks, permissionMode, and disallowedTools will be lost");
+    }
+    return { compatible: true, warnings };
+  }
+  if (targetFormat === "cursor-agent") {
+    if (sourceFormat === "claude-agent") {
+      warnings.push("Some Claude-specific features may not translate perfectly");
+    }
+    return { compatible: true, warnings };
+  }
+  return { compatible: true, warnings };
+}
 export {
   AGENT_CLI_CONFIGS,
+  AGENT_DISCOVERY_PATHS,
   AGENT_FORMAT_MAP,
   AIManager,
   AISearch,
   AISkillGenerator,
+  ALL_AGENT_DISCOVERY_PATHS,
   APIBasedCompressor,
+  AgentFrontmatter,
+  AgentHook,
+  AgentLocation,
+  AgentMetadata,
+  AgentPermissionMode,
   AgentType,
   AuditLogger,
   BaseAIProvider,
@@ -15796,6 +16647,7 @@ export {
   CIRCLECI_CONFIG_TEMPLATE,
   CONTEXT_DIR,
   CONTEXT_FILE,
+  CUSTOM_AGENT_FORMAT_MAP,
   CommandGenerator,
   CommandRegistry,
   ContextLoader,
@@ -15867,6 +16719,7 @@ export {
   WORKFLOW_EXTENSION,
   WindsurfTranslator,
   WorkflowOrchestrator,
+  agentExists,
   analyzeProject,
   buildSkillIndex,
   canTranslate,
@@ -15908,21 +16761,33 @@ export {
   cursorTranslator,
   detectProvider,
   detectSkillFormat,
+  discoverAgents,
+  discoverAgentsForAgent,
+  discoverGlobalAgents,
   discoverSkills,
   dryRunExecutor,
   estimateTokens,
   executeWithAgent,
   exportBundle,
+  extractAgentContent,
+  extractAgentFrontmatter,
   extractField,
   extractFrontmatter,
   extractSkillMetadata,
   fetchSkillsFromRepo,
+  findAgent,
+  findAllAgents,
   findAllSkills,
   findSkill,
   formatSkillAsPrompt,
+  fromCanonicalAgent,
   getAgentCLIConfig,
   getAgentConfigPath,
+  getAgentFilename,
   getAgentFormat,
+  getAgentStats,
+  getAgentTargetDirectory,
+  getAgentsDirectory,
   getAllProviders,
   getAvailableCLIAgents,
   getBuiltinPacksDir,
@@ -15946,12 +16811,14 @@ export {
   initProject,
   initializeMemoryDirectory,
   isAgentCLIAvailable,
+  isAgentCompatible,
   isGitUrl,
   isIndexStale,
   isLocalPath,
   isPathInside,
   listCICDTemplates,
   listWorkflows,
+  loadAgentMetadata,
   loadConfig,
   loadContext,
   loadIndex,
@@ -15962,11 +16829,14 @@ export {
   loadWorkflow,
   loadWorkflowByName,
   memoryDirectoryExists,
+  parseAgentDir,
+  parseAgentFile,
   parseShorthand,
   parseSkill,
   parseSkillContent,
   parseSource,
   parseWorkflow,
+  readAgentContent,
   readSkillContent,
   runTestSuite,
   saveConfig,
@@ -15980,9 +16850,15 @@ export {
   supportsSlashCommands,
   syncToAgent,
   syncToAllAgents,
+  toCanonicalAgent,
+  translateAgent,
+  translateAgentContent,
+  translateAgents,
+  translateCanonicalAgent,
   translateSkill,
   translateSkillFile,
   translatorRegistry,
+  validateAgent,
   validateBuiltinPacks,
   validatePackDirectory,
   validatePackManifest,