agents-inc 0.149.2 → 0.150.0

package/dist/chunk-3LIU2ZEF.js

@@ -0,0 +1,1355 @@
+#!/usr/bin/env node
+import {
+  typedKeys
+} from "./chunk-VEP23B5W.js";
+import {
+  AUTHOR_HANDLE_PATTERN,
+  CLAUDE_SRC_DIR,
+  DIRS,
+  KEBAB_CASE_PATTERN,
+  LOCAL_PSEUDO_CATEGORY,
+  PROJECT_ROOT,
+  STANDARD_DIRS,
+  STANDARD_FILES
+} from "./chunk-O5ASLZ2K.js";
+import {
+  init_esm_shims
+} from "./chunk-P56WJ5FA.js";
+
+// src/cli/lib/loading/loader.ts
+init_esm_shims();
+import { parse as parseYaml2 } from "yaml";
+import path2 from "path";
+import { unique } from "remeda";
+
+// src/cli/utils/errors.ts
+init_esm_shims();
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli/utils/frontmatter.ts
+init_esm_shims();
+import { parse as parseYaml } from "yaml";
+function extractFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+  if (!match || !match[1]) {
+    return null;
+  }
+  try {
+    return parseYaml(match[1]);
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/utils/fs.ts
+init_esm_shims();
+import fs from "fs-extra";
+import fg from "fast-glob";
+import os from "os";
+import path from "path";
+
+// src/cli/lib/config-gate/gate-token.ts
+init_esm_shims();
+import { AsyncLocalStorage } from "async_hooks";
+var gateToken = new AsyncLocalStorage();
+var GlobalPairWriteViolation = class extends Error {
+  constructor(targetPath) {
+    super(
+      `${targetPath} may only be written through config-gate \u2014 see src/cli/lib/config-gate/index.ts`
+    );
+    this.name = "GlobalPairWriteViolation";
+  }
+};
+function withGateToken(fn) {
+  return gateToken.run(true, fn);
+}
+function hasGateToken() {
+  return gateToken.getStore() === true;
+}
+function assertGateToken(targetPath) {
+  if (hasGateToken()) return;
+  throw new GlobalPairWriteViolation(targetPath);
+}
+
+// src/cli/utils/fs.ts
+function isPathWithin(child, parent) {
+  const resolvedChild = path.resolve(child);
+  const resolvedParent = path.resolve(parent);
+  return resolvedChild === resolvedParent || resolvedChild.startsWith(resolvedParent + path.sep);
+}
+async function readFile(filePath) {
+  return fs.readFile(filePath, "utf-8");
+}
+async function readFileSafe(filePath, maxSizeBytes) {
+  const stats = await fs.stat(filePath);
+  if (stats.size > maxSizeBytes) {
+    throw new Error(
+      `File too large: '${filePath}' is ${stats.size} bytes (limit: ${maxSizeBytes} bytes)`
+    );
+  }
+  return fs.readFile(filePath, "utf-8");
+}
+async function readFileOptional(filePath, fallback = "") {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return fallback;
+  }
+}
+async function fileExists(filePath) {
+  return fs.pathExists(filePath);
+}
+async function directoryExists(dirPath) {
+  try {
+    const stat = await fs.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listDirectories(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function glob(pattern, cwd) {
+  return fg(pattern, { cwd, onlyFiles: true });
+}
+function isGlobalPairPath(resolvedPath) {
+  const globalConfigDir = path.join(os.homedir(), CLAUDE_SRC_DIR);
+  return resolvedPath === path.join(globalConfigDir, STANDARD_FILES.CONFIG_TS) || resolvedPath === path.join(globalConfigDir, STANDARD_FILES.CONFIG_TYPES_TS);
+}
+async function writeFile(filePath, content) {
+  const resolvedPath = path.resolve(filePath);
+  if (isGlobalPairPath(resolvedPath)) assertGateToken(resolvedPath);
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, "utf-8");
+}
+async function ensureDir(dirPath) {
+  await fs.ensureDir(dirPath);
+}
+async function remove(filePath) {
+  await fs.remove(filePath);
+}
+async function copy(src, dest) {
+  await fs.copy(src, dest);
+}
+
+// src/cli/utils/logger.ts
+init_esm_shims();
+var verboseMode = false;
+function setVerbose(enabled) {
+  verboseMode = enabled;
+}
+function verbose(msg) {
+  if (verboseMode) {
+    console.log(`  ${msg}`);
+  }
+}
+function log(msg) {
+  console.log(msg);
+}
+var bufferMode = false;
+var messageBuffer = [];
+function enableBuffering() {
+  bufferMode = true;
+  messageBuffer = [];
+}
+function drainBuffer() {
+  const messages = [...messageBuffer];
+  messageBuffer = [];
+  return messages;
+}
+function disableBuffering() {
+  bufferMode = false;
+  messageBuffer = [];
+}
+function warn(msg, options) {
+  if (options?.suppressInTest && process.env.VITEST) {
+    return;
+  }
+  if (bufferMode) {
+    messageBuffer.push({ level: "warn", text: msg });
+    return;
+  }
+  console.warn(`  Warning: ${msg}`);
+}
+
+// src/cli/lib/schemas.ts
+init_esm_shims();
+import { z } from "zod";
+import { partition } from "remeda";
+
+// src/cli/lib/schema-validator.ts
+init_esm_shims();
+function formatZodIssue(issue) {
+  const path3 = issue.path.join(".");
+  if (issue.code === "unrecognized_keys") {
+    return `Unrecognized key: "${issue.keys.join('", "')}"`;
+  }
+  return path3 ? `${path3}: ${issue.message}` : issue.message;
+}
+function formatZodErrors(error) {
+  return error.issues.map(formatZodIssue);
+}
+
+// src/cli/types/generated/source-types.ts
+init_esm_shims();
+var SKILL_SLUGS = [
+  "angular-standalone",
+  "ant-design",
+  "anthropic-sdk",
+  "api-performance",
+  "apollo-server",
+  "app-links",
+  "appwrite",
+  "astro",
+  "auth-security",
+  "aws-sdk",
+  "axiom-pino-sentry",
+  "better-auth-drizzle-hono",
+  "biome",
+  "ble-nfc",
+  "bullmq",
+  "chakra-ui",
+  "changesets",
+  "chroma",
+  "clack",
+  "claude-vision",
+  "clerk",
+  "cli-commander",
+  "cli-reviewing",
+  "cloudflare-workers",
+  "cockroachdb",
+  "cohere-sdk",
+  "css-animations",
+  "cva",
+  "cypress-e2e",
+  "d3",
+  "date-fns",
+  "detox",
+  "dnd-kit",
+  "docker",
+  "docusaurus",
+  "drizzle",
+  "eas",
+  "edgedb",
+  "elasticsearch",
+  "electron",
+  "electron-forge",
+  "electron-ipc",
+  "electron-multiwindow",
+  "electron-security",
+  "electron-storage",
+  "electron-testing",
+  "electron-ui",
+  "electron-updater",
+  "elevenlabs",
+  "elysia",
+  "error-boundaries",
+  "eslint-prettier",
+  "expo",
+  "expo-router",
+  "express",
+  "expressive-typescript",
+  "fastify",
+  "file-upload-patterns",
+  "firebase",
+  "framer-motion",
+  "gesture-handler",
+  "git-hooks",
+  "github-actions",
+  "google-gemini-sdk",
+  "graphql-apollo",
+  "graphql-urql",
+  "headless-ui",
+  "hono",
+  "huggingface-inference",
+  "image-handling",
+  "jotai",
+  "knex",
+  "kubernetes",
+  "langchain",
+  "langfuse",
+  "leaflet",
+  "lexical",
+  "litellm",
+  "llamaindex",
+  "maestro",
+  "mantine",
+  "mapbox",
+  "meilisearch",
+  "mercurius",
+  "mistral-sdk",
+  "mmkv",
+  "mobx",
+  "modal",
+  "mongodb",
+  "mongoose",
+  "msw",
+  "mui",
+  "mysql",
+  "native-js",
+  "nativewind",
+  "neon",
+  "nestjs",
+  "netlify",
+  "next-intl",
+  "nextauth",
+  "nextjs",
+  "ngrx-signalstore",
+  "nuxt",
+  "nx",
+  "oclif-ink",
+  "offline-first",
+  "ollama",
+  "openai-sdk",
+  "openai-whisper",
+  "openapi",
+  "payload",
+  "pinecone",
+  "pinia",
+  "planetscale",
+  "playwright-e2e",
+  "pnpm-workspaces",
+  "postgresql",
+  "posthog-analytics",
+  "posthog-flags",
+  "prisma",
+  "promptfoo",
+  "pulumi",
+  "push",
+  "qdrant",
+  "qwik",
+  "radix-ui",
+  "react",
+  "react-hook-form",
+  "react-intl",
+  "react-native",
+  "react-native-paper",
+  "react-native-performance",
+  "react-native-security",
+  "react-navigation",
+  "react-query",
+  "react-router",
+  "react-testing-library",
+  "react-three-fiber",
+  "reanimated",
+  "recharts",
+  "redis",
+  "redux-toolkit",
+  "remix",
+  "replicate",
+  "research-methodology",
+  "resend-react-email",
+  "result-types",
+  "reviewing",
+  "rxjs",
+  "sanity",
+  "scss-modules",
+  "sequelize",
+  "service-workers",
+  "setup-axiom-pino-sentry",
+  "setup-env",
+  "setup-posthog",
+  "setup-resend",
+  "shadcn-ui",
+  "skia",
+  "socket-io",
+  "solidjs",
+  "sqlite-powersync",
+  "sse",
+  "sst",
+  "storybook",
+  "strapi",
+  "strategies",
+  "stripe",
+  "supabase",
+  "surrealdb",
+  "svelte",
+  "sveltekit",
+  "swr",
+  "tailwind",
+  "tamagui",
+  "tanstack-form",
+  "tanstack-router",
+  "tanstack-table",
+  "tasks",
+  "tauri",
+  "tauri-backend",
+  "tauri-bundling",
+  "tauri-mobile",
+  "tauri-multiwindow",
+  "tauri-plugins",
+  "tauri-security",
+  "terraform",
+  "tiptap",
+  "together-ai",
+  "tool-use-patterns",
+  "trpc",
+  "turborepo",
+  "turborepo-ci",
+  "turso",
+  "typeorm",
+  "typescript-config",
+  "unistyles",
+  "upstash",
+  "vee-validate",
+  "vercel",
+  "vercel-ai-sdk",
+  "vercel-kv",
+  "vercel-postgres",
+  "view-transitions",
+  "vision-camera",
+  "vite",
+  "vitepress",
+  "vitest",
+  "vue-composition-api",
+  "vue-i18n",
+  "vue-test-utils",
+  "vuetify",
+  "vueuse",
+  "watermelondb",
+  "weaviate",
+  "web-accessibility",
+  "web-performance",
+  "webhooks",
+  "websockets",
+  "yoga",
+  "zod-validation",
+  "zustand"
+];
+var CATEGORIES = [
+  "ai-infrastructure",
+  "ai-observability",
+  "ai-orchestration",
+  "ai-patterns",
+  "ai-provider",
+  "api-analytics",
+  "api-api",
+  "api-auth",
+  "api-baas",
+  "api-caching",
+  "api-cms",
+  "api-commerce",
+  "api-database",
+  "api-email",
+  "api-framework",
+  "api-graphql",
+  "api-messaging",
+  "api-observability",
+  "api-performance",
+  "api-queue",
+  "api-search",
+  "api-specs",
+  "api-vector-db",
+  "cli-framework",
+  "cli-prompts",
+  "desktop-backend",
+  "desktop-framework",
+  "desktop-ipc",
+  "desktop-mobile",
+  "desktop-multiwindow",
+  "desktop-packaging",
+  "desktop-plugins",
+  "desktop-security",
+  "desktop-storage",
+  "desktop-testing",
+  "desktop-ui",
+  "desktop-updates",
+  "infra-ci-cd",
+  "infra-config",
+  "infra-containers",
+  "infra-iac",
+  "infra-platform",
+  "meta-design",
+  "meta-methodology",
+  "meta-reviewing",
+  "mobile-animation",
+  "mobile-background",
+  "mobile-camera",
+  "mobile-deep-linking",
+  "mobile-deployment",
+  "mobile-framework",
+  "mobile-hardware",
+  "mobile-navigation",
+  "mobile-notifications",
+  "mobile-performance",
+  "mobile-security",
+  "mobile-storage",
+  "mobile-styling",
+  "mobile-testing",
+  "mobile-ui-components",
+  "shared-monorepo",
+  "shared-security",
+  "shared-tooling",
+  "web-3d",
+  "web-accessibility",
+  "web-animation",
+  "web-client-state",
+  "web-dataviz",
+  "web-dnd",
+  "web-editor",
+  "web-error-handling",
+  "web-file-upload",
+  "web-files",
+  "web-forms",
+  "web-framework",
+  "web-i18n",
+  "web-maps",
+  "web-meta-framework",
+  "web-mocking",
+  "web-performance",
+  "web-pwa",
+  "web-realtime",
+  "web-routing",
+  "web-server-state",
+  "web-styling",
+  "web-testing",
+  "web-tooling",
+  "web-ui-components",
+  "web-utilities"
+];
+var DOMAINS = [
+  "ai",
+  "api",
+  "cli",
+  "desktop",
+  "infra",
+  "meta",
+  "mobile",
+  "shared",
+  "web"
+];
+var AGENT_NAMES = [
+  "agent-summoner",
+  "ai-developer",
+  "ai-reviewer",
+  "api-developer",
+  "api-pm",
+  "api-researcher",
+  "api-reviewer",
+  "api-tester",
+  "cli-developer",
+  "cli-reviewer",
+  "cli-tester",
+  "codex-keeper",
+  "convention-keeper",
+  "infra-reviewer",
+  "pattern-scout",
+  "skill-summoner",
+  "web-architecture",
+  "web-developer",
+  "web-pattern-critique",
+  "web-pm",
+  "web-researcher",
+  "web-reviewer",
+  "web-tester"
+];
+
+// src/cli/types/matrix.ts
+init_esm_shims();
+var MODEL_NAMES = ["sonnet", "opus", "haiku", "fable", "inherit"];
+var EFFORT_NAMES = ["low", "medium", "high", "xhigh", "max"];
+var PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "dontAsk",
+  "bypassPermissions",
+  "plan",
+  "delegate"
+];
+
+// src/cli/lib/schemas.ts
+var boundSkillSchema = z.object({
+  id: z.string(),
+  sourceUrl: z.string(),
+  sourceName: z.string(),
+  boundTo: z.string(),
+  description: z.string().optional()
+});
+var modelNameSchema = z.enum(MODEL_NAMES);
+var effortLevelSchema = z.enum(EFFORT_NAMES);
+var permissionModeSchema = z.enum(PERMISSION_MODES);
+var skillSlugSchema = z.enum(SKILL_SLUGS);
+function validateCategoryField(val, ctx) {
+  if (!val.category) return;
+  if (val.custom) {
+    if (!KEBAB_CASE_PATTERN.test(val.category)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["category"],
+        message: "Custom category must be kebab-case"
+      });
+    }
+    return;
+  }
+  const result = categoryPathSchema.safeParse(val.category);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      ctx.addIssue({ ...issue, path: ["category"] });
+    }
+  }
+}
+var categoryPathSchema = z.string().refine(
+  (val) => {
+    if (val === LOCAL_PSEUDO_CATEGORY) return true;
+    if (CATEGORIES.includes(val)) return true;
+    return KEBAB_CASE_PATTERN.test(val);
+  },
+  {
+    message: "Must be a valid category path (e.g., 'web-framework', 'shared-testing', or 'local')"
+  }
+);
+var agentHookActionSchema = z.object({
+  type: z.enum(["command", "script", "prompt"]),
+  command: z.string().optional(),
+  script: z.string().optional(),
+  prompt: z.string().optional()
+});
+var agentHookDefinitionSchema = z.object({
+  matcher: z.string().optional(),
+  hooks: z.array(agentHookActionSchema).optional()
+});
+var hooksRecordSchema = z.record(z.string(), z.array(agentHookDefinitionSchema));
+var strictAgentHookDefinitionSchema = z.object({
+  matcher: z.string().optional(),
+  hooks: z.array(agentHookActionSchema).min(1)
+});
+var strictHooksRecordSchema = z.record(
+  z.string(),
+  z.array(strictAgentHookDefinitionSchema)
+);
+var skillAssignmentSchema = z.object({
+  id: z.string(),
+  preloaded: z.boolean().optional(),
+  local: z.boolean().optional(),
+  path: z.string().optional()
+});
+var skillFrontmatterLoaderSchema = z.object({
+  /** Lenient (any string): local/custom skills have non-builtin IDs */
+  name: z.string(),
+  description: z.string(),
+  model: modelNameSchema.optional()
+});
+var skillMetadataLoaderSchema = z.object({
+  // Field accepts any string; cross-field validation in superRefine enforces strict/custom rules
+  category: z.string().optional(),
+  author: z.string().optional(),
+  domain: z.string(),
+  custom: z.boolean().optional()
+}).passthrough().superRefine(validateCategoryField);
+var matrixRawMetadataSchema = z.object({
+  category: categoryPathSchema,
+  author: z.string(),
+  displayName: z.string().optional(),
+  slug: z.string(),
+  cliDescription: z.string().optional(),
+  usageGuidance: z.string().optional(),
+  // Boundary cast: domain is a string at the YAML parse boundary; narrowed to Domain type
+  domain: z.string(),
+  custom: z.boolean().optional()
+});
+var pluginAuthorSchema = z.object({
+  name: z.string().min(1),
+  email: z.string().optional()
+});
+var pluginManifestObjectSchema = z.object({
+  name: z.string(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  keywords: z.array(z.string()).optional(),
+  commands: z.union([z.string(), z.array(z.string())]).optional(),
+  agents: z.union([z.string(), z.array(z.string())]).optional(),
+  skills: z.union([z.string(), z.array(z.string())]).optional(),
+  hooks: z.union([z.string(), hooksRecordSchema]).optional()
+});
+var pluginManifestSchema = pluginManifestObjectSchema;
+var pluginManifestValidationSchema = pluginManifestObjectSchema.strict();
+var agentYamlConfigSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  model: modelNameSchema.optional(),
+  effort: effortLevelSchema.optional(),
+  tools: z.array(z.string()),
+  disallowedTools: z.array(z.string()).optional(),
+  permissionMode: permissionModeSchema.optional(),
+  hooks: hooksRecordSchema.optional(),
+  outputFormat: z.string().optional(),
+  domain: z.string().optional(),
+  custom: z.boolean().optional()
+});
+var skillAssignmentElementSchema = z.union([
+  z.string(),
+  skillAssignmentSchema
+]);
+var stackAgentConfigSchema = z.record(
+  z.string(),
+  z.union([skillAssignmentElementSchema, z.array(skillAssignmentElementSchema)])
+);
+var projectConfigLoaderSchema = z.object({
+  /** Project/plugin name in kebab-case */
+  name: z.string().optional(),
+  description: z.string().optional(),
+  /** Per-agent configuration with scope (e.g., [{ name: "web-developer", scope: "project" }]) */
+  agents: z.array(
+    z.object({
+      name: z.string(),
+      scope: z.enum(["project", "global"]),
+      /** Per-agent overrides of the agent's own metadata defaults */
+      model: modelNameSchema.optional(),
+      effort: effortLevelSchema.optional(),
+      excluded: z.boolean().optional()
+    })
+  ).optional(),
+  /** Per-skill configuration with scope and source */
+  skills: z.array(
+    z.object({
+      id: z.string(),
+      scope: z.enum(["project", "global"]),
+      source: z.string(),
+      excluded: z.boolean().optional()
+    })
+  ).optional(),
+  /** Author handle (e.g., "@vince") */
+  author: z.string().optional(),
+  /** Selected domains from the wizard (persisted for edit mode restoration) */
+  domains: z.array(z.string()).optional(),
+  /** Selected agents from the wizard (persisted for edit mode restoration) */
+  selectedAgents: z.array(z.string()).optional(),
+  /** Agent-to-category-to-skill mappings from selected stack (accepts same formats as stacks.ts) */
+  stack: z.record(z.string(), stackAgentConfigSchema).optional(),
+  /** Skills source path or URL (e.g., "github:my-org/skills") */
+  source: z.string().optional(),
+  /** Marketplace identifier for plugin installation */
+  marketplace: z.string().optional(),
+  /** Separate source for agents when different from skills source */
+  agentsSource: z.string().optional(),
+  /** Tracked project installation paths (global config only) */
+  projects: z.array(z.string()).optional()
+}).passthrough();
+var categoryDefinitionSchema = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  description: z.string(),
+  domain: z.string().optional(),
+  exclusive: z.boolean(),
+  required: z.boolean(),
+  order: z.number(),
+  icon: z.string().optional()
+});
+var skillRefInRules = skillSlugSchema;
+var skillGroupRuleSchema = z.object({
+  skills: z.array(skillRefInRules).min(2),
+  reason: z.string()
+});
+var conflictRuleSchema = skillGroupRuleSchema;
+var discourageRuleSchema = skillGroupRuleSchema;
+var recommendationSchema = z.object({
+  skill: skillRefInRules,
+  reason: z.string()
+});
+var compatibilityGroupSchema = skillGroupRuleSchema;
+var requireRuleSchema = z.object({
+  skill: skillRefInRules,
+  needs: z.array(skillRefInRules).min(1),
+  needsAny: z.boolean().optional(),
+  reason: z.string()
+});
+var alternativeGroupSchema = z.object({
+  purpose: z.string(),
+  skills: z.array(skillRefInRules).min(1)
+});
+var relationshipDefinitionsSchema = z.object({
+  conflicts: z.array(conflictRuleSchema),
+  discourages: z.array(discourageRuleSchema),
+  recommends: z.array(recommendationSchema),
+  requires: z.array(requireRuleSchema),
+  alternatives: z.array(alternativeGroupSchema),
+  compatibleWith: z.array(compatibilityGroupSchema).optional().default([])
+});
+var skillCategoriesFileSchema = z.object({
+  version: z.string(),
+  categories: z.record(z.string(), categoryDefinitionSchema)
+});
+var skillRulesFileSchema = z.object({
+  version: z.string(),
+  relationships: relationshipDefinitionsSchema.optional()
+});
+var localRawMetadataSchema = z.object({
+  /** Short name shown in the wizard grid (e.g., "my-custom-react") */
+  displayName: z.string(),
+  /** Kebab-case short key for alias resolution (e.g., "react") */
+  slug: z.string(),
+  /** One-line description for the wizard */
+  cliDescription: z.string().optional(),
+  /** Category to place this skill in (e.g., "web-framework") */
+  // Field accepts any string; cross-field validation in superRefine enforces strict/custom rules
+  category: z.string(),
+  /** When an AI agent should invoke this skill */
+  usageGuidance: z.string().optional(),
+  /** Domain this skill belongs to (e.g., "web", "api", "cli") */
+  domain: z.string(),
+  /** True if this skill was created outside the CLI's built-in vocabulary */
+  custom: z.boolean().optional()
+}).passthrough().superRefine(validateCategoryField);
+var localSkillMetadataSchema = z.object({
+  forkedFrom: z.object({
+    /** Original skill ID before forking — lenient (any string) since custom/extra-source skills have non-builtin IDs */
+    skillId: z.string(),
+    /** SHA hash of the original content at fork time (for diff detection) */
+    contentHash: z.string(),
+    /** ISO date when the fork was created */
+    date: z.string(),
+    /** Source URL the skill was installed from (e.g., "github:agents-inc/skills") */
+    source: z.string().optional()
+  }).optional()
+}).passthrough();
+var stackSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  description: z.string(),
+  /** Maps agent IDs to their category-to-skill assignments */
+  agents: z.record(z.string(), stackAgentConfigSchema),
+  /** High-level philosophy guiding this stack's technology choices */
+  philosophy: z.string().optional()
+});
+var stacksConfigSchema = z.object({
+  stacks: z.array(stackSchema).min(1)
+});
+var marketplaceRemoteSourceSchema = z.object({
+  source: z.enum(["github", "url"]),
+  repo: z.string().optional(),
+  url: z.string().optional(),
+  ref: z.string().optional()
+});
+var marketplacePluginSchema = z.object({
+  name: z.string().min(1),
+  /** Local directory path (relative to pluginRoot) or remote source config */
+  source: z.union([z.string(), marketplaceRemoteSourceSchema]),
+  description: z.string().optional(),
+  version: z.string().optional(),
+  author: pluginAuthorSchema.optional(),
+  /** Lenient: external data may have any category string or none at all */
+  category: z.string().optional(),
+  keywords: z.array(z.string()).optional()
+});
+var marketplaceOwnerSchema = pluginAuthorSchema;
+var marketplaceMetadataSchema = z.object({
+  /** Base directory for resolving plugin source paths (e.g., "plugins/") */
+  pluginRoot: z.string().optional()
+});
+var marketplaceSchema = z.object({
+  $schema: z.string().optional(),
+  name: z.string().min(1),
+  version: z.string().min(1),
+  description: z.string().optional(),
+  owner: marketplaceOwnerSchema,
+  metadata: marketplaceMetadataSchema.optional(),
+  plugins: z.array(marketplacePluginSchema).min(1)
+});
+var permissionConfigSchema = z.object({
+  /** Tool names or patterns to explicitly allow */
+  allow: z.array(z.string()).optional(),
+  /** Tool names or patterns to explicitly deny */
+  deny: z.array(z.string()).optional()
+});
+var settingsFileSchema = z.object({
+  permissions: permissionConfigSchema.optional()
+}).passthrough();
+var importedSkillMetadataSchema = z.object({
+  forkedFrom: z.object({
+    /** Source URL or identifier where the skill was imported from */
+    source: z.string(),
+    /** Original skill name in the source */
+    skillName: z.string(),
+    /** SHA hash of the original content at import time */
+    contentHash: z.string(),
+    /** ISO date when the import was performed */
+    date: z.string()
+  }).optional()
+}).passthrough();
+var brandingConfigSchema = z.object({
+  /** Custom CLI name (e.g., "Acme Dev Tools") */
+  name: z.string().optional(),
+  /** Custom tagline shown in wizard header */
+  tagline: z.string().optional()
+});
+var projectSourceConfigSchema = z.object({
+  /** Primary skills source (path or URL) */
+  source: z.string().optional(),
+  /** Author handle for this project's config */
+  author: z.string().optional(),
+  /** Marketplace identifier for plugin installation */
+  marketplace: z.string().optional(),
+  /** Separate source for agent definitions (when different from skills) */
+  agentsSource: z.string().optional(),
+  /** Additional skill sources (private marketplaces, custom repos) */
+  sources: z.array(
+    z.object({
+      /** Display name for the source (shown in wizard) */
+      name: z.string(),
+      /** Source URL (e.g., "github:acme-corp/claude-skills") */
+      url: z.string(),
+      description: z.string().optional(),
+      /** Git ref (branch/tag/commit) for the source */
+      ref: z.string().optional()
+    })
+  ).optional(),
+  /** Skills explicitly bound to categories via search (from Step Sources) */
+  boundSkills: z.array(boundSkillSchema).optional(),
+  /** Branding overrides for white-labeling the CLI */
+  branding: brandingConfigSchema.optional(),
+  /** Custom skills directory override (default: "src/skills") */
+  skillsDir: z.string().optional(),
+  /** Custom agents directory override (default: "src/agents") */
+  agentsDir: z.string().optional(),
+  /** Custom stacks file path override (default: "config/stacks.ts") */
+  stacksFile: z.string().optional(),
+  /** Custom categories file path override (default: "config/skill-categories.ts") */
+  categoriesFile: z.string().optional(),
+  /** Custom rules file path override (default: "config/skill-rules.ts") */
+  rulesFile: z.string().optional()
+}).passthrough();
+var agentYamlGenerationSchema = z.object({
+  $schema: z.string().optional(),
+  id: z.string().min(1),
+  title: z.string().min(1),
+  description: z.string().min(1),
+  model: modelNameSchema.optional(),
+  effort: effortLevelSchema.optional(),
+  tools: z.array(z.string()).min(1),
+  disallowedTools: z.array(z.string()).optional(),
+  permissionMode: permissionModeSchema.optional(),
+  hooks: strictHooksRecordSchema.optional(),
+  outputFormat: z.string().optional(),
+  domain: z.string().optional(),
+  custom: z.boolean().optional()
+}).strict();
+var agentFrontmatterValidationSchema = z.object({
+  /** Agent name in kebab-case (becomes the Task tool identifier) */
+  name: z.string().regex(KEBAB_CASE_PATTERN).min(1),
+  description: z.string().min(1),
+  /** Comma-separated list of allowed tools */
+  tools: z.string().optional(),
+  /** Comma-separated list of denied tools */
+  disallowedTools: z.string().optional(),
+  model: modelNameSchema.optional(),
+  effort: effortLevelSchema.optional(),
+  permissionMode: permissionModeSchema.optional(),
+  /** Skill names to preload (embed in agent prompt) */
+  skills: z.array(z.string().min(1)).optional(),
+  hooks: strictHooksRecordSchema.optional()
+}).strict();
+var skillFrontmatterValidationSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  /** If true, Claude cannot invoke this skill on its own */
+  "disable-model-invocation": z.boolean().optional(),
+  /** If true, user can invoke this skill directly */
+  "user-invocable": z.boolean().optional(),
+  /** Comma-separated list of tools this skill can use */
+  "allowed-tools": z.string().optional(),
+  model: modelNameSchema.optional(),
+  /** "fork" means skill runs in a forked context (separate conversation) */
+  context: z.enum(["fork"]).optional(),
+  /** Agent name this skill is scoped to */
+  agent: z.string().optional(),
+  /** Hint text shown when user invokes the skill */
+  "argument-hint": z.string().optional()
+}).strict();
+var forkedFromSchema = z.object({
+  /** Original skill ID */
+  skillId: z.string(),
+  /** Version of the original at fork time */
+  version: z.number().int().min(1).optional(),
+  /** Content hash of the original at fork time */
+  contentHash: z.string(),
+  /** Source URL or identifier */
+  source: z.string().optional(),
+  /** ISO date of the fork */
+  date: z.string()
+});
+var CLI_DESCRIPTION_MAX_LENGTH = 60;
+var skillMetadataBaseSchema = z.object({
+  /** Author handle — must start with @ (e.g., "@vince") */
+  author: z.string().regex(AUTHOR_HANDLE_PATTERN),
+  /** Short display name for the wizard grid (max 30 chars) */
+  displayName: z.string().min(1).max(30),
+  /** One-line description for the wizard (max 60 chars recommended; over-length is a validation warning) */
+  cliDescription: z.string().min(1).max(CLI_DESCRIPTION_MAX_LENGTH),
+  /** When an AI agent should invoke this skill (min 10 chars to ensure usefulness) */
+  usageGuidance: z.string().min(10),
+  /** 7-char hex SHA of skill content (for change detection) */
+  contentHash: z.string().regex(/^[a-f0-9]{7}$/).optional(),
+  /** ISO date of last update */
+  updated: z.string().optional(),
+  /** Provenance tracking when skill was forked from another */
+  forkedFrom: forkedFromSchema.optional(),
+  /** Domain assignment from metadata */
+  domain: z.string().optional(),
+  /** True if this skill was created outside the CLI's built-in vocabulary */
+  custom: z.boolean().optional()
+});
+var metadataValidationSchema = skillMetadataBaseSchema.extend({
+  /** Domain-prefixed category — must be a known built-in category */
+  category: z.enum(CATEGORIES),
+  /** Kebab-case short key — must be a known built-in slug */
+  slug: z.enum(SKILL_SLUGS)
+}).strict();
+var customMetadataValidationSchema = skillMetadataBaseSchema.extend({
+  /** Any string category — custom skills may define their own categories */
+  category: z.string(),
+  /** Kebab-case short key for alias resolution, search, and relationship rules */
+  slug: z.string().regex(/^[a-z][a-z0-9-]*$/).min(1).max(50)
+});
+var stackSkillAssignmentSchema = z.object({
+  id: z.string().min(1),
+  /** If true, skill content is embedded in the compiled agent prompt */
+  preloaded: z.boolean().optional()
+}).strict();
+var stackConfigValidationSchema = z.object({
+  /** Unique stack identifier in kebab-case */
+  id: z.string().regex(KEBAB_CASE_PATTERN).optional(),
+  name: z.string().min(1),
+  version: z.string(),
+  author: z.string().min(1),
+  description: z.string().optional(),
+  /** ISO date when this stack was first created */
+  created: z.string().optional(),
+  /** ISO date of last update */
+  updated: z.string().optional(),
+  /** Primary framework this stack is designed for (e.g., "nextjs", "remix") */
+  framework: z.string().optional(),
+  /** All skills used in this stack (flat list, at least one required) */
+  skills: z.array(stackSkillAssignmentSchema).min(1),
+  /** Agent IDs this stack compiles (at least one required) */
+  agents: z.array(z.string().regex(KEBAB_CASE_PATTERN)).min(1),
+  /** Per-agent skill assignments: { agentId: { category: [skillAssignment] } } */
+  agentSkills: z.record(z.string(), z.record(z.string(), z.array(stackSkillAssignmentSchema))).optional(),
+  /** High-level philosophy guiding technology choices */
+  philosophy: z.string().optional(),
+  /** Guiding principles for agents using this stack */
+  principles: z.array(z.string().min(1)).optional(),
+  tags: z.array(z.string().regex(KEBAB_CASE_PATTERN)).optional(),
+  /** Per-skill overrides: alternative suggestions and lock status */
+  overrides: z.record(
+    z.string(),
+    z.object({
+      /** Suggested alternative skill IDs if this one is swapped */
+      alternatives: z.array(z.string().min(1)).optional(),
+      /** If true, this skill cannot be swapped by the user */
+      locked: z.boolean().optional()
+    }).strict()
+  ).optional(),
+  /** Community metrics for sorting/ranking */
+  metrics: z.object({
+    upvotes: z.number().int().min(0).optional(),
+    downloads: z.number().int().min(0).optional()
+  }).strict().optional(),
+  /** Lifecycle hooks triggered by file changes or commands */
+  hooks: strictHooksRecordSchema.optional()
+}).strict();
+function formatZodIssues(issues) {
+  return issues.map(formatZodIssue).join("; ");
+}
+function validateSkillMetadata(rawMetadata) {
+  const schema = isCustomMetadata(rawMetadata) ? customMetadataValidationSchema : metadataValidationSchema;
+  return schema.safeParse(rawMetadata);
+}
+function isOverLengthCliDescription(issue) {
+  return issue.code === "too_big" && issue.path.length === 1 && issue.path[0] === "cliDescription";
+}
+function readCliDescription(raw) {
+  if (raw == null || typeof raw !== "object") return void 0;
+  const value = raw.cliDescription;
+  return typeof value === "string" ? value : void 0;
+}
+function formatOverLengthWarning(issue, cliDescription) {
+  if (cliDescription === void 0) return formatZodIssue(issue);
+  return `cliDescription is ${cliDescription.length} characters \u2014 exceeds the recommended maximum of ${CLI_DESCRIPTION_MAX_LENGTH}`;
+}
+function splitMetadataValidationIssues(error, rawMetadata) {
+  const [overLength, hardFailures] = partition(error.issues, isOverLengthCliDescription);
+  const cliDescription = readCliDescription(rawMetadata);
+  const warnings = overLength.map((issue) => formatOverLengthWarning(issue, cliDescription));
+  return { errors: hardFailures.map(formatZodIssue), warnings };
+}
+function validateNestingDepth(value, maxDepth) {
+  function check(val, depth) {
+    if (depth > maxDepth) return false;
+    if (Array.isArray(val)) {
+      return val.every((item) => check(item, depth + 1));
+    }
+    if (val !== null && typeof val === "object") {
+      return Object.values(val).every((v) => check(v, depth + 1));
+    }
+    return true;
+  }
+  return check(value, 0);
+}
+function isCustomMetadata(raw) {
+  if (raw == null || typeof raw !== "object") return false;
+  if (!("custom" in raw)) return false;
+  return raw.custom === true;
+}
+function warnUnknownFields(parsed, expectedKeys, context) {
+  const expectedSet = new Set(expectedKeys);
+  const unknownKeys = Object.keys(parsed).filter((k) => !expectedSet.has(k));
+  if (unknownKeys.length > 0) {
+    warn(`Unknown fields in ${context}: ${unknownKeys.join(", ")}`);
+  }
+}
+
+// src/cli/lib/loading/loader.ts
+function parseFrontmatter(content, filePath) {
+  const rawFrontmatter = extractFrontmatter(content);
+  if (rawFrontmatter === null) return null;
+  const parsed = skillFrontmatterLoaderSchema.safeParse(rawFrontmatter);
+  if (!parsed.success) {
+    const location = filePath ?? "unknown file";
+    warn(`Invalid SKILL.md frontmatter in '${location}': ${formatZodIssues(parsed.error.issues)}`);
+    return null;
+  }
+  return parsed.data;
+}
+async function loadAgentsFromDir(agentsDir, sourceRoot, options) {
+  const agents = {};
+  const files = await glob(`**/${STANDARD_FILES.AGENT_METADATA_YAML}`, agentsDir);
+  for (const file of files) {
+    const fullPath = path2.join(agentsDir, file);
+    try {
+      const content = await readFile(fullPath);
+      const config = agentYamlConfigSchema.parse(parseYaml2(content));
+      agents[config.id] = {
+        title: config.title,
+        description: config.description,
+        model: config.model,
+        tools: config.tools,
+        path: path2.dirname(file),
+        sourceRoot,
+        ...options.agentBaseDir ? { agentBaseDir: options.agentBaseDir } : {},
+        ...config.domain ? { domain: config.domain } : {},
+        ...options.includeCustomFlag && config.custom === true ? { custom: true } : {}
+      };
+      verbose(`Loaded ${options.verboseLabel}: ${config.id} from ${file}`);
+    } catch (error) {
+      warn(`Skipping invalid metadata.yaml at '${fullPath}': ${getErrorMessage(error)}`);
+    }
+  }
+  return agents;
+}
+async function loadAllAgents(projectRoot) {
+  return loadAgentsFromDir(path2.join(projectRoot, DIRS.agents), projectRoot, {
+    includeCustomFlag: true,
+    verboseLabel: "agent"
+  });
+}
+async function loadMergedAgents(sourcePath) {
+  const [cliAgents, sourceAgents] = await Promise.all([
+    loadAllAgents(PROJECT_ROOT),
+    loadAllAgents(sourcePath)
+  ]);
+  return { ...cliAgents, ...sourceAgents };
+}
+async function loadProjectAgents(projectRoot) {
+  const projectAgentsDir = path2.join(projectRoot, CLAUDE_SRC_DIR, STANDARD_DIRS.AGENTS);
+  if (!await directoryExists(projectAgentsDir)) {
+    verbose(`No project agents directory at ${projectAgentsDir}`);
+    const noAgents = {};
+    return noAgents;
+  }
+  return loadAgentsFromDir(projectAgentsDir, projectRoot, {
+    // Project agents are in .claude-src/agents/
+    agentBaseDir: `${CLAUDE_SRC_DIR}/agents`,
+    verboseLabel: "project agent"
+  });
+}
+async function buildIdToDirectoryPathMap(skillsDir) {
+  const files = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
+  const parsed = await Promise.all(
+    files.map(async (file) => {
+      const fullPath = path2.join(skillsDir, file);
+      return { file, frontmatter: parseFrontmatter(await readFile(fullPath), fullPath) };
+    })
+  );
+  return Object.fromEntries(
+    parsed.filter(
+      (entry) => Boolean(entry.frontmatter?.name)
+    ).flatMap(({ file, frontmatter }) => {
+      const directoryPath = file.replace(`/${STANDARD_FILES.SKILL_MD}`, "");
+      return [
+        [frontmatter.name, directoryPath],
+        [directoryPath, directoryPath]
+      ];
+    })
+  );
+}
+async function loadSkillsByIds(skillIds, projectRoot) {
+  const skills = {};
+  const skillsDir = path2.join(projectRoot, DIRS.skills);
+  const idToDirectoryPath = await buildIdToDirectoryPathMap(skillsDir);
+  const expandDirectoryRef = (skillId) => {
+    const childSkills = typedKeys(idToDirectoryPath).filter(
+      (id) => idToDirectoryPath[id]?.startsWith(`${skillId}/`)
+    );
+    if (childSkills.length === 0) {
+      warn(`Unknown skill reference '${skillId}'`);
+      return [];
+    }
+    verbose(`Expanded directory '${skillId}' to ${childSkills.length} skills`);
+    return childSkills;
+  };
+  const uniqueSkillIds = unique(
+    skillIds.flatMap(({ id }) => idToDirectoryPath[id] ? [id] : expandDirectoryRef(id))
+  );
+  for (const skillId of uniqueSkillIds) {
+    const directoryPath = idToDirectoryPath[skillId];
+    if (!directoryPath) {
+      warn(`Could not find skill '${skillId}': no matching skill found`);
+      continue;
+    }
+    const skillPath = path2.join(skillsDir, directoryPath);
+    const skillMdPath = path2.join(skillPath, STANDARD_FILES.SKILL_MD);
+    try {
+      const content = await readFile(skillMdPath);
+      const frontmatter = parseFrontmatter(content, skillMdPath);
+      if (!frontmatter) {
+        warn(`Skipping '${skillId}': missing or invalid frontmatter`);
+        continue;
+      }
+      const canonicalId = frontmatter.name;
+      const skillDef = {
+        id: canonicalId,
+        path: `${DIRS.skills}/${directoryPath}/`,
+        description: frontmatter.description
+      };
+      skills[canonicalId] = skillDef;
+      verbose(`Loaded skill: ${canonicalId} (from ${directoryPath})`);
+    } catch (error) {
+      warn(`Could not load skill '${skillId}': ${error}`);
+    }
+  }
+  return skills;
+}
+async function loadSkillsFromDir(skillsDir, options = {}) {
+  const { pathPrefix = "", requireMetadata = false } = options;
+  const skills = {};
+  if (!await directoryExists(skillsDir)) {
+    return skills;
+  }
+  const skillFiles = await glob(`**/${STANDARD_FILES.SKILL_MD}`, skillsDir);
+  for (const skillFile of skillFiles) {
+    const skillPath = path2.join(skillsDir, skillFile);
+    const skillDir = path2.dirname(skillPath);
+    const relativePath = path2.relative(skillsDir, skillDir);
+    const skillDirName = path2.basename(skillDir);
+    const displayPath = pathPrefix ? `${pathPrefix}/${relativePath}/` : `${relativePath}/`;
+    if (requireMetadata) {
+      const metadataPath = path2.join(skillDir, STANDARD_FILES.METADATA_YAML);
+      if (!await fileExists(metadataPath)) {
+        warn(
+          `Skill '${skillDirName}' in '${displayPath}' is missing ${STANDARD_FILES.METADATA_YAML} \u2014 skipped. Add ${STANDARD_FILES.METADATA_YAML} to register it with the CLI.`
+        );
+        continue;
+      }
+    }
+    try {
+      const content = await readFile(skillPath);
+      const frontmatter = parseFrontmatter(content, skillPath);
+      if (!frontmatter?.name) {
+        warn(`Skipping skill in '${skillDirName}': missing or invalid frontmatter name`);
+        continue;
+      }
+      const canonicalId = frontmatter.name;
+      skills[canonicalId] = {
+        id: canonicalId,
+        path: displayPath,
+        description: frontmatter.description || ""
+      };
+      verbose(`  Loaded skill: ${canonicalId}`);
+    } catch (error) {
+      verbose(`  Failed to load skill: ${skillFile} - ${error}`);
+    }
+  }
+  return skills;
+}
+async function loadPluginSkills(pluginDir) {
+  return loadSkillsFromDir(path2.join(pluginDir, "skills"), {
+    pathPrefix: "skills",
+    requireMetadata: false
+  });
+}
+
+export {
+  getErrorMessage,
+  setVerbose,
+  verbose,
+  log,
+  enableBuffering,
+  drainBuffer,
+  disableBuffering,
+  warn,
+  extractFrontmatter,
+  GlobalPairWriteViolation,
+  withGateToken,
+  assertGateToken,
+  isPathWithin,
+  readFile,
+  readFileSafe,
+  readFileOptional,
+  fileExists,
+  directoryExists,
+  listDirectories,
+  glob,
+  writeFile,
+  ensureDir,
+  remove,
+  copy,
+  formatZodErrors,
+  DOMAINS,
+  AGENT_NAMES,
+  MODEL_NAMES,
+  EFFORT_NAMES,
+  modelNameSchema,
+  skillMetadataLoaderSchema,
+  matrixRawMetadataSchema,
+  pluginManifestSchema,
+  pluginManifestValidationSchema,
+  projectConfigLoaderSchema,
+  skillCategoriesFileSchema,
+  skillRulesFileSchema,
+  localRawMetadataSchema,
+  localSkillMetadataSchema,
+  stacksConfigSchema,
+  marketplaceSchema,
+  settingsFileSchema,
+  importedSkillMetadataSchema,
+  projectSourceConfigSchema,
+  agentYamlGenerationSchema,
+  agentFrontmatterValidationSchema,
+  skillFrontmatterValidationSchema,
+  metadataValidationSchema,
+  stackConfigValidationSchema,
+  formatZodIssues,
+  validateSkillMetadata,
+  splitMetadataValidationIssues,
+  validateNestingDepth,
+  warnUnknownFields,
+  parseFrontmatter,
+  loadAllAgents,
+  loadMergedAgents,
+  loadProjectAgents,
+  loadSkillsByIds,
+  loadSkillsFromDir,
+  loadPluginSkills
+};
+//# sourceMappingURL=chunk-3LIU2ZEF.js.map