agentpacks 0.2.0

package/dist/core/pack-loader.js

@@ -0,0 +1,646 @@
+// @bun
+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 = import.meta.require;
+
+// 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";
+function loadWorkspaceConfig(projectRoot) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = resolve(projectRoot, filename);
+    if (existsSync(filepath)) {
+      const raw = readFileSync(filepath, "utf-8");
+      const parsed = parseJsonc(raw);
+      return WorkspaceConfigSchema.parse(parsed);
+    }
+  }
+  return WorkspaceConfigSchema.parse({});
+}
+function loadPackManifest(packDir) {
+  const filepath = resolve(packDir, "pack.json");
+  if (!existsSync(filepath)) {
+    const dirName = packDir.split("/").pop() ?? "unknown";
+    return PackManifestSchema.parse({ name: dirName });
+  }
+  const raw = readFileSync(filepath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return PackManifestSchema.parse(parsed);
+}
+function resolveFeatures(config, targetId) {
+  const { features } = config;
+  if (features === "*") {
+    return [...FEATURE_IDS];
+  }
+  if (Array.isArray(features)) {
+    if (features.includes("*"))
+      return [...FEATURE_IDS];
+    return features.filter((f) => FEATURE_IDS.includes(f));
+  }
+  const targetFeatures = features[targetId];
+  if (!targetFeatures)
+    return [];
+  if (targetFeatures === "*")
+    return [...FEATURE_IDS];
+  if (Array.isArray(targetFeatures) && targetFeatures.includes("*"))
+    return [...FEATURE_IDS];
+  return targetFeatures.filter((f) => FEATURE_IDS.includes(f));
+}
+function resolveTargets(config) {
+  if (config.targets === "*")
+    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 {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  readdirSync,
+  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.";
+function writeGeneratedFile(filepath, content, options = {}) {
+  const { header = true, type } = options;
+  const ext = type ?? inferFileType(filepath);
+  ensureDir(dirname(filepath));
+  let output = content;
+  if (header) {
+    const headerComment = getHeader(ext);
+    if (headerComment) {
+      output = `${headerComment}
+${content}`;
+    }
+  }
+  writeFileSync(filepath, output, "utf-8");
+}
+function writeGeneratedJson(filepath, data, options = {}) {
+  const json = JSON.stringify(data, null, 2);
+  writeGeneratedFile(filepath, json + `
+`, { ...options, type: "json" });
+}
+function readFileOrNull(filepath) {
+  if (!existsSync2(filepath))
+    return null;
+  return readFileSync2(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync2(targetPath)) {
+    removeSync(targetPath);
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync2(dirPath))
+    return [];
+  const results = [];
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && recursive) {
+      results.push(...listFiles(fullPath, options));
+    } else if (stat.isFile()) {
+      if (!extension || entry.endsWith(extension)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+function listDirs(dirPath) {
+  if (!existsSync2(dirPath))
+    return [];
+  return readdirSync(dirPath).map((entry) => join(dirPath, entry)).filter((fullPath) => statSync(fullPath).isDirectory());
+}
+function relPath(projectRoot, filepath) {
+  return relative(projectRoot, filepath);
+}
+function isGeneratedFile(filepath) {
+  const content = readFileOrNull(filepath);
+  if (!content)
+    return false;
+  return content.startsWith(GENERATED_HEADER_MD) || content.startsWith(GENERATED_HEADER_JSON) || content.startsWith(GENERATED_HEADER_JS);
+}
+function inferFileType(filepath) {
+  if (filepath.endsWith(".json") || filepath.endsWith(".jsonc"))
+    return "json";
+  if (filepath.endsWith(".ts") || filepath.endsWith(".mts"))
+    return "ts";
+  if (filepath.endsWith(".js") || filepath.endsWith(".mjs"))
+    return "js";
+  return "md";
+}
+function getHeader(type) {
+  switch (type) {
+    case "md":
+      return GENERATED_HEADER_MD;
+    case "json":
+      return GENERATED_HEADER_JSON;
+    case "js":
+    case "ts":
+      return GENERATED_HEADER_JS;
+    default:
+      return null;
+  }
+}
+
+// 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";
+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);
+  return {
+    name: data.name ?? basename4(skillDir),
+    sourcePath: filepath,
+    sourceDir: skillDir,
+    packName,
+    meta: data,
+    content
+  };
+}
+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/features/hooks.ts
+import { join as join3 } from "path";
+var TARGET_OVERRIDE_KEYS = ["cursor", "claudecode", "opencode"];
+function parseHooks(packDir, packName) {
+  const hooksPath = join3(packDir, "hooks", "hooks.json");
+  const raw = readJsonOrNull(hooksPath);
+  if (!raw)
+    return null;
+  const shared = raw.hooks ?? {};
+  const targetOverrides = {};
+  for (const key of TARGET_OVERRIDE_KEYS) {
+    const override = raw[key];
+    if (override && typeof override === "object" && "hooks" in override && override.hooks) {
+      targetOverrides[key] = override.hooks;
+    }
+  }
+  return {
+    packName,
+    sourcePath: hooksPath,
+    version: raw.version,
+    shared,
+    targetOverrides
+  };
+}
+function resolveHooksForTarget(hooks, targetId) {
+  const merged = {};
+  for (const [event, entries] of Object.entries(hooks.shared)) {
+    merged[event] = [...entries];
+  }
+  const overrides = hooks.targetOverrides[targetId];
+  if (overrides) {
+    for (const [event, entries] of Object.entries(overrides)) {
+      merged[event] = [...merged[event] ?? [], ...entries];
+    }
+  }
+  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));
+}
+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
+  };
+}
+
+// src/features/mcp.ts
+import { join as join5 } from "path";
+function parseMcp(packDir, packName) {
+  const mcpPath = join5(packDir, "mcp.json");
+  const raw = readJsonOrNull(mcpPath);
+  if (!raw?.mcpServers)
+    return null;
+  return {
+    packName,
+    sourcePath: mcpPath,
+    servers: raw.mcpServers
+  };
+}
+function mergeMcpConfigs(configs) {
+  const servers = {};
+  const warnings = [];
+  for (const config of configs) {
+    for (const [name, entry] of Object.entries(config.servers)) {
+      if (name in servers) {
+        warnings.push(`MCP server "${name}" from pack "${config.packName}" skipped (already defined).`);
+        continue;
+      }
+      servers[name] = entry;
+    }
+  }
+  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;
+}
+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/core/pack-loader.ts
+init_config();
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve3, isAbsolute } from "path";
+class PackLoader {
+  projectRoot;
+  config;
+  constructor(projectRoot, config) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+  }
+  loadAll() {
+    const warnings = [];
+    const packs = [];
+    const disabledSet = new Set(this.config.disabled);
+    for (const packRef of this.config.packs) {
+      const packDir = this.resolvePackPath(packRef);
+      if (!packDir) {
+        warnings.push(`Pack "${packRef}" could not be resolved. Skipping.`);
+        continue;
+      }
+      if (!existsSync6(packDir)) {
+        warnings.push(`Pack directory "${packDir}" does not exist. Skipping.`);
+        continue;
+      }
+      const manifest = loadPackManifest(packDir);
+      if (disabledSet.has(manifest.name) || disabledSet.has(packRef)) {
+        continue;
+      }
+      const loaded = this.loadPack(packDir, manifest);
+      packs.push(loaded);
+    }
+    return { packs, warnings };
+  }
+  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");
+    return {
+      manifest,
+      directory: packDir,
+      rules: existsSync6(rulesDir) ? parseRules(rulesDir, name) : [],
+      commands: existsSync6(commandsDir) ? parseCommands(commandsDir, name) : [],
+      agents: existsSync6(agentsDir) ? parseAgents(agentsDir, name) : [],
+      skills: existsSync6(skillsDir) ? parseSkills(skillsDir, name) : [],
+      hooks: parseHooks(packDir, name),
+      plugins: parsePlugins(packDir, name),
+      mcp: parseMcp(packDir, name),
+      ignore: parseIgnore(packDir, name)
+    };
+  }
+  loadForBaseDir(baseDir) {
+    const baseDirRoot = resolve3(this.projectRoot, baseDir);
+    const localConfigPath = resolve3(baseDirRoot, "agentpacks.jsonc");
+    if (!existsSync6(localConfigPath)) {
+      return { packs: [], warnings: [] };
+    }
+    const { loadWorkspaceConfig: loadWorkspaceConfig2 } = (init_config(), __toCommonJS(exports_config));
+    const localConfig = loadWorkspaceConfig2(baseDirRoot);
+    const loader = new PackLoader(baseDirRoot, localConfig);
+    return loader.loadAll();
+  }
+  resolveCuratedPack(packRef) {
+    const curatedDir = resolve3(this.projectRoot, ".agentpacks", ".curated");
+    let packName = packRef;
+    if (packName.startsWith("npm:"))
+      packName = packName.slice(4);
+    if (packName.startsWith("github:"))
+      packName = packName.slice(7);
+    if (packName.startsWith("@"))
+      packName = packName.slice(1);
+    if (packName.includes("/")) {
+      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);
+    return existsSync6(resolved) ? resolved : null;
+  }
+  resolvePackPath(packRef) {
+    if (packRef.startsWith("./") || packRef.startsWith("../")) {
+      return resolve3(this.projectRoot, packRef);
+    }
+    if (isAbsolute(packRef)) {
+      return 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);
+  }
+}
+export {
+  PackLoader
+};

package/dist/exporters/cursor-plugin.d.ts

@@ -0,0 +1,29 @@
+import type { LoadedPack } from '../core/pack-loader.js';
+/**
+ * Cursor plugin manifest shape.
+ */
+interface CursorPluginManifest {
+    name: string;
+    version: string;
+    description: string;
+    author?: string;
+    tags?: string[];
+    rules?: string[];
+    agents?: string[];
+    skills?: string[];
+    commands?: string[];
+    mcp?: boolean;
+}
+/**
+ * Export result.
+ */
+export interface CursorPluginExportResult {
+    outputDir: string;
+    filesWritten: string[];
+    manifest: CursorPluginManifest;
+}
+/**
+ * Export a loaded pack as a Cursor plugin directory.
+ */
+export declare function exportCursorPlugin(pack: LoadedPack, outputDir: string): CursorPluginExportResult;
+export {};