agentpacks 0.3.0 → 0.4.0

package/dist/node/core/index.js

@@ -1,51 +1,85 @@
 import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/core/config.ts
-var exports_config = {};
-__export(exports_config, {
-  resolveTargets: () => resolveTargets,
-  resolveFeatures: () => resolveFeatures,
-  loadWorkspaceConfig: () => loadWorkspaceConfig,
-  loadPackManifest: () => loadPackManifest,
-  WorkspaceConfigSchema: () => WorkspaceConfigSchema,
-  TARGET_IDS: () => TARGET_IDS,
-  REPO_MODES: () => REPO_MODES,
-  PackManifestSchema: () => PackManifestSchema,
-  FEATURE_IDS: () => FEATURE_IDS
-});
 import { z } from "zod";
 import { readFileSync, existsSync } from "fs";
 import { resolve } from "path";
 import { parse as parseJsonc } from "jsonc-parser";
+var TARGET_IDS = [
+  "opencode",
+  "cursor",
+  "claudecode",
+  "codexcli",
+  "geminicli",
+  "copilot",
+  "agentsmd",
+  "cline",
+  "kilo",
+  "roo",
+  "qwencode",
+  "kiro",
+  "factorydroid",
+  "antigravity",
+  "junie",
+  "augmentcode",
+  "windsurf",
+  "warp",
+  "replit",
+  "zed"
+];
+var FEATURE_IDS = [
+  "rules",
+  "commands",
+  "agents",
+  "skills",
+  "hooks",
+  "plugins",
+  "mcp",
+  "ignore",
+  "models"
+];
+var REPO_MODES = ["repo", "monorepo", "metarepo"];
+var PackManifestSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().default("1.0.0"),
+  description: z.string().default(""),
+  author: z.union([
+    z.string(),
+    z.object({ name: z.string(), email: z.string().optional() })
+  ]).optional(),
+  tags: z.array(z.string()).default([]),
+  dependencies: z.array(z.string()).default([]),
+  conflicts: z.array(z.string()).default([]),
+  targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+  features: z.union([z.literal("*"), z.array(z.string())]).default("*")
+});
+var FeaturesSchema = z.union([
+  z.literal("*"),
+  z.array(z.string()),
+  z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
+]);
+var WorkspaceConfigSchema = z.object({
+  $schema: z.string().optional(),
+  packs: z.array(z.string()).default(["./packs/default"]),
+  disabled: z.array(z.string()).default([]),
+  targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+  features: FeaturesSchema.default("*"),
+  mode: z.enum(REPO_MODES).default("repo"),
+  baseDirs: z.array(z.string()).default(["."]),
+  global: z.boolean().default(false),
+  delete: z.boolean().default(true),
+  verbose: z.boolean().default(false),
+  silent: z.boolean().default(false),
+  overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
+  sources: z.array(z.object({
+    source: z.string(),
+    packs: z.array(z.string()).optional(),
+    skills: z.array(z.string()).optional()
+  })).default([]),
+  modelProfile: z.string().optional()
+});
+var CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
 function loadWorkspaceConfig(projectRoot) {
   for (const filename of CONFIG_FILES) {
     const filepath = resolve(projectRoot, filename);
@@ -91,81 +125,6 @@ function resolveTargets(config) {
     return [...TARGET_IDS];
   return config.targets;
 }
-var TARGET_IDS, FEATURE_IDS, REPO_MODES, PackManifestSchema, FeaturesSchema, WorkspaceConfigSchema, CONFIG_FILES;
-var init_config = __esm(() => {
-  TARGET_IDS = [
-    "opencode",
-    "cursor",
-    "claudecode",
-    "codexcli",
-    "geminicli",
-    "copilot",
-    "agentsmd",
-    "cline",
-    "kilo",
-    "roo",
-    "qwencode",
-    "kiro",
-    "factorydroid",
-    "antigravity",
-    "junie",
-    "augmentcode",
-    "windsurf",
-    "warp",
-    "replit",
-    "zed"
-  ];
-  FEATURE_IDS = [
-    "rules",
-    "commands",
-    "agents",
-    "skills",
-    "hooks",
-    "plugins",
-    "mcp",
-    "ignore"
-  ];
-  REPO_MODES = ["repo", "monorepo", "metarepo"];
-  PackManifestSchema = z.object({
-    name: z.string().min(1),
-    version: z.string().default("1.0.0"),
-    description: z.string().default(""),
-    author: z.union([
-      z.string(),
-      z.object({ name: z.string(), email: z.string().optional() })
-    ]).optional(),
-    tags: z.array(z.string()).default([]),
-    dependencies: z.array(z.string()).default([]),
-    conflicts: z.array(z.string()).default([]),
-    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
-    features: z.union([z.literal("*"), z.array(z.string())]).default("*")
-  });
-  FeaturesSchema = z.union([
-    z.literal("*"),
-    z.array(z.string()),
-    z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
-  ]);
-  WorkspaceConfigSchema = z.object({
-    $schema: z.string().optional(),
-    packs: z.array(z.string()).default(["./packs/default"]),
-    disabled: z.array(z.string()).default([]),
-    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
-    features: FeaturesSchema.default("*"),
-    mode: z.enum(REPO_MODES).default("repo"),
-    baseDirs: z.array(z.string()).default(["."]),
-    global: z.boolean().default(false),
-    delete: z.boolean().default(true),
-    verbose: z.boolean().default(false),
-    silent: z.boolean().default(false),
-    overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
-    sources: z.array(z.object({
-      source: z.string(),
-      packs: z.array(z.string()).optional(),
-      skills: z.array(z.string()).optional()
-    })).default([])
-  });
-  CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
-});
 
 // src/utils/filesystem.ts
 import {
@@ -174,10 +133,10 @@ import {
   readFileSync as readFileSync2,
   writeFileSync,
   readdirSync,
+  rmSync,
   statSync
 } from "fs";
 import { dirname, relative, join } from "path";
-import { removeSync } from "fs-extra";
 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.";
@@ -218,7 +177,7 @@ function ensureDir(dirPath) {
 }
 function removeIfExists(targetPath) {
   if (existsSync2(targetPath)) {
-    removeSync(targetPath);
+    rmSync(targetPath, { recursive: true, force: true });
   }
 }
 function listFiles(dirPath, options = {}) {
@@ -544,10 +503,178 @@ function mergeIgnorePatterns(configs) {
   return result;
 }
 
+// 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);
+  return {
+    packName,
+    sourcePath: modelsPath,
+    config: parsed
+  };
+}
+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;
+              }
+            }
+          }
+        }
+      }
+    }
+    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;
+      }
+    }
+  }
+  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}`);
+    }
+  }
+  return warnings;
+}
+
 // src/core/pack-loader.ts
-init_config();
 import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve3, isAbsolute } from "path";
+import { resolve as resolve2, isAbsolute } from "path";
 class PackLoader {
   projectRoot;
   config;
@@ -580,10 +707,10 @@ class PackLoader {
   }
   loadPack(packDir, manifest) {
     const name = manifest.name;
-    const rulesDir = resolve3(packDir, "rules");
-    const commandsDir = resolve3(packDir, "commands");
-    const agentsDir = resolve3(packDir, "agents");
-    const skillsDir = resolve3(packDir, "skills");
+    const rulesDir = resolve2(packDir, "rules");
+    const commandsDir = resolve2(packDir, "commands");
+    const agentsDir = resolve2(packDir, "agents");
+    const skillsDir = resolve2(packDir, "skills");
     return {
       manifest,
       directory: packDir,
@@ -594,23 +721,25 @@ class PackLoader {
       hooks: parseHooks(packDir, name),
       plugins: parsePlugins(packDir, name),
       mcp: parseMcp(packDir, name),
-      ignore: parseIgnore(packDir, name)
+      ignore: parseIgnore(packDir, name),
+      models: parseModels(packDir, name)
     };
   }
   loadForBaseDir(baseDir) {
-    const baseDirRoot = resolve3(this.projectRoot, baseDir);
-    const localConfigPath = resolve3(baseDirRoot, "agentpacks.jsonc");
+    const baseDirRoot = resolve2(this.projectRoot, baseDir);
+    const localConfigPath = resolve2(baseDirRoot, "agentpacks.jsonc");
     if (!existsSync6(localConfigPath)) {
       return { packs: [], warnings: [] };
     }
-    const { loadWorkspaceConfig: loadWorkspaceConfig2 } = (init_config(), __toCommonJS(exports_config));
-    const localConfig = loadWorkspaceConfig2(baseDirRoot);
+    const localConfig = loadWorkspaceConfig(baseDirRoot);
     const loader = new PackLoader(baseDirRoot, localConfig);
     return loader.loadAll();
   }
   resolveCuratedPack(packRef) {
-    const curatedDir = resolve3(this.projectRoot, ".agentpacks", ".curated");
+    const curatedDir = resolve2(this.projectRoot, ".agentpacks", ".curated");
     let packName = packRef;
+    if (packName.startsWith("registry:"))
+      packName = packName.slice(9);
     if (packName.startsWith("npm:"))
       packName = packName.slice(4);
     if (packName.startsWith("github:"))
@@ -621,24 +750,28 @@ class PackLoader {
       const parts = packName.split("/");
       packName = packName.includes("@") ? parts.join("-") : parts[parts.length - 1] ?? packName;
     }
-    packName = packName.split("@")[0].split(":")[0];
-    const resolved = resolve3(curatedDir, packName);
+    const withoutVersion = packName.split("@")[0] ?? packName;
+    packName = withoutVersion.split(":")[0] ?? withoutVersion;
+    const resolved = resolve2(curatedDir, packName);
     return existsSync6(resolved) ? resolved : null;
   }
   resolvePackPath(packRef) {
     if (packRef.startsWith("./") || packRef.startsWith("../")) {
-      return resolve3(this.projectRoot, packRef);
+      return resolve2(this.projectRoot, packRef);
     }
     if (isAbsolute(packRef)) {
       return packRef;
     }
+    if (packRef.startsWith("registry:")) {
+      return this.resolveCuratedPack(packRef);
+    }
     if (packRef.startsWith("@") || packRef.startsWith("npm:") || !packRef.includes("/")) {
       return this.resolveCuratedPack(packRef);
     }
     if (packRef.startsWith("github:") || packRef.includes("/")) {
       return this.resolveCuratedPack(packRef);
     }
-    return resolve3(this.projectRoot, packRef);
+    return resolve2(this.projectRoot, packRef);
   }
 }
 
@@ -659,7 +792,8 @@ class FeatureMerger {
       hooks: this.mergeHooks(),
       plugins: this.mergePlugins(),
       mcpServers: this.mergeMcp(),
-      ignorePatterns: this.mergeIgnore()
+      ignorePatterns: this.mergeIgnore(),
+      models: this.mergeModels()
     };
     return { features, warnings: this.warnings };
   }
@@ -746,16 +880,24 @@ class FeatureMerger {
     }
     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/lockfile.ts
 import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 import { createHash } from "crypto";
 var LOCKFILE_VERSION = 1;
 var LOCKFILE_NAME = "agentpacks.lock";
 function loadLockfile(projectRoot) {
-  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  const filepath = resolve3(projectRoot, LOCKFILE_NAME);
   if (!existsSync7(filepath)) {
     return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
   }
@@ -763,7 +905,7 @@ function loadLockfile(projectRoot) {
   return JSON.parse(raw);
 }
 function saveLockfile(projectRoot, lockfile) {
-  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  const filepath = resolve3(projectRoot, LOCKFILE_NAME);
   writeFileSync2(filepath, JSON.stringify(lockfile, null, 2) + `
 `);
 }
@@ -831,8 +973,12 @@ function topologicalSort(graph) {
   const sorted = [];
   while (queue.length > 0) {
     const current = queue.shift();
+    if (!current)
+      continue;
     sorted.push(current);
     const node = graph.get(current);
+    if (!node)
+      continue;
     for (const dep of node.dependencies) {
       if (!graph.has(dep))
         continue;
@@ -898,9 +1044,6 @@ function detectConflicts(graph) {
   }
   return conflicts;
 }
-
-// src/core/index.ts
-init_config();
 export {
   setLockedSource,
   saveLockfile,

package/dist/node/core/lockfile.js

@@ -1,32 +1,4 @@
 import { createRequire } from "node:module";
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/core/lockfile.ts