agentpacks 1.7.6 → 1.7.9

package/dist/cli/models-explain.js

@@ -2,10 +2,10 @@
 var __require = import.meta.require;
 
 // src/core/config.ts
-import { z } from "zod";
-import { readFileSync, existsSync } from "fs";
-import { resolve } from "path";
+import { existsSync, readFileSync } from "fs";
 import { parse as parseJsonc } from "jsonc-parser";
+import { resolve } from "path";
+import { z } from "zod";
 var TARGET_IDS = [
   "opencode",
   "cursor",
@@ -138,13 +138,13 @@ function resolveTargets(config) {
 import {
   existsSync as existsSync2,
   mkdirSync,
-  readFileSync as readFileSync2,
-  writeFileSync,
   readdirSync,
+  readFileSync as readFileSync2,
   rmSync,
-  statSync
+  statSync,
+  writeFileSync
 } from "fs";
-import { dirname, relative, join } from "path";
+import { dirname, join, relative } from "path";
 var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
 var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
 var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
@@ -244,194 +244,355 @@ function getHeader(type) {
   }
 }
 
-// src/utils/frontmatter.ts
-import matter from "gray-matter";
-function parseFrontmatter(source) {
-  const { data, content } = matter(source);
-  return {
-    data,
-    content: content.trim(),
-    raw: source
-  };
-}
-function serializeFrontmatter(data, content) {
-  const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
-  if (Object.keys(filtered).length === 0) {
-    return content;
-  }
-  return matter.stringify(content, filtered);
-}
-
-// src/features/rules.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { basename } from "path";
-function parseRules(rulesDir, packName) {
-  const files = listFiles(rulesDir, { extension: ".md" });
-  return files.map((filepath) => parseRuleFile(filepath, packName));
-}
-function parseRuleFile(filepath, packName) {
-  const raw = readFileSync3(filepath, "utf-8");
-  const { data, content } = parseFrontmatter(raw);
-  return {
-    name: basename(filepath, ".md"),
-    sourcePath: filepath,
-    packName,
-    meta: data,
-    content
-  };
-}
-function ruleMatchesTarget(rule, targetId) {
-  const { targets } = rule.meta;
-  if (!targets || targets === "*")
-    return true;
-  if (Array.isArray(targets) && targets.includes("*"))
-    return true;
-  return Array.isArray(targets) && targets.includes(targetId);
-}
-function getRootRules(rules) {
-  return rules.filter((r) => r.meta.root === true);
-}
-function getDetailRules(rules) {
-  return rules.filter((r) => r.meta.root !== true);
-}
-
-// src/features/commands.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { basename as basename2 } from "path";
-function parseCommands(commandsDir, packName) {
-  const files = listFiles(commandsDir, { extension: ".md" });
-  return files.map((filepath) => parseCommandFile(filepath, packName));
-}
-function parseCommandFile(filepath, packName) {
-  const raw = readFileSync4(filepath, "utf-8");
-  const { data, content } = parseFrontmatter(raw);
-  return {
-    name: basename2(filepath, ".md"),
-    sourcePath: filepath,
-    packName,
-    meta: data,
-    content
-  };
-}
-function commandMatchesTarget(cmd, targetId) {
-  const { targets } = cmd.meta;
-  if (!targets || targets === "*")
-    return true;
-  if (Array.isArray(targets) && targets.includes("*"))
-    return true;
-  return Array.isArray(targets) && targets.includes(targetId);
-}
-
-// src/features/agents.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { basename as basename3 } from "path";
-function parseAgents(agentsDir, packName) {
-  const files = listFiles(agentsDir, { extension: ".md" });
-  return files.map((filepath) => parseAgentFile(filepath, packName));
-}
-function parseAgentFile(filepath, packName) {
-  const raw = readFileSync5(filepath, "utf-8");
-  const { data, content } = parseFrontmatter(raw);
-  return {
-    name: data.name ?? basename3(filepath, ".md"),
-    sourcePath: filepath,
-    packName,
-    meta: data,
-    content
-  };
-}
-function agentMatchesTarget(agent, targetId) {
-  const { targets } = agent.meta;
-  if (!targets || targets === "*")
-    return true;
-  if (Array.isArray(targets) && targets.includes("*"))
-    return true;
-  return Array.isArray(targets) && targets.includes(targetId);
-}
-
-// src/features/skills.ts
-import { readFileSync as readFileSync6, existsSync as existsSync3 } from "fs";
-import { basename as basename4, join as join2 } from "path";
-var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var SKILL_NAME_MAX_LENGTH = 64;
-function parseSkills(skillsDir, packName) {
-  const dirs = listDirs(skillsDir);
-  const skills = [];
-  for (const dir of dirs) {
-    const skillMd = join2(dir, "SKILL.md");
-    if (existsSync3(skillMd)) {
-      skills.push(parseSkillFile(skillMd, dir, packName));
-    }
-  }
-  return skills;
-}
-function parseSkillFile(filepath, skillDir, packName) {
-  const raw = readFileSync6(filepath, "utf-8");
-  const { data, content } = parseFrontmatter(raw);
+// src/features/models.ts
+import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var SECRET_PATTERNS = [
+  /["']api[_-]?key["']\s*:/i,
+  /["']apiKey["']\s*:/i,
+  /["']secret["']\s*:/i,
+  /["']password["']\s*:/i,
+  /["'](?:auth_token|access_token|bearer_token)["']\s*:/i,
+  /["']private[_-]?key["']\s*:/i,
+  /-----BEGIN\s+(RSA|EC|DSA|OPENSSH|PGP)\s+PRIVATE\s+KEY-----/,
+  /sk-[a-zA-Z0-9]{20,}/,
+  /Bearer\s+[a-zA-Z0-9._-]{20,}/
+];
+var AgentModelSchema = z2.object({
+  model: z2.string(),
+  temperature: z2.number().min(0).max(2).optional(),
+  top_p: z2.number().min(0).max(1).optional()
+});
+var ModelProfileSchema = z2.object({
+  extends: z2.string().optional(),
+  description: z2.string().optional(),
+  default: z2.string().optional(),
+  small: z2.string().optional(),
+  agents: z2.record(z2.string(), AgentModelSchema).optional()
+});
+var RoutingConditionSchema = z2.object({
+  complexity: z2.enum(["low", "medium", "high", "critical"]).optional().describe("Task complexity level"),
+  urgency: z2.enum(["low", "normal", "high"]).optional().describe("Time sensitivity"),
+  budget: z2.enum(["minimal", "standard", "premium"]).optional().describe("Cost/token budget tier"),
+  contextWindowNeed: z2.enum(["small", "medium", "large", "max"]).optional().describe("Required context window size"),
+  toolUseIntensity: z2.enum(["none", "light", "heavy"]).optional().describe("Expected tool/function calling intensity")
+});
+var RoutingRuleSchema = z2.object({
+  when: z2.record(z2.string(), z2.string()),
+  use: z2.string(),
+  description: z2.string().optional(),
+  priority: z2.number().optional()
+});
+var ProviderModelSchema = z2.object({
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  variants: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional()
+});
+var ProviderConfigSchema = z2.object({
+  options: z2.record(z2.string(), z2.unknown()).optional(),
+  models: z2.record(z2.string(), ProviderModelSchema).optional()
+});
+var ModelsSchema = z2.object({
+  default: z2.string().optional(),
+  small: z2.string().optional(),
+  agents: z2.record(z2.string(), AgentModelSchema).optional(),
+  profiles: z2.record(z2.string(), ModelProfileSchema).optional(),
+  providers: z2.record(z2.string(), ProviderConfigSchema).optional(),
+  routing: z2.array(RoutingRuleSchema).optional(),
+  overrides: z2.record(z2.string(), z2.object({
+    default: z2.string().optional(),
+    small: z2.string().optional(),
+    agents: z2.record(z2.string(), AgentModelSchema).optional()
+  })).optional()
+});
+function parseModels(packDir, packName) {
+  const modelsPath = join2(packDir, "models.json");
+  const raw = readJsonOrNull(modelsPath);
+  if (!raw)
+    return null;
+  const parsed = ModelsSchema.parse(raw);
   return {
-    name: data.name ?? basename4(skillDir),
-    sourcePath: filepath,
-    sourceDir: skillDir,
     packName,
-    meta: data,
-    content
-  };
-}
-function buildSkillFrontmatter(skill) {
-  return {
-    ...skill.meta,
-    name: skill.name
-  };
-}
-function serializeSkill(skill) {
-  return serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
-}
-function normalizeImportedSkillMarkdown(source, skillName) {
-  const { data, content } = parseFrontmatter(source);
-  const normalized = {
-    ...data,
-    name: skillName
-  };
-  let addedDescription = false;
-  const description = normalized.description;
-  if (typeof description !== "string" || description.trim().length === 0) {
-    normalized.description = `Imported skill: ${skillName}`;
-    addedDescription = true;
-  }
-  return {
-    content: serializeFrontmatter(normalized, content),
-    addedDescription
+    sourcePath: modelsPath,
+    config: parsed
   };
 }
-function validateAgentSkillsFrontmatter(skill) {
-  const errors = [];
-  const dirName = basename4(skill.sourceDir);
-  const declaredName = skill.meta.name;
-  if (typeof declaredName !== "string" || declaredName.trim().length === 0) {
-    errors.push('Missing required frontmatter field "name".');
-  } else {
-    if (declaredName.length > SKILL_NAME_MAX_LENGTH) {
-      errors.push(`Invalid "name": must be at most ${SKILL_NAME_MAX_LENGTH} characters.`);
+function mergeModelsConfigs(configs) {
+  const warnings = [];
+  const result = {};
+  for (const entry of configs) {
+    const { config, packName } = entry;
+    if (config.default !== undefined && result.default === undefined) {
+      result.default = config.default;
+    } else if (config.default !== undefined && result.default !== undefined) {
+      warnings.push(`Models "default" from pack "${packName}" skipped (already defined).`);
     }
-    if (!SKILL_NAME_PATTERN.test(declaredName)) {
-      errors.push('Invalid "name": use lowercase letters, numbers, and single hyphens only.');
+    if (config.small !== undefined && result.small === undefined) {
+      result.small = config.small;
+    } else if (config.small !== undefined && result.small !== undefined) {
+      warnings.push(`Models "small" from pack "${packName}" skipped (already defined).`);
     }
-    if (declaredName !== dirName) {
-      errors.push(`Invalid "name": must match containing directory "${dirName}".`);
+    if (config.agents) {
+      if (!result.agents)
+        result.agents = {};
+      for (const [name, assignment] of Object.entries(config.agents)) {
+        if (name in result.agents) {
+          warnings.push(`Models agent "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.agents[name] = assignment;
+      }
+    }
+    if (config.profiles) {
+      if (!result.profiles)
+        result.profiles = {};
+      for (const [name, profile] of Object.entries(config.profiles)) {
+        if (name in result.profiles) {
+          warnings.push(`Models profile "${name}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.profiles[name] = profile;
+      }
+    }
+    if (config.providers) {
+      if (!result.providers)
+        result.providers = {};
+      for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+        if (!(providerName in result.providers)) {
+          result.providers[providerName] = providerConfig;
+        } else {
+          const existing = result.providers[providerName];
+          if (!existing) {
+            result.providers[providerName] = providerConfig;
+            continue;
+          }
+          if (providerConfig.options) {
+            existing.options = {
+              ...providerConfig.options,
+              ...existing.options
+            };
+          }
+          if (providerConfig.models) {
+            if (!existing.models)
+              existing.models = {};
+            for (const [modelName, modelConfig] of Object.entries(providerConfig.models)) {
+              if (!(modelName in existing.models)) {
+                existing.models[modelName] = modelConfig;
+              }
+            }
+          }
+        }
+      }
+    }
+    if (config.routing) {
+      if (!result.routing)
+        result.routing = [];
+      result.routing.push(...config.routing);
+    }
+    if (config.overrides) {
+      if (!result.overrides)
+        result.overrides = {};
+      for (const [targetId, override] of Object.entries(config.overrides)) {
+        if (targetId in result.overrides) {
+          warnings.push(`Models override for target "${targetId}" from pack "${packName}" skipped (already defined).`);
+          continue;
+        }
+        result.overrides[targetId] = override;
+      }
     }
   }
-  const description = skill.meta.description;
-  if (typeof description !== "string" || description.trim().length === 0) {
-    errors.push('Missing required frontmatter field "description".');
-  }
-  const allowedTools = skill.meta["allowed-tools"];
-  if (allowedTools !== undefined && (!Array.isArray(allowedTools) || allowedTools.some((tool) => typeof tool !== "string" || tool.length === 0))) {
-    errors.push('Invalid "allowed-tools": expected an array of non-empty strings.');
-  }
-  return errors;
+  return { config: result, warnings };
 }
-function skillMatchesTarget(skill, targetId) {
-  const { targets } = skill.meta;
+function scanModelsForSecrets(config) {
+  const warnings = [];
+  const json = JSON.stringify(config);
+  for (const pattern of SECRET_PATTERNS) {
+    if (pattern.test(json)) {
+      warnings.push(`Potential secret detected in models.json matching pattern: ${pattern.source}`);
+    }
+  }
+  return warnings;
+}
+
+// src/core/feature-merger.ts
+class FeatureMerger {
+  packs;
+  warnings = [];
+  constructor(packs) {
+    this.packs = packs;
+  }
+  merge() {
+    this.warnings = [];
+    const features = {
+      rules: this.mergeRules(),
+      commands: this.mergeByName("commands"),
+      agents: this.mergeByName("agents"),
+      skills: this.mergeByName("skills"),
+      hooks: this.mergeHooks(),
+      plugins: this.mergePlugins(),
+      mcpServers: this.mergeMcp(),
+      ignorePatterns: this.mergeIgnore(),
+      models: this.mergeModels()
+    };
+    return { features, warnings: this.warnings };
+  }
+  mergeRules() {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      for (const rule of pack.rules) {
+        const existing = seen.get(rule.name);
+        if (existing) {
+          this.warnings.push(`Rule "${rule.name}" from pack "${rule.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(rule.name, rule.packName);
+        result.push(rule);
+      }
+    }
+    return result;
+  }
+  mergeByName(featureKey) {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      const items = pack[featureKey];
+      for (const item of items) {
+        const existing = seen.get(item.name);
+        if (existing) {
+          this.warnings.push(`${featureKey.slice(0, -1)} "${item.name}" from pack "${item.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(item.name, item.packName);
+        result.push(item);
+      }
+    }
+    return result;
+  }
+  mergeHooks() {
+    return this.packs.map((p) => p.hooks).filter((h) => h !== null);
+  }
+  mergePlugins() {
+    const seen = new Map;
+    const result = [];
+    for (const pack of this.packs) {
+      for (const plugin of pack.plugins) {
+        const key = `${plugin.name}.${plugin.extension}`;
+        const existing = seen.get(key);
+        if (existing) {
+          this.warnings.push(`Plugin "${key}" from pack "${plugin.packName}" skipped (already defined by "${existing}").`);
+          continue;
+        }
+        seen.set(key, plugin.packName);
+        result.push(plugin);
+      }
+    }
+    return result;
+  }
+  mergeMcp() {
+    const servers = {};
+    for (const pack of this.packs) {
+      if (!pack.mcp)
+        continue;
+      for (const [name, entry] of Object.entries(pack.mcp.servers)) {
+        if (name in servers) {
+          this.warnings.push(`MCP server "${name}" from pack "${pack.manifest.name}" skipped (already defined).`);
+          continue;
+        }
+        servers[name] = entry;
+      }
+    }
+    return servers;
+  }
+  mergeIgnore() {
+    const seen = new Set;
+    const result = [];
+    for (const pack of this.packs) {
+      if (!pack.ignore)
+        continue;
+      for (const pattern of pack.ignore.patterns) {
+        if (!seen.has(pattern)) {
+          seen.add(pattern);
+          result.push(pattern);
+        }
+      }
+    }
+    return result;
+  }
+  mergeModels() {
+    const configs = this.packs.map((p) => p.models).filter((m) => m != null);
+    if (configs.length === 0)
+      return null;
+    const { config, warnings } = mergeModelsConfigs(configs);
+    this.warnings.push(...warnings);
+    return config;
+  }
+}
+
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(source) {
+  const { data, content } = matter(source);
+  return {
+    data,
+    content: content.trim(),
+    raw: source
+  };
+}
+function serializeFrontmatter(data, content) {
+  const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+  if (Object.keys(filtered).length === 0) {
+    return content;
+  }
+  return matter.stringify(content, filtered);
+}
+
+// src/features/agents.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename } from "path";
+function parseAgents(agentsDir, packName) {
+  const files = listFiles(agentsDir, { extension: ".md" });
+  return files.map((filepath) => parseAgentFile(filepath, packName));
+}
+function parseAgentFile(filepath, packName) {
+  const raw = readFileSync3(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: data.name ?? basename(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function agentMatchesTarget(agent, targetId) {
+  const { targets } = agent.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
+// src/features/commands.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { basename as basename2 } from "path";
+function parseCommands(commandsDir, packName) {
+  const files = listFiles(commandsDir, { extension: ".md" });
+  return files.map((filepath) => parseCommandFile(filepath, packName));
+}
+function parseCommandFile(filepath, packName) {
+  const raw = readFileSync4(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename2(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function commandMatchesTarget(cmd, targetId) {
+  const { targets } = cmd.meta;
   if (!targets || targets === "*")
     return true;
   if (Array.isArray(targets) && targets.includes("*"))
@@ -477,28 +638,41 @@ function resolveHooksForTarget(hooks, targetId) {
   return merged;
 }
 
-// src/features/plugins.ts
-import { readFileSync as readFileSync7, existsSync as existsSync4 } from "fs";
-import { basename as basename5, join as join4 } from "path";
-function parsePlugins(packDir, packName) {
-  const pluginsDir = join4(packDir, "plugins");
-  if (!existsSync4(pluginsDir))
-    return [];
-  const tsFiles = listFiles(pluginsDir, { extension: ".ts" });
-  const jsFiles = listFiles(pluginsDir, { extension: ".js" });
-  const allFiles = [...tsFiles, ...jsFiles];
-  return allFiles.map((filepath) => parsePluginFile(filepath, packName));
+// src/features/ignore.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join4 } from "path";
+var IGNORE_FILES = ["ignore", ".aiignore"];
+function parseIgnore(packDir, packName) {
+  for (const filename of IGNORE_FILES) {
+    const filepath = join4(packDir, filename);
+    if (existsSync3(filepath)) {
+      const raw = readFileSync5(filepath, "utf-8");
+      const patterns = parseIgnoreContent(raw);
+      return {
+        packName,
+        sourcePath: filepath,
+        patterns
+      };
+    }
+  }
+  return null;
 }
-function parsePluginFile(filepath, packName) {
-  const content = readFileSync7(filepath, "utf-8");
-  const ext = filepath.endsWith(".ts") ? "ts" : "js";
-  return {
-    name: basename5(filepath, `.${ext}`),
-    sourcePath: filepath,
-    packName,
-    content,
-    extension: ext
-  };
+function parseIgnoreContent(content) {
+  return content.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function mergeIgnorePatterns(configs) {
+  const seen = new Set;
+  const result = [];
+  for (const config of configs) {
+    for (const pattern of config.patterns) {
+      if (!seen.has(pattern)) {
+        seen.add(pattern);
+        result.push(pattern);
+      }
+    }
+  }
+  return result;
 }
 
 // src/features/mcp.ts
@@ -529,215 +703,156 @@ function mergeMcpConfigs(configs) {
   return { servers, warnings };
 }
 
-// src/features/ignore.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
-import { join as join6 } from "path";
-var IGNORE_FILES = ["ignore", ".aiignore"];
-function parseIgnore(packDir, packName) {
-  for (const filename of IGNORE_FILES) {
-    const filepath = join6(packDir, filename);
-    if (existsSync5(filepath)) {
-      const raw = readFileSync8(filepath, "utf-8");
-      const patterns = parseIgnoreContent(raw);
-      return {
-        packName,
-        sourcePath: filepath,
-        patterns
-      };
-    }
-  }
-  return null;
+// src/features/plugins.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
+import { basename as basename3, join as join6 } from "path";
+function parsePlugins(packDir, packName) {
+  const pluginsDir = join6(packDir, "plugins");
+  if (!existsSync4(pluginsDir))
+    return [];
+  const tsFiles = listFiles(pluginsDir, { extension: ".ts" });
+  const jsFiles = listFiles(pluginsDir, { extension: ".js" });
+  const allFiles = [...tsFiles, ...jsFiles];
+  return allFiles.map((filepath) => parsePluginFile(filepath, packName));
 }
-function parseIgnoreContent(content) {
-  return content.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+function parsePluginFile(filepath, packName) {
+  const content = readFileSync6(filepath, "utf-8");
+  const ext = filepath.endsWith(".ts") ? "ts" : "js";
+  return {
+    name: basename3(filepath, `.${ext}`),
+    sourcePath: filepath,
+    packName,
+    content,
+    extension: ext
+  };
 }
-function mergeIgnorePatterns(configs) {
-  const seen = new Set;
-  const result = [];
-  for (const config of configs) {
-    for (const pattern of config.patterns) {
-      if (!seen.has(pattern)) {
-        seen.add(pattern);
-        result.push(pattern);
-      }
+
+// src/features/rules.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { basename as basename4 } from "path";
+function parseRules(rulesDir, packName) {
+  const files = listFiles(rulesDir, { extension: ".md" });
+  return files.map((filepath) => parseRuleFile(filepath, packName));
+}
+function parseRuleFile(filepath, packName) {
+  const raw = readFileSync7(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename4(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function ruleMatchesTarget(rule, targetId) {
+  const { targets } = rule.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+function getRootRules(rules) {
+  return rules.filter((r) => r.meta.root === true);
+}
+function getDetailRules(rules) {
+  return rules.filter((r) => r.meta.root !== true);
+}
+
+// src/features/skills.ts
+import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
+import { basename as basename5, join as join7 } from "path";
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
+function parseSkills(skillsDir, packName) {
+  const dirs = listDirs(skillsDir);
+  const skills = [];
+  for (const dir of dirs) {
+    const skillMd = join7(dir, "SKILL.md");
+    if (existsSync5(skillMd)) {
+      skills.push(parseSkillFile(skillMd, dir, packName));
     }
   }
-  return result;
+  return skills;
 }
-
-// src/features/models.ts
-import { join as join7 } from "path";
-import { z as z2 } from "zod";
-var SECRET_PATTERNS = [
-  /["']api[_-]?key["']\s*:/i,
-  /["']apiKey["']\s*:/i,
-  /["']secret["']\s*:/i,
-  /["']password["']\s*:/i,
-  /["'](?:auth_token|access_token|bearer_token)["']\s*:/i,
-  /["']private[_-]?key["']\s*:/i,
-  /-----BEGIN\s+(RSA|EC|DSA|OPENSSH|PGP)\s+PRIVATE\s+KEY-----/,
-  /sk-[a-zA-Z0-9]{20,}/,
-  /Bearer\s+[a-zA-Z0-9._-]{20,}/
-];
-var AgentModelSchema = z2.object({
-  model: z2.string(),
-  temperature: z2.number().min(0).max(2).optional(),
-  top_p: z2.number().min(0).max(1).optional()
-});
-var ModelProfileSchema = z2.object({
-  extends: z2.string().optional(),
-  description: z2.string().optional(),
-  default: z2.string().optional(),
-  small: z2.string().optional(),
-  agents: z2.record(z2.string(), AgentModelSchema).optional()
-});
-var RoutingConditionSchema = z2.object({
-  complexity: z2.enum(["low", "medium", "high", "critical"]).optional().describe("Task complexity level"),
-  urgency: z2.enum(["low", "normal", "high"]).optional().describe("Time sensitivity"),
-  budget: z2.enum(["minimal", "standard", "premium"]).optional().describe("Cost/token budget tier"),
-  contextWindowNeed: z2.enum(["small", "medium", "large", "max"]).optional().describe("Required context window size"),
-  toolUseIntensity: z2.enum(["none", "light", "heavy"]).optional().describe("Expected tool/function calling intensity")
-});
-var RoutingRuleSchema = z2.object({
-  when: z2.record(z2.string(), z2.string()),
-  use: z2.string(),
-  description: z2.string().optional(),
-  priority: z2.number().optional()
-});
-var ProviderModelSchema = z2.object({
-  options: z2.record(z2.string(), z2.unknown()).optional(),
-  variants: z2.record(z2.string(), z2.record(z2.string(), z2.unknown())).optional()
-});
-var ProviderConfigSchema = z2.object({
-  options: z2.record(z2.string(), z2.unknown()).optional(),
-  models: z2.record(z2.string(), ProviderModelSchema).optional()
-});
-var ModelsSchema = z2.object({
-  default: z2.string().optional(),
-  small: z2.string().optional(),
-  agents: z2.record(z2.string(), AgentModelSchema).optional(),
-  profiles: z2.record(z2.string(), ModelProfileSchema).optional(),
-  providers: z2.record(z2.string(), ProviderConfigSchema).optional(),
-  routing: z2.array(RoutingRuleSchema).optional(),
-  overrides: z2.record(z2.string(), z2.object({
-    default: z2.string().optional(),
-    small: z2.string().optional(),
-    agents: z2.record(z2.string(), AgentModelSchema).optional()
-  })).optional()
-});
-function parseModels(packDir, packName) {
-  const modelsPath = join7(packDir, "models.json");
-  const raw = readJsonOrNull(modelsPath);
-  if (!raw)
-    return null;
-  const parsed = ModelsSchema.parse(raw);
+function parseSkillFile(filepath, skillDir, packName) {
+  const raw = readFileSync8(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: data.name ?? basename5(skillDir),
+    sourcePath: filepath,
+    sourceDir: skillDir,
+    packName,
+    meta: data,
+    content
+  };
+}
+function buildSkillFrontmatter(skill) {
+  return {
+    ...skill.meta,
+    name: skill.name
+  };
+}
+function serializeSkill(skill) {
+  return serializeFrontmatter(buildSkillFrontmatter(skill), skill.content);
+}
+function normalizeImportedSkillMarkdown(source, skillName) {
+  const { data, content } = parseFrontmatter(source);
+  const normalized = {
+    ...data,
+    name: skillName
+  };
+  let addedDescription = false;
+  const description = normalized.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    normalized.description = `Imported skill: ${skillName}`;
+    addedDescription = true;
+  }
   return {
-    packName,
-    sourcePath: modelsPath,
-    config: parsed
+    content: serializeFrontmatter(normalized, content),
+    addedDescription
   };
 }
-function mergeModelsConfigs(configs) {
-  const warnings = [];
-  const result = {};
-  for (const entry of configs) {
-    const { config, packName } = entry;
-    if (config.default !== undefined && result.default === undefined) {
-      result.default = config.default;
-    } else if (config.default !== undefined && result.default !== undefined) {
-      warnings.push(`Models "default" from pack "${packName}" skipped (already defined).`);
-    }
-    if (config.small !== undefined && result.small === undefined) {
-      result.small = config.small;
-    } else if (config.small !== undefined && result.small !== undefined) {
-      warnings.push(`Models "small" from pack "${packName}" skipped (already defined).`);
-    }
-    if (config.agents) {
-      if (!result.agents)
-        result.agents = {};
-      for (const [name, assignment] of Object.entries(config.agents)) {
-        if (name in result.agents) {
-          warnings.push(`Models agent "${name}" from pack "${packName}" skipped (already defined).`);
-          continue;
-        }
-        result.agents[name] = assignment;
-      }
-    }
-    if (config.profiles) {
-      if (!result.profiles)
-        result.profiles = {};
-      for (const [name, profile] of Object.entries(config.profiles)) {
-        if (name in result.profiles) {
-          warnings.push(`Models profile "${name}" from pack "${packName}" skipped (already defined).`);
-          continue;
-        }
-        result.profiles[name] = profile;
-      }
-    }
-    if (config.providers) {
-      if (!result.providers)
-        result.providers = {};
-      for (const [providerName, providerConfig] of Object.entries(config.providers)) {
-        if (!(providerName in result.providers)) {
-          result.providers[providerName] = providerConfig;
-        } else {
-          const existing = result.providers[providerName];
-          if (!existing) {
-            result.providers[providerName] = providerConfig;
-            continue;
-          }
-          if (providerConfig.options) {
-            existing.options = {
-              ...providerConfig.options,
-              ...existing.options
-            };
-          }
-          if (providerConfig.models) {
-            if (!existing.models)
-              existing.models = {};
-            for (const [modelName, modelConfig] of Object.entries(providerConfig.models)) {
-              if (!(modelName in existing.models)) {
-                existing.models[modelName] = modelConfig;
-              }
-            }
-          }
-        }
-      }
+function validateAgentSkillsFrontmatter(skill) {
+  const errors = [];
+  const dirName = basename5(skill.sourceDir);
+  const declaredName = skill.meta.name;
+  if (typeof declaredName !== "string" || declaredName.trim().length === 0) {
+    errors.push('Missing required frontmatter field "name".');
+  } else {
+    if (declaredName.length > SKILL_NAME_MAX_LENGTH) {
+      errors.push(`Invalid "name": must be at most ${SKILL_NAME_MAX_LENGTH} characters.`);
     }
-    if (config.routing) {
-      if (!result.routing)
-        result.routing = [];
-      result.routing.push(...config.routing);
+    if (!SKILL_NAME_PATTERN.test(declaredName)) {
+      errors.push('Invalid "name": use lowercase letters, numbers, and single hyphens only.');
     }
-    if (config.overrides) {
-      if (!result.overrides)
-        result.overrides = {};
-      for (const [targetId, override] of Object.entries(config.overrides)) {
-        if (targetId in result.overrides) {
-          warnings.push(`Models override for target "${targetId}" from pack "${packName}" skipped (already defined).`);
-          continue;
-        }
-        result.overrides[targetId] = override;
-      }
+    if (declaredName !== dirName) {
+      errors.push(`Invalid "name": must match containing directory "${dirName}".`);
     }
   }
-  return { config: result, warnings };
-}
-function scanModelsForSecrets(config) {
-  const warnings = [];
-  const json = JSON.stringify(config);
-  for (const pattern of SECRET_PATTERNS) {
-    if (pattern.test(json)) {
-      warnings.push(`Potential secret detected in models.json matching pattern: ${pattern.source}`);
-    }
+  const description = skill.meta.description;
+  if (typeof description !== "string" || description.trim().length === 0) {
+    errors.push('Missing required frontmatter field "description".');
   }
-  return warnings;
+  const allowedTools = skill.meta["allowed-tools"];
+  if (allowedTools !== undefined && (!Array.isArray(allowedTools) || allowedTools.some((tool) => typeof tool !== "string" || tool.length === 0))) {
+    errors.push('Invalid "allowed-tools": expected an array of non-empty strings.');
+  }
+  return errors;
+}
+function skillMatchesTarget(skill, targetId) {
+  const { targets } = skill.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
 }
 
 // src/core/pack-loader.ts
 import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve2, isAbsolute } from "path";
+import { isAbsolute, resolve as resolve2 } from "path";
 class PackLoader {
   projectRoot;
   config;
@@ -838,121 +953,6 @@ class PackLoader {
   }
 }
 
-// src/core/feature-merger.ts
-class FeatureMerger {
-  packs;
-  warnings = [];
-  constructor(packs) {
-    this.packs = packs;
-  }
-  merge() {
-    this.warnings = [];
-    const features = {
-      rules: this.mergeRules(),
-      commands: this.mergeByName("commands"),
-      agents: this.mergeByName("agents"),
-      skills: this.mergeByName("skills"),
-      hooks: this.mergeHooks(),
-      plugins: this.mergePlugins(),
-      mcpServers: this.mergeMcp(),
-      ignorePatterns: this.mergeIgnore(),
-      models: this.mergeModels()
-    };
-    return { features, warnings: this.warnings };
-  }
-  mergeRules() {
-    const seen = new Map;
-    const result = [];
-    for (const pack of this.packs) {
-      for (const rule of pack.rules) {
-        const existing = seen.get(rule.name);
-        if (existing) {
-          this.warnings.push(`Rule "${rule.name}" from pack "${rule.packName}" skipped (already defined by "${existing}").`);
-          continue;
-        }
-        seen.set(rule.name, rule.packName);
-        result.push(rule);
-      }
-    }
-    return result;
-  }
-  mergeByName(featureKey) {
-    const seen = new Map;
-    const result = [];
-    for (const pack of this.packs) {
-      const items = pack[featureKey];
-      for (const item of items) {
-        const existing = seen.get(item.name);
-        if (existing) {
-          this.warnings.push(`${featureKey.slice(0, -1)} "${item.name}" from pack "${item.packName}" skipped (already defined by "${existing}").`);
-          continue;
-        }
-        seen.set(item.name, item.packName);
-        result.push(item);
-      }
-    }
-    return result;
-  }
-  mergeHooks() {
-    return this.packs.map((p) => p.hooks).filter((h) => h !== null);
-  }
-  mergePlugins() {
-    const seen = new Map;
-    const result = [];
-    for (const pack of this.packs) {
-      for (const plugin of pack.plugins) {
-        const key = `${plugin.name}.${plugin.extension}`;
-        const existing = seen.get(key);
-        if (existing) {
-          this.warnings.push(`Plugin "${key}" from pack "${plugin.packName}" skipped (already defined by "${existing}").`);
-          continue;
-        }
-        seen.set(key, plugin.packName);
-        result.push(plugin);
-      }
-    }
-    return result;
-  }
-  mergeMcp() {
-    const servers = {};
-    for (const pack of this.packs) {
-      if (!pack.mcp)
-        continue;
-      for (const [name, entry] of Object.entries(pack.mcp.servers)) {
-        if (name in servers) {
-          this.warnings.push(`MCP server "${name}" from pack "${pack.manifest.name}" skipped (already defined).`);
-          continue;
-        }
-        servers[name] = entry;
-      }
-    }
-    return servers;
-  }
-  mergeIgnore() {
-    const seen = new Set;
-    const result = [];
-    for (const pack of this.packs) {
-      if (!pack.ignore)
-        continue;
-      for (const pattern of pack.ignore.patterns) {
-        if (!seen.has(pattern)) {
-          seen.add(pattern);
-          result.push(pattern);
-        }
-      }
-    }
-    return result;
-  }
-  mergeModels() {
-    const configs = this.packs.map((p) => p.models).filter((m) => m != null);
-    if (configs.length === 0)
-      return null;
-    const { config, warnings } = mergeModelsConfigs(configs);
-    this.warnings.push(...warnings);
-    return config;
-  }
-}
-
 // src/core/profile-resolver.ts
 function resolveModels(merged, modelProfile, targetId) {
   let defaultModel = merged.default;