agentpacks 0.2.0

package/dist/index.js

@@ -0,0 +1,3464 @@
+#!/usr/bin/env node
+// @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);
+  }
+}
+
+// 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()
+    };
+    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;
+  }
+}
+
+// src/core/lockfile.ts
+import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4 } from "path";
+import { createHash } from "crypto";
+var LOCKFILE_VERSION = 1;
+var LOCKFILE_NAME = "agentpacks.lock";
+function loadLockfile(projectRoot) {
+  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  if (!existsSync7(filepath)) {
+    return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
+  }
+  const raw = readFileSync9(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveLockfile(projectRoot, lockfile) {
+  const filepath = resolve4(projectRoot, LOCKFILE_NAME);
+  writeFileSync2(filepath, JSON.stringify(lockfile, null, 2) + `
+`);
+}
+function getLockedSource(lockfile, sourceKey) {
+  return lockfile.sources[sourceKey];
+}
+function setLockedSource(lockfile, sourceKey, entry) {
+  lockfile.sources[sourceKey] = entry;
+}
+function computeIntegrity(content) {
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256-${hash}`;
+}
+function isLockfileFrozenValid(lockfile, sourceKeys) {
+  const missing = sourceKeys.filter((key) => !(key in lockfile.sources));
+  return { valid: missing.length === 0, missing };
+}
+
+// src/sources/local.ts
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
+function resolveLocalPack(packRef, projectRoot) {
+  let resolved;
+  if (isAbsolute2(packRef)) {
+    resolved = packRef;
+  } else {
+    resolved = resolve5(projectRoot, packRef);
+  }
+  if (!existsSync8(resolved))
+    return null;
+  return resolved;
+}
+function isLocalPackRef(packRef) {
+  return packRef.startsWith("./") || packRef.startsWith("../") || isAbsolute2(packRef);
+}
+
+// src/sources/git-ref.ts
+function parseGitSourceRef(source) {
+  let s = source;
+  if (s.startsWith("github:")) {
+    s = s.slice(7);
+  }
+  let path = "";
+  const atIdx = s.indexOf("@");
+  const colonIdx = s.indexOf(":", atIdx > -1 ? atIdx : 0);
+  if (colonIdx > -1) {
+    path = s.slice(colonIdx + 1);
+    s = s.slice(0, colonIdx);
+  }
+  let ref = "main";
+  if (atIdx > -1) {
+    ref = s.slice(atIdx + 1);
+    s = s.slice(0, atIdx);
+  }
+  const parts = s.split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid git source reference: "${source}". Expected owner/repo format.`);
+  }
+  return {
+    owner: parts[0],
+    repo: parts[1],
+    ref,
+    path: path || ""
+  };
+}
+function isGitPackRef(packRef) {
+  if (packRef.startsWith("github:"))
+    return true;
+  if (packRef.startsWith("./") || packRef.startsWith("../") || packRef.startsWith("/")) {
+    return false;
+  }
+  if (packRef.startsWith("@") || packRef.startsWith("npm:"))
+    return false;
+  const parts = packRef.split("/");
+  return parts.length === 2 && !packRef.includes("node_modules");
+}
+function gitSourceKey(parsed) {
+  return `${parsed.owner}/${parsed.repo}`;
+}
+
+// src/sources/npm-ref.ts
+function parseNpmSourceRef(source) {
+  let s = source;
+  if (s.startsWith("npm:")) {
+    s = s.slice(4);
+  }
+  let path = "";
+  const pathColonIdx = findPathColon(s);
+  if (pathColonIdx > -1) {
+    path = s.slice(pathColonIdx + 1);
+    s = s.slice(0, pathColonIdx);
+  }
+  let version = "latest";
+  const versionAtIdx = findVersionAt(s);
+  if (versionAtIdx > -1) {
+    version = s.slice(versionAtIdx + 1);
+    s = s.slice(0, versionAtIdx);
+  }
+  if (!s) {
+    throw new Error(`Invalid npm source reference: "${source}". Expected package name.`);
+  }
+  return { packageName: s, version, path };
+}
+function findPathColon(s) {
+  const startAfter = s.startsWith("@") ? s.indexOf("/") + 1 : 0;
+  const vAt = findVersionAt(s);
+  const searchFrom = vAt > -1 ? vAt : startAfter;
+  return s.indexOf(":", searchFrom);
+}
+function findVersionAt(s) {
+  if (s.startsWith("@")) {
+    const slashIdx = s.indexOf("/");
+    if (slashIdx === -1)
+      return -1;
+    return s.indexOf("@", slashIdx + 1);
+  }
+  return s.indexOf("@");
+}
+function isNpmPackRef(packRef) {
+  if (packRef.startsWith("npm:"))
+    return true;
+  if (packRef.startsWith("@") && packRef.includes("/"))
+    return true;
+  return false;
+}
+function npmSourceKey(parsed) {
+  return `npm:${parsed.packageName}`;
+}
+
+// src/sources/git.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve6, join as join7 } from "path";
+var GITHUB_API = "https://api.github.com";
+function githubHeaders(token) {
+  const h = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "agentpacks"
+  };
+  if (token)
+    h.Authorization = `token ${token}`;
+  return h;
+}
+async function resolveGitRef(parsed, token) {
+  const base = `${GITHUB_API}/repos/${parsed.owner}/${parsed.repo}/git/ref`;
+  const res = await fetch(`${base}/heads/${parsed.ref}`, {
+    headers: githubHeaders(token)
+  });
+  if (!res.ok) {
+    const tagRes = await fetch(`${base}/tags/${parsed.ref}`, {
+      headers: githubHeaders(token)
+    });
+    if (!tagRes.ok) {
+      throw new Error(`Could not resolve ref "${parsed.ref}" for ${parsed.owner}/${parsed.repo}: ${res.status}`);
+    }
+    const tagData = await tagRes.json();
+    return tagData.object.sha;
+  }
+  const data = await res.json();
+  return data.object.sha;
+}
+async function fetchGitDirectory(parsed, sha, subpath, token) {
+  const path = parsed.path ? `${parsed.path}/${subpath}` : subpath;
+  const url = `${GITHUB_API}/repos/${parsed.owner}/${parsed.repo}/contents/${path}?ref=${sha}`;
+  const res = await fetch(url, { headers: githubHeaders(token) });
+  if (!res.ok)
+    return [];
+  return await res.json();
+}
+async function fetchGitFile(downloadUrl, token) {
+  const headers = { "User-Agent": "agentpacks" };
+  if (token)
+    headers.Authorization = `token ${token}`;
+  const res = await fetch(downloadUrl, { headers });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${downloadUrl}: ${res.status}`);
+  }
+  return res.text();
+}
+async function fetchAndWriteSubdir(parsed, sha, remotePath, localDir, installed, token) {
+  mkdirSync2(localDir, { recursive: true });
+  const entries = await fetchGitDirectory(parsed, sha, remotePath, token);
+  for (const entry of entries) {
+    if (entry.type === "file" && entry.download_url) {
+      const content = await fetchGitFile(entry.download_url, token);
+      const filepath = join7(localDir, entry.name);
+      writeFileSync3(filepath, content);
+      installed.push(filepath);
+    } else if (entry.type === "dir") {
+      await fetchAndWriteSubdir(parsed, sha, `${remotePath}/${entry.name}`, join7(localDir, entry.name), installed, token);
+    }
+  }
+}
+async function installGitSource(projectRoot, source, lockfile, options = {}) {
+  const parsed = parseGitSourceRef(source);
+  const sourceKey = gitSourceKey(parsed);
+  const installed = [];
+  const warnings = [];
+  let resolvedSha;
+  const locked = getLockedSource(lockfile, sourceKey);
+  if (options.frozen && !locked) {
+    throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
+  }
+  if (locked && !options.update) {
+    resolvedSha = locked.resolvedRef;
+  } else {
+    resolvedSha = await resolveGitRef(parsed, options.token);
+  }
+  const basePath = parsed.path || "packs";
+  const entries = await fetchGitDirectory(parsed, resolvedSha, basePath, options.token);
+  const curatedDir = resolve6(projectRoot, ".agentpacks", ".curated");
+  mkdirSync2(curatedDir, { recursive: true });
+  const newLockEntry = {
+    requestedRef: parsed.ref,
+    resolvedRef: resolvedSha,
+    resolvedAt: new Date().toISOString(),
+    skills: {},
+    packs: {}
+  };
+  const packDirs = entries.filter((e) => e.type === "dir");
+  for (const packEntry of packDirs) {
+    const packName = packEntry.name;
+    const packOutDir = resolve6(curatedDir, packName);
+    const packFiles = await fetchGitDirectory(parsed, resolvedSha, `${basePath}/${packName}`, options.token);
+    mkdirSync2(packOutDir, { recursive: true });
+    for (const file of packFiles) {
+      if (file.type === "file" && file.download_url) {
+        const content = await fetchGitFile(file.download_url, options.token);
+        writeFileSync3(join7(packOutDir, file.name), content);
+        installed.push(join7(packOutDir, file.name));
+        if (newLockEntry.packs) {
+          newLockEntry.packs[packName] = {
+            integrity: computeIntegrity(content)
+          };
+        }
+      } else if (file.type === "dir") {
+        await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${packName}/${file.name}`, join7(packOutDir, file.name), installed, options.token);
+      }
+    }
+  }
+  if (packDirs.length === 0) {
+    const fileEntries = entries.filter((e) => e.type === "file");
+    if (fileEntries.length > 0) {
+      const packName = parsed.path.split("/").pop() ?? parsed.repo;
+      const packOutDir = resolve6(curatedDir, packName);
+      mkdirSync2(packOutDir, { recursive: true });
+      for (const file of entries) {
+        if (file.type === "file" && file.download_url) {
+          const content = await fetchGitFile(file.download_url, options.token);
+          writeFileSync3(join7(packOutDir, file.name), content);
+          installed.push(join7(packOutDir, file.name));
+        } else if (file.type === "dir") {
+          await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${file.name}`, join7(packOutDir, file.name), installed, options.token);
+        }
+      }
+    }
+  }
+  setLockedSource(lockfile, sourceKey, newLockEntry);
+  return { installed, warnings };
+}
+
+// src/sources/npm.ts
+import { mkdirSync as mkdirSync3, existsSync as existsSync9 } from "fs";
+import { resolve as resolve7, join as join8 } from "path";
+import { execSync } from "child_process";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+async function resolveNpmVersion(parsed) {
+  const url = `${NPM_REGISTRY}/${encodeURIComponent(parsed.packageName)}/${parsed.version}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Could not resolve npm package "${parsed.packageName}@${parsed.version}": ${res.status}`);
+  }
+  const data = await res.json();
+  return { version: data.version, tarball: data.dist.tarball };
+}
+async function installNpmSource(projectRoot, source, lockfile, options = {}) {
+  const parsed = parseNpmSourceRef(source);
+  const sourceKey = npmSourceKey(parsed);
+  const installed = [];
+  const warnings = [];
+  const locked = getLockedSource(lockfile, sourceKey);
+  if (options.frozen && !locked) {
+    throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
+  }
+  let resolvedVersion;
+  let tarballUrl;
+  if (locked && !options.update) {
+    resolvedVersion = locked.resolvedRef;
+    tarballUrl = "";
+  } else {
+    const resolved = await resolveNpmVersion(parsed);
+    resolvedVersion = resolved.version;
+    tarballUrl = resolved.tarball;
+  }
+  const curatedDir = resolve7(projectRoot, ".agentpacks", ".curated");
+  mkdirSync3(curatedDir, { recursive: true });
+  const packDir = extractNpmPack(parsed, resolvedVersion, curatedDir, installed, warnings);
+  const newEntry = {
+    requestedRef: parsed.version,
+    resolvedRef: resolvedVersion,
+    resolvedAt: new Date().toISOString(),
+    skills: {},
+    packs: {}
+  };
+  setLockedSource(lockfile, sourceKey, newEntry);
+  return { installed, warnings };
+}
+function extractNpmPack(parsed, version, curatedDir, installed, warnings) {
+  const pkgSpec = `${parsed.packageName}@${version}`;
+  const packName = parsed.packageName.replace(/^@/, "").replace(/\//g, "-");
+  const packOutDir = resolve7(curatedDir, packName);
+  try {
+    const tmpDir = resolve7(curatedDir, ".tmp-npm");
+    mkdirSync3(tmpDir, { recursive: true });
+    execSync(`npm pack ${pkgSpec} --pack-destination "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000
+    });
+    const tgzFiles = __require("fs").readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+    if (tgzFiles.length === 0) {
+      warnings.push(`No tarball found for ${pkgSpec}`);
+      return packOutDir;
+    }
+    const tgzPath = join8(tmpDir, tgzFiles[0]);
+    mkdirSync3(packOutDir, { recursive: true });
+    execSync(`tar xzf "${tgzPath}" -C "${packOutDir}" --strip-components=1`, {
+      stdio: "pipe",
+      timeout: 15000
+    });
+    execSync(`rm -rf "${tmpDir}"`, { stdio: "pipe" });
+    const subpath = parsed.path || "";
+    const targetDir = subpath ? join8(packOutDir, subpath) : packOutDir;
+    if (existsSync9(targetDir)) {
+      collectFiles(targetDir, installed);
+    }
+  } catch (err) {
+    warnings.push(`Failed to extract npm pack ${pkgSpec}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return packOutDir;
+}
+function collectFiles(dir, out) {
+  const fs = __require("fs");
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join8(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+}
+
+// src/targets/base-target.ts
+class BaseTarget {
+  supportsFeature(feature) {
+    return this.supportedFeatures.includes(feature);
+  }
+  getEffectiveFeatures(enabledFeatures) {
+    return enabledFeatures.filter((f) => this.supportsFeature(f));
+  }
+  createResult(filesWritten = [], filesDeleted = [], warnings = []) {
+    return {
+      targetId: this.id,
+      filesWritten,
+      filesDeleted,
+      warnings
+    };
+  }
+}
+
+// src/utils/markdown.ts
+function stripGeneratedHeader(content) {
+  return content.replace(/^<!-- Generated by agentpacks.*-->\n/, "").replace(/^\/\/ Generated by agentpacks.*\n/, "");
+}
+function packNameToIdentifier(packName) {
+  return packName.split(/[-_.]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function extractFirstHeading(content) {
+  const match = content.match(/^#{1,6}\s+(.+)$/m);
+  return match?.[1]?.trim() ?? null;
+}
+function combineMarkdown(sections, separator = `
+
+---
+
+`) {
+  return sections.filter(Boolean).join(separator);
+}
+function wrapSection(heading, content, level = 2) {
+  const prefix = "#".repeat(level);
+  return `${prefix} ${heading}
+
+${content}`;
+}
+
+// src/targets/opencode.ts
+import { resolve as resolve8, join as join9 } from "path";
+var TARGET_ID = "opencode";
+
+class OpenCodeTarget extends BaseTarget {
+  id = TARGET_ID;
+  name = "OpenCode";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "plugins",
+    "mcp",
+    "ignore"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve8(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const opencodeDir = resolve8(root, ".opencode");
+    if (effective.includes("agents")) {
+      const agentDir = resolve8(opencodeDir, "agent");
+      if (deleteExisting) {
+        removeIfExists(agentDir);
+        filesDeleted.push(agentDir);
+      }
+      ensureDir(agentDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID));
+      for (const agent of agents) {
+        const filepath = join9(agentDir, `${agent.name}.md`);
+        writeGeneratedFile(filepath, agent.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillDir = resolve8(opencodeDir, "skill");
+      if (deleteExisting) {
+        removeIfExists(skillDir);
+        filesDeleted.push(skillDir);
+      }
+      ensureDir(skillDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID));
+      for (const skill of skills) {
+        const skillSubDir = join9(skillDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join9(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, skill.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const cmdDir = resolve8(opencodeDir, "command");
+      if (deleteExisting) {
+        removeIfExists(cmdDir);
+        filesDeleted.push(cmdDir);
+      }
+      ensureDir(cmdDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID));
+      for (const cmd of commands) {
+        const filepath = join9(cmdDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("hooks") || effective.includes("plugins")) {
+      const pluginsDir = resolve8(opencodeDir, "plugins");
+      ensureDir(pluginsDir);
+      if (effective.includes("hooks")) {
+        for (const hookSet of features.hooks) {
+          const events = resolveHooksForTarget(hookSet, TARGET_ID);
+          if (Object.keys(events).length > 0) {
+            const filepath = join9(pluginsDir, `agentpacks-${hookSet.packName}.ts`);
+            const content = generateOpenCodeHookPlugin(hookSet.packName, events);
+            writeGeneratedFile(filepath, content, { type: "ts" });
+            filesWritten.push(filepath);
+          }
+        }
+      }
+      if (effective.includes("plugins")) {
+        for (const plugin of features.plugins) {
+          const filepath = join9(pluginsDir, `agentpacks-${plugin.packName}-${plugin.name}.${plugin.extension}`);
+          writeGeneratedFile(filepath, plugin.content, {
+            type: plugin.extension
+          });
+          filesWritten.push(filepath);
+        }
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const opencodeConfig = buildOpenCodeMcp(features.mcpServers);
+        const filepath = resolve8(root, "opencode.json");
+        writeGeneratedJson(filepath, opencodeConfig, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("rules")) {
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID));
+      const rootRules = getRootRules(rules);
+      const detailRules = getDetailRules(rules);
+      if (detailRules.length > 0) {
+        const memoriesDir = resolve8(opencodeDir, "memories");
+        if (deleteExisting) {
+          removeIfExists(memoriesDir);
+          filesDeleted.push(memoriesDir);
+        }
+        ensureDir(memoriesDir);
+        for (const rule of detailRules) {
+          const filepath = join9(memoriesDir, `${rule.name}.md`);
+          writeGeneratedFile(filepath, rule.content);
+          filesWritten.push(filepath);
+        }
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildOpenCodeMcp(servers) {
+  const mcp = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.url) {
+      mcp[name] = {
+        type: "remote",
+        url: entry.url,
+        enabled: true,
+        ...entry.headers && Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}
+      };
+    } else if (entry.command) {
+      const cmd = entry.args ? [entry.command, ...entry.args] : [entry.command];
+      mcp[name] = {
+        type: "local",
+        command: cmd,
+        enabled: true,
+        ...entry.env && Object.keys(entry.env).length > 0 ? { environment: entry.env } : {}
+      };
+    }
+  }
+  return {
+    $schema: "https://opencode.ai/config.json",
+    mcp
+  };
+}
+function generateOpenCodeHookPlugin(packName, events) {
+  const identifier = packNameToIdentifier(packName);
+  const hookMap = mapHookEvents(events);
+  const hookEntries = Object.entries(hookMap).map(([event, handlers]) => {
+    const body = handlers.map((h) => {
+      const matcherGuard = h.matcher ? `if (!/(?:${h.matcher})/.test(String(input?.tool ?? ""))) return;
+      ` : "";
+      return `      ${matcherGuard}await $\`${h.command}\`;`;
+    }).join(`
+`);
+    return `    "${event}": async (input, output) => {
+${body}
+    },`;
+  }).join(`
+`);
+  return `import type { Plugin } from "@opencode-ai/plugin";
+
+export const ${identifier}Plugin: Plugin = async ({ project, client, $, directory, worktree }) => {
+  return {
+${hookEntries}
+  };
+};
+`;
+}
+function mapHookEvents(events) {
+  const mapped = {};
+  const eventMapping = {
+    sessionStart: "session.created",
+    postToolUse: "tool.execute.after",
+    preToolUse: "tool.execute.before",
+    stop: "session.idle",
+    afterFileEdit: "file.edited",
+    afterShellExecution: "command.executed"
+  };
+  for (const [event, handlers] of Object.entries(events)) {
+    const opencodeEvent = eventMapping[event] ?? event;
+    if (!mapped[opencodeEvent]) {
+      mapped[opencodeEvent] = [];
+    }
+    mapped[opencodeEvent].push(...handlers.filter((h) => h.command));
+  }
+  return mapped;
+}
+
+// src/targets/cursor.ts
+import { resolve as resolve9, join as join10 } from "path";
+var TARGET_ID2 = "cursor";
+
+class CursorTarget extends BaseTarget {
+  id = TARGET_ID2;
+  name = "Cursor";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "mcp",
+    "ignore"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve9(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const cursorDir = resolve9(root, ".cursor");
+    if (effective.includes("rules")) {
+      const rulesDir = resolve9(cursorDir, "rules");
+      if (deleteExisting) {
+        removeIfExists(rulesDir);
+        filesDeleted.push(rulesDir);
+      }
+      ensureDir(rulesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID2));
+      for (const rule of rules) {
+        const cursorMeta = rule.meta.cursor ?? {};
+        const frontmatter = {
+          description: cursorMeta.description ?? rule.meta.description ?? "",
+          alwaysApply: cursorMeta.alwaysApply ?? rule.meta.root ?? false
+        };
+        const globs = cursorMeta.globs ?? rule.meta.globs;
+        if (globs) {
+          frontmatter.globs = globs;
+        }
+        const filepath = join10(rulesDir, `${rule.name}.mdc`);
+        const content = serializeFrontmatter(frontmatter, rule.content);
+        writeGeneratedFile(filepath, content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("agents")) {
+      const agentsDir = resolve9(cursorDir, "agents");
+      if (deleteExisting) {
+        removeIfExists(agentsDir);
+        filesDeleted.push(agentsDir);
+      }
+      ensureDir(agentsDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID2));
+      for (const agent of agents) {
+        const frontmatter = {
+          name: agent.name,
+          description: agent.meta.description ?? ""
+        };
+        const filepath = join10(agentsDir, `${agent.name}.md`);
+        const content = serializeFrontmatter(frontmatter, agent.content);
+        writeGeneratedFile(filepath, content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillsDir = resolve9(cursorDir, "skills");
+      if (deleteExisting) {
+        removeIfExists(skillsDir);
+        filesDeleted.push(skillsDir);
+      }
+      ensureDir(skillsDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID2));
+      for (const skill of skills) {
+        const skillSubDir = join10(skillsDir, skill.name);
+        ensureDir(skillSubDir);
+        const frontmatter = {
+          name: skill.name,
+          description: skill.meta.description ?? ""
+        };
+        const filepath = join10(skillSubDir, "SKILL.md");
+        const content = serializeFrontmatter(frontmatter, skill.content);
+        writeGeneratedFile(filepath, content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve9(cursorDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID2));
+      for (const cmd of commands) {
+        const filepath = join10(commandsDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const mcpConfig = buildCursorMcp(features.mcpServers);
+        const filepath = resolve9(cursorDir, "mcp.json");
+        writeGeneratedJson(filepath, mcpConfig, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("ignore")) {
+      if (features.ignorePatterns.length > 0) {
+        const filepath = resolve9(root, ".cursorignore");
+        const content = features.ignorePatterns.join(`
+`) + `
+`;
+        writeGeneratedFile(filepath, content);
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildCursorMcp(servers) {
+  const mcpServers = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.url) {
+      mcpServers[name] = { url: entry.url };
+    } else if (entry.command) {
+      mcpServers[name] = {
+        command: entry.command,
+        ...entry.args ? { args: entry.args } : {},
+        ...entry.env ? { env: entry.env } : {}
+      };
+    }
+  }
+  return { mcpServers };
+}
+
+// src/targets/claude-code.ts
+import { resolve as resolve10, join as join11 } from "path";
+var TARGET_ID3 = "claudecode";
+
+class ClaudeCodeTarget extends BaseTarget {
+  id = TARGET_ID3;
+  name = "Claude Code";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "mcp",
+    "ignore"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve10(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const claudeDir = resolve10(root, ".claude");
+    if (effective.includes("rules")) {
+      const rulesDir = resolve10(claudeDir, "rules");
+      if (deleteExisting) {
+        removeIfExists(rulesDir);
+        filesDeleted.push(rulesDir);
+      }
+      ensureDir(rulesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID3));
+      const rootRules = getRootRules(rules);
+      const detailRules = getDetailRules(rules);
+      if (rootRules.length > 0) {
+        const claudeMd = rootRules.map((r) => r.content).join(`
+
+`);
+        const filepath = resolve10(claudeDir, "CLAUDE.md");
+        writeGeneratedFile(filepath, claudeMd);
+        filesWritten.push(filepath);
+      }
+      for (const rule of detailRules) {
+        const filepath = join11(rulesDir, `${rule.name}.md`);
+        writeGeneratedFile(filepath, rule.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("agents")) {
+      const agentsDir = resolve10(claudeDir, "agents");
+      if (deleteExisting) {
+        removeIfExists(agentsDir);
+        filesDeleted.push(agentsDir);
+      }
+      ensureDir(agentsDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID3));
+      for (const agent of agents) {
+        const filepath = join11(agentsDir, `${agent.name}.md`);
+        writeGeneratedFile(filepath, agent.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillsDir = resolve10(claudeDir, "skills");
+      if (deleteExisting) {
+        removeIfExists(skillsDir);
+        filesDeleted.push(skillsDir);
+      }
+      ensureDir(skillsDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID3));
+      for (const skill of skills) {
+        const skillSubDir = join11(skillsDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join11(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, skill.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve10(claudeDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID3));
+      for (const cmd of commands) {
+        const filepath = join11(commandsDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("hooks") || effective.includes("mcp") || effective.includes("ignore")) {
+      const settings = buildClaudeSettings(options, effective);
+      if (Object.keys(settings).length > 0) {
+        const filepath = resolve10(claudeDir, "settings.json");
+        const existing = readJsonOrNull(filepath) ?? {};
+        const merged = { ...existing, ...settings };
+        writeGeneratedJson(filepath, merged, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildClaudeSettings(options, effective) {
+  const settings = {};
+  if (effective.includes("hooks")) {
+    const allHookEntries = {};
+    for (const hookSet of options.features.hooks) {
+      const events = resolveHooksForTarget(hookSet, TARGET_ID3);
+      for (const [event, entries] of Object.entries(events)) {
+        const pascalEvent = toPascalCase(event);
+        if (!allHookEntries[pascalEvent]) {
+          allHookEntries[pascalEvent] = [];
+        }
+        allHookEntries[pascalEvent].push(...entries.map((e) => ({
+          type: e.type ?? "command",
+          ...e.matcher ? { matcher: e.matcher } : {},
+          command: e.command
+        })));
+      }
+    }
+    if (Object.keys(allHookEntries).length > 0) {
+      settings.hooks = allHookEntries;
+    }
+  }
+  if (effective.includes("mcp")) {
+    const mcpEntries = Object.entries(options.features.mcpServers);
+    if (mcpEntries.length > 0) {
+      const mcpServers = {};
+      for (const [name, entry] of mcpEntries) {
+        if (entry.url) {
+          mcpServers[name] = { url: entry.url };
+        } else if (entry.command) {
+          mcpServers[name] = {
+            command: entry.command,
+            ...entry.args ? { args: entry.args } : {},
+            ...entry.env ? { env: entry.env } : {}
+          };
+        }
+      }
+      settings.mcpServers = mcpServers;
+    }
+  }
+  return settings;
+}
+function toPascalCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/targets/codex-cli.ts
+import { resolve as resolve11, join as join12 } from "path";
+var TARGET_ID4 = "codexcli";
+
+class CodexCliTarget extends BaseTarget {
+  id = TARGET_ID4;
+  name = "Codex CLI";
+  supportedFeatures = ["rules", "skills", "mcp", "hooks"];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve11(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const codexDir = resolve11(root, ".codex");
+    if (effective.includes("rules")) {
+      const memoriesDir = resolve11(codexDir, "memories");
+      if (deleteExisting) {
+        removeIfExists(memoriesDir);
+        filesDeleted.push(memoriesDir);
+      }
+      ensureDir(memoriesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID4));
+      for (const rule of rules) {
+        const filepath = join12(memoriesDir, `${rule.name}.md`);
+        writeGeneratedFile(filepath, rule.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const skillsDir = resolve11(codexDir, "skills");
+      if (deleteExisting) {
+        removeIfExists(skillsDir);
+        filesDeleted.push(skillsDir);
+      }
+      ensureDir(skillsDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID4));
+      for (const skill of skills) {
+        const skillSubDir = join12(skillsDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join12(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, skill.content);
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+
+// src/targets/gemini-cli.ts
+import { resolve as resolve12, join as join13 } from "path";
+var TARGET_ID5 = "geminicli";
+
+class GeminiCliTarget extends BaseTarget {
+  id = TARGET_ID5;
+  name = "Gemini CLI";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "mcp",
+    "ignore",
+    "skills",
+    "hooks"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve12(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const geminiDir = resolve12(root, ".gemini");
+    if (effective.includes("rules")) {
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID5));
+      const rootRules = getRootRules(rules);
+      const detailRules = getDetailRules(rules);
+      if (rootRules.length > 0) {
+        const geminiMd = rootRules.map((r) => r.content).join(`
+
+`);
+        const filepath = resolve12(root, "GEMINI.md");
+        writeGeneratedFile(filepath, geminiMd);
+        filesWritten.push(filepath);
+      }
+      if (detailRules.length > 0) {
+        const memoriesDir = resolve12(geminiDir, "memories");
+        if (deleteExisting) {
+          removeIfExists(memoriesDir);
+          filesDeleted.push(memoriesDir);
+        }
+        ensureDir(memoriesDir);
+        for (const rule of detailRules) {
+          const filepath = join13(memoriesDir, `${rule.name}.md`);
+          writeGeneratedFile(filepath, rule.content);
+          filesWritten.push(filepath);
+        }
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve12(geminiDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID5));
+      for (const cmd of commands) {
+        const toml = buildGeminiCommand(cmd.name, cmd.meta.description ?? "", cmd.content);
+        const filepath = join13(commandsDir, `${cmd.name}.toml`);
+        writeGeneratedFile(filepath, toml, { type: "md" });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const settings = buildGeminiSettings(features.mcpServers);
+        const filepath = resolve12(geminiDir, "settings.json");
+        writeGeneratedJson(filepath, settings, { header: false });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("ignore")) {
+      if (features.ignorePatterns.length > 0) {
+        const filepath = resolve12(root, ".geminiignore");
+        const content = features.ignorePatterns.join(`
+`) + `
+`;
+        writeGeneratedFile(filepath, content);
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+function buildGeminiCommand(name, description, content) {
+  return `[command]
+name = "${name}"
+description = "${description}"
+
+[prompt]
+content = """
+${content}
+"""
+`;
+}
+function buildGeminiSettings(servers) {
+  const mcpServers = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (entry.command) {
+      mcpServers[name] = {
+        command: entry.command,
+        ...entry.args ? { args: entry.args } : {},
+        ...entry.env ? { env: entry.env } : {}
+      };
+    } else if (entry.url) {
+      mcpServers[name] = { url: entry.url };
+    }
+  }
+  return { mcpServers };
+}
+
+// src/targets/copilot.ts
+import { resolve as resolve13, join as join14 } from "path";
+var TARGET_ID6 = "copilot";
+
+class CopilotTarget extends BaseTarget {
+  id = TARGET_ID6;
+  name = "GitHub Copilot";
+  supportedFeatures = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "mcp",
+    "ignore"
+  ];
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve13(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const githubDir = resolve13(root, ".github");
+    if (effective.includes("rules")) {
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, TARGET_ID6));
+      if (rules.length > 0) {
+        const combinedContent = rules.map((r) => r.content).join(`
+
+---
+
+`);
+        const filepath = resolve13(githubDir, "copilot-instructions.md");
+        ensureDir(githubDir);
+        writeGeneratedFile(filepath, combinedContent);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("agents")) {
+      const copilotDir = resolve13(githubDir, "copilot");
+      const agentsDir = resolve13(copilotDir, "agents");
+      if (deleteExisting) {
+        removeIfExists(agentsDir);
+        filesDeleted.push(agentsDir);
+      }
+      ensureDir(agentsDir);
+      const agents = features.agents.filter((a) => agentMatchesTarget(a, TARGET_ID6));
+      for (const agent of agents) {
+        const filepath = join14(agentsDir, `${agent.name}.md`);
+        writeGeneratedFile(filepath, agent.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("skills")) {
+      const copilotDir = resolve13(githubDir, "copilot");
+      const skillsDir = resolve13(copilotDir, "skills");
+      if (deleteExisting) {
+        removeIfExists(skillsDir);
+        filesDeleted.push(skillsDir);
+      }
+      ensureDir(skillsDir);
+      const skills = features.skills.filter((s) => skillMatchesTarget(s, TARGET_ID6));
+      for (const skill of skills) {
+        const skillSubDir = join14(skillsDir, skill.name);
+        ensureDir(skillSubDir);
+        const filepath = join14(skillSubDir, "SKILL.md");
+        writeGeneratedFile(filepath, skill.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const copilotDir = resolve13(githubDir, "copilot");
+      const commandsDir = resolve13(copilotDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, TARGET_ID6));
+      for (const cmd of commands) {
+        const filepath = join14(commandsDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("ignore")) {}
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+
+// src/targets/agents-md.ts
+import { resolve as resolve14 } from "path";
+class AgentsMdTarget extends BaseTarget {
+  id = "agentsmd";
+  name = "AGENTS.md";
+  supportedFeatures = ["rules"];
+  generate(options) {
+    const { projectRoot, baseDir, features } = options;
+    const root = resolve14(projectRoot, baseDir);
+    const filesWritten = [];
+    const warnings = [];
+    const rootRules = getRootRules(features.rules);
+    if (rootRules.length === 0) {
+      warnings.push("No root rules found. AGENTS.md will not be generated.");
+      return this.createResult(filesWritten, [], warnings);
+    }
+    const sections = rootRules.map((r) => r.content);
+    const content = sections.join(`
+
+`);
+    const filepath = resolve14(root, "AGENTS.md");
+    writeGeneratedFile(filepath, content);
+    filesWritten.push(filepath);
+    return this.createResult(filesWritten, [], warnings);
+  }
+}
+
+// src/targets/generic-md-target.ts
+import { resolve as resolve15, join as join15 } from "path";
+function createGenericMdTarget(config) {
+  return new GenericMdTarget(config);
+}
+
+class GenericMdTarget extends BaseTarget {
+  id;
+  name;
+  supportedFeatures;
+  config;
+  constructor(config) {
+    super();
+    this.id = config.id;
+    this.name = config.name;
+    this.supportedFeatures = config.supportedFeatures;
+    this.config = config;
+  }
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve15(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const configDir = resolve15(root, this.config.configDir);
+    const rulesSubDir = this.config.rulesDir ?? "rules";
+    const ext = this.config.ruleExtension ?? ".md";
+    if (effective.includes("rules")) {
+      const rulesDir = resolve15(configDir, rulesSubDir);
+      if (deleteExisting) {
+        removeIfExists(rulesDir);
+        filesDeleted.push(rulesDir);
+      }
+      ensureDir(rulesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, this.id));
+      for (const rule of rules) {
+        const filepath = join15(rulesDir, `${rule.name}${ext}`);
+        writeGeneratedFile(filepath, rule.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve15(configDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, this.id));
+      for (const cmd of commands) {
+        const filepath = join15(commandsDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const mcpDir = this.config.mcpInConfigDir ? configDir : root;
+        const filepath = resolve15(mcpDir, "mcp.json");
+        writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
+          header: false
+        });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("ignore") && this.config.ignoreFile) {
+      if (features.ignorePatterns.length > 0) {
+        const filepath = resolve15(root, this.config.ignoreFile);
+        writeGeneratedFile(filepath, features.ignorePatterns.join(`
+`) + `
+`);
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+
+// src/targets/additional-targets.ts
+var ClineTarget = createGenericMdTarget({
+  id: "cline",
+  name: "Cline",
+  configDir: ".cline",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".clineignore",
+  mcpInConfigDir: true
+});
+var KiloTarget = createGenericMdTarget({
+  id: "kilo",
+  name: "Kilo Code",
+  configDir: ".kilo",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".kiloignore",
+  mcpInConfigDir: true
+});
+var RooTarget = createGenericMdTarget({
+  id: "roo",
+  name: "Roo Code",
+  configDir: ".roo",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".rooignore",
+  mcpInConfigDir: true
+});
+var QwenCodeTarget = createGenericMdTarget({
+  id: "qwencode",
+  name: "Qwen Code",
+  configDir: ".qwencode",
+  supportedFeatures: ["rules", "mcp", "ignore"],
+  ignoreFile: ".qwencodeignore",
+  mcpInConfigDir: true
+});
+var KiroTarget = createGenericMdTarget({
+  id: "kiro",
+  name: "Kiro",
+  configDir: ".kiro",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var FactoryDroidTarget = createGenericMdTarget({
+  id: "factorydroid",
+  name: "Factory Droid",
+  configDir: ".factorydroid",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var AntiGravityTarget = createGenericMdTarget({
+  id: "antigravity",
+  name: "AntiGravity",
+  configDir: ".antigravity",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var JunieTarget = createGenericMdTarget({
+  id: "junie",
+  name: "Junie",
+  configDir: ".junie",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var AugmentCodeTarget = createGenericMdTarget({
+  id: "augmentcode",
+  name: "Augment Code",
+  configDir: ".augmentcode",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var WindsurfTarget = createGenericMdTarget({
+  id: "windsurf",
+  name: "Windsurf",
+  configDir: ".windsurf",
+  supportedFeatures: ["rules", "mcp", "ignore"],
+  ignoreFile: ".windsurfignore",
+  mcpInConfigDir: true
+});
+var WarpTarget = createGenericMdTarget({
+  id: "warp",
+  name: "Warp",
+  configDir: ".warp",
+  supportedFeatures: ["rules"]
+});
+var ReplitTarget = createGenericMdTarget({
+  id: "replit",
+  name: "Replit Agent",
+  configDir: ".replit",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var ZedTarget = createGenericMdTarget({
+  id: "zed",
+  name: "Zed",
+  configDir: ".zed",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+
+// src/targets/registry.ts
+var TARGETS = [
+  new OpenCodeTarget,
+  new CursorTarget,
+  new ClaudeCodeTarget,
+  new CodexCliTarget,
+  new GeminiCliTarget,
+  new CopilotTarget,
+  new AgentsMdTarget,
+  ClineTarget,
+  KiloTarget,
+  RooTarget,
+  QwenCodeTarget,
+  KiroTarget,
+  FactoryDroidTarget,
+  AntiGravityTarget,
+  JunieTarget,
+  AugmentCodeTarget,
+  WindsurfTarget,
+  WarpTarget,
+  ReplitTarget,
+  ZedTarget
+];
+var targetMap = new Map(TARGETS.map((t) => [t.id, t]));
+function getTarget(id) {
+  return targetMap.get(id);
+}
+function getAllTargets() {
+  return [...TARGETS];
+}
+function getTargets(ids) {
+  return ids.map((id) => targetMap.get(id)).filter((t) => t !== undefined);
+}
+function listTargetIds() {
+  return TARGETS.map((t) => t.id);
+}
+
+// src/exporters/cursor-plugin.ts
+import { resolve as resolve16, join as join16 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
+function exportCursorPlugin(pack, outputDir) {
+  const filesWritten = [];
+  const pluginDir = resolve16(outputDir, pack.manifest.name);
+  mkdirSync4(pluginDir, { recursive: true });
+  const manifest = {
+    name: pack.manifest.name,
+    version: pack.manifest.version,
+    description: pack.manifest.description
+  };
+  if (pack.manifest.author) {
+    manifest.author = typeof pack.manifest.author === "string" ? pack.manifest.author : pack.manifest.author.name;
+  }
+  if (pack.manifest.tags.length > 0) {
+    manifest.tags = pack.manifest.tags;
+  }
+  if (pack.rules.length > 0) {
+    const rulesDir = join16(pluginDir, "rules");
+    ensureDir(rulesDir);
+    manifest.rules = [];
+    for (const rule of pack.rules) {
+      const cursorMeta = rule.meta.cursor ?? {};
+      const fm = {
+        description: cursorMeta.description ?? rule.meta.description ?? "",
+        alwaysApply: cursorMeta.alwaysApply ?? rule.meta.root ?? false
+      };
+      const globs = cursorMeta.globs ?? rule.meta.globs;
+      if (globs)
+        fm.globs = globs;
+      const filename = `${rule.name}.mdc`;
+      const filepath = join16(rulesDir, filename);
+      writeFileSync5(filepath, serializeFrontmatter(fm, rule.content));
+      filesWritten.push(filepath);
+      manifest.rules.push(filename);
+    }
+  }
+  if (pack.agents.length > 0) {
+    const agentsDir = join16(pluginDir, "agents");
+    ensureDir(agentsDir);
+    manifest.agents = [];
+    for (const agent of pack.agents) {
+      const fm = {
+        name: agent.name,
+        description: agent.meta.description ?? ""
+      };
+      const filename = `${agent.name}.md`;
+      const filepath = join16(agentsDir, filename);
+      writeFileSync5(filepath, serializeFrontmatter(fm, agent.content));
+      filesWritten.push(filepath);
+      manifest.agents.push(filename);
+    }
+  }
+  if (pack.skills.length > 0) {
+    const skillsDir = join16(pluginDir, "skills");
+    ensureDir(skillsDir);
+    manifest.skills = [];
+    for (const skill of pack.skills) {
+      const skillSubDir = join16(skillsDir, skill.name);
+      ensureDir(skillSubDir);
+      const fm = {
+        name: skill.name,
+        description: skill.meta.description ?? ""
+      };
+      const filepath = join16(skillSubDir, "SKILL.md");
+      writeFileSync5(filepath, serializeFrontmatter(fm, skill.content));
+      filesWritten.push(filepath);
+      manifest.skills.push(skill.name);
+    }
+  }
+  if (pack.commands.length > 0) {
+    const commandsDir = join16(pluginDir, "commands");
+    ensureDir(commandsDir);
+    manifest.commands = [];
+    for (const cmd of pack.commands) {
+      const filename = `${cmd.name}.md`;
+      const filepath = join16(commandsDir, filename);
+      writeFileSync5(filepath, cmd.content);
+      filesWritten.push(filepath);
+      manifest.commands.push(filename);
+    }
+  }
+  if (pack.mcp && Object.keys(pack.mcp.servers).length > 0) {
+    manifest.mcp = true;
+    const filepath = join16(pluginDir, "mcp.json");
+    writeFileSync5(filepath, JSON.stringify({ mcpServers: pack.mcp.servers }, null, 2) + `
+`);
+    filesWritten.push(filepath);
+  }
+  const manifestPath = join16(pluginDir, "manifest.json");
+  writeFileSync5(manifestPath, JSON.stringify(manifest, null, 2) + `
+`);
+  filesWritten.push(manifestPath);
+  return { outputDir: pluginDir, filesWritten, manifest };
+}
+
+// src/importers/rulesync.ts
+import { existsSync as existsSync10, readFileSync as readFileSync10, copyFileSync, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve17, join as join17, basename as basename6 } from "path";
+import { parse as parseJsonc2 } from "jsonc-parser";
+function importFromRulesync(projectRoot, outputPackDir) {
+  const rulesyncDir = resolve17(projectRoot, ".rulesync");
+  const warnings = [];
+  const filesImported = [];
+  if (!existsSync10(rulesyncDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .rulesync/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve17(projectRoot, "packs", "default");
+  ensureDir(packDir);
+  const rulesDir = resolve17(rulesyncDir, "rules");
+  if (existsSync10(rulesDir)) {
+    const outRulesDir = resolve17(packDir, "rules");
+    ensureDir(outRulesDir);
+    const files = listFiles(rulesDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join17(outRulesDir, basename6(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const commandsDir = resolve17(rulesyncDir, "commands");
+  if (existsSync10(commandsDir)) {
+    const outCommandsDir = resolve17(packDir, "commands");
+    ensureDir(outCommandsDir);
+    const files = listFiles(commandsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join17(outCommandsDir, basename6(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const subagentsDir = resolve17(rulesyncDir, "subagents");
+  if (existsSync10(subagentsDir)) {
+    const outAgentsDir = resolve17(packDir, "agents");
+    ensureDir(outAgentsDir);
+    const files = listFiles(subagentsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join17(outAgentsDir, basename6(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const skillsDir = resolve17(rulesyncDir, "skills");
+  if (existsSync10(skillsDir)) {
+    const outSkillsDir = resolve17(packDir, "skills");
+    ensureDir(outSkillsDir);
+    const skillDirs = listDirs(skillsDir);
+    for (const skillDir of skillDirs) {
+      const skillName = basename6(skillDir);
+      if (skillName.startsWith("."))
+        continue;
+      const skillMd = join17(skillDir, "SKILL.md");
+      if (existsSync10(skillMd)) {
+        const outSkillDir = join17(outSkillsDir, skillName);
+        ensureDir(outSkillDir);
+        copyFileSync(skillMd, join17(outSkillDir, "SKILL.md"));
+        filesImported.push(join17(outSkillDir, "SKILL.md"));
+      }
+    }
+  }
+  const hooksJson = resolve17(rulesyncDir, "hooks.json");
+  if (existsSync10(hooksJson)) {
+    const outHooksDir = resolve17(packDir, "hooks");
+    ensureDir(outHooksDir);
+    copyFileSync(hooksJson, join17(outHooksDir, "hooks.json"));
+    filesImported.push(join17(outHooksDir, "hooks.json"));
+  }
+  const mcpJson = resolve17(rulesyncDir, "mcp.json");
+  if (existsSync10(mcpJson)) {
+    copyFileSync(mcpJson, join17(packDir, "mcp.json"));
+    filesImported.push(join17(packDir, "mcp.json"));
+  }
+  const aiIgnore = resolve17(rulesyncDir, ".aiignore");
+  const rulesyncIgnore = resolve17(projectRoot, ".rulesyncignore");
+  if (existsSync10(aiIgnore)) {
+    copyFileSync(aiIgnore, join17(packDir, "ignore"));
+    filesImported.push(join17(packDir, "ignore"));
+  } else if (existsSync10(rulesyncIgnore)) {
+    copyFileSync(rulesyncIgnore, join17(packDir, "ignore"));
+    filesImported.push(join17(packDir, "ignore"));
+  }
+  const packJson = {
+    name: "default",
+    version: "1.0.0",
+    description: "Imported from rulesync",
+    tags: ["imported", "rulesync"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  writeFileSync6(join17(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(join17(packDir, "pack.json"));
+  let configGenerated = false;
+  const rulesyncConfig = resolve17(projectRoot, "rulesync.jsonc");
+  if (existsSync10(rulesyncConfig)) {
+    const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir, projectRoot);
+    const configPath = resolve17(projectRoot, "agentpacks.jsonc");
+    writeFileSync6(configPath, agentpacksConfig);
+    configGenerated = true;
+  }
+  return { packDir, filesImported, warnings, configGenerated };
+}
+function convertRulesyncConfig(rulesyncPath, packDir, projectRoot) {
+  const raw = readFileSync10(rulesyncPath, "utf-8");
+  const parsed = parseJsonc2(raw);
+  const targets = parsed.targets ?? ["opencode", "cursor", "claudecode"];
+  const features = parsed.features ?? ["*"];
+  const baseDirs = parsed.baseDirs ?? ["."];
+  const global = parsed.global ?? false;
+  const deleteVal = parsed.delete ?? true;
+  const relPackDir = "./" + join17("packs", "default");
+  const config = {
+    $schema: "https://unpkg.com/agentpacks/schema.json",
+    packs: [relPackDir],
+    disabled: [],
+    targets,
+    features,
+    mode: baseDirs.length > 1 ? "monorepo" : "repo",
+    baseDirs,
+    global,
+    delete: deleteVal
+  };
+  return JSON.stringify(config, null, 2) + `
+`;
+}
+
+// src/importers/cursor.ts
+import { existsSync as existsSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync7, copyFileSync as copyFileSync2 } from "fs";
+import { resolve as resolve18, join as join18, basename as basename7 } from "path";
+function importFromCursor(projectRoot, outputPackDir) {
+  const cursorDir = resolve18(projectRoot, ".cursor");
+  const warnings = [];
+  const filesImported = [];
+  if (!existsSync11(cursorDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .cursor/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve18(projectRoot, "packs", "cursor-import");
+  ensureDir(packDir);
+  const rulesDir = resolve18(cursorDir, "rules");
+  if (existsSync11(rulesDir)) {
+    const outRulesDir = resolve18(packDir, "rules");
+    ensureDir(outRulesDir);
+    const files = listFiles(rulesDir, { extension: ".mdc" });
+    for (const file of files) {
+      const raw = readFileSync11(file, "utf-8");
+      const { data, content } = parseFrontmatter(raw);
+      const meta = {};
+      if (data.description)
+        meta.description = data.description;
+      if (data.alwaysApply)
+        meta.root = true;
+      if (data.globs)
+        meta.globs = data.globs;
+      meta.cursor = { ...data };
+      const mdContent = buildAgentpacksRule(meta, content);
+      const name = basename7(file, ".mdc");
+      const dest = join18(outRulesDir, `${name}.md`);
+      writeFileSync7(dest, mdContent);
+      filesImported.push(dest);
+    }
+    const mdFiles = listFiles(rulesDir, { extension: ".md" });
+    for (const file of mdFiles) {
+      const dest = join18(outRulesDir, basename7(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const agentsDir = resolve18(cursorDir, "agents");
+  if (existsSync11(agentsDir)) {
+    const outDir = resolve18(packDir, "agents");
+    ensureDir(outDir);
+    const files = listFiles(agentsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join18(outDir, basename7(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const skillsDir = resolve18(cursorDir, "skills");
+  if (existsSync11(skillsDir)) {
+    const outDir = resolve18(packDir, "skills");
+    ensureDir(outDir);
+    const dirs = listDirs(skillsDir);
+    for (const dir of dirs) {
+      const name = basename7(dir);
+      const skillMd = join18(dir, "SKILL.md");
+      if (existsSync11(skillMd)) {
+        const outSkillDir = join18(outDir, name);
+        ensureDir(outSkillDir);
+        copyFileSync2(skillMd, join18(outSkillDir, "SKILL.md"));
+        filesImported.push(join18(outSkillDir, "SKILL.md"));
+      }
+    }
+  }
+  const commandsDir = resolve18(cursorDir, "commands");
+  if (existsSync11(commandsDir)) {
+    const outDir = resolve18(packDir, "commands");
+    ensureDir(outDir);
+    const files = listFiles(commandsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join18(outDir, basename7(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const mcpJson = resolve18(cursorDir, "mcp.json");
+  if (existsSync11(mcpJson)) {
+    copyFileSync2(mcpJson, join18(packDir, "mcp.json"));
+    filesImported.push(join18(packDir, "mcp.json"));
+  }
+  const cursorIgnore = resolve18(projectRoot, ".cursorignore");
+  if (existsSync11(cursorIgnore)) {
+    copyFileSync2(cursorIgnore, join18(packDir, "ignore"));
+    filesImported.push(join18(packDir, "ignore"));
+  }
+  writePackJson(packDir, "cursor-import", filesImported);
+  return { packDir, filesImported, warnings, configGenerated: false };
+}
+function buildAgentpacksRule(meta, content) {
+  const lines = ["---"];
+  for (const [k, v] of Object.entries(meta)) {
+    if (typeof v === "object") {
+      lines.push(`${k}: ${JSON.stringify(v)}`);
+    } else {
+      lines.push(`${k}: ${v}`);
+    }
+  }
+  lines.push("---", "", content);
+  return lines.join(`
+`);
+}
+function writePackJson(packDir, name, filesImported) {
+  const packJson = {
+    name,
+    version: "1.0.0",
+    description: `Imported from Cursor`,
+    tags: ["imported", "cursor"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  const dest = join18(packDir, "pack.json");
+  writeFileSync7(dest, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(dest);
+}
+
+// src/importers/claude-code.ts
+import { existsSync as existsSync12, readFileSync as readFileSync12, writeFileSync as writeFileSync8, copyFileSync as copyFileSync3 } from "fs";
+import { resolve as resolve19, join as join19, basename as basename8 } from "path";
+function importFromClaudeCode(projectRoot, outputPackDir) {
+  const warnings = [];
+  const filesImported = [];
+  const claudeDir = resolve19(projectRoot, ".claude");
+  const hasClaudeMd = existsSync12(resolve19(projectRoot, "CLAUDE.md"));
+  const hasClaudeDir = existsSync12(claudeDir);
+  if (!hasClaudeMd && !hasClaudeDir) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No CLAUDE.md or .claude/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve19(projectRoot, "packs", "claude-import");
+  ensureDir(packDir);
+  const rulesDir = resolve19(packDir, "rules");
+  ensureDir(rulesDir);
+  if (hasClaudeMd) {
+    const raw = readFileSync12(resolve19(projectRoot, "CLAUDE.md"), "utf-8");
+    const ruleContent = [
+      "---",
+      "root: true",
+      'description: "Root Claude Code rules"',
+      "---",
+      "",
+      raw
+    ].join(`
+`);
+    const dest = join19(rulesDir, "claude-root.md");
+    writeFileSync8(dest, ruleContent);
+    filesImported.push(dest);
+  }
+  if (hasClaudeDir) {
+    const claudeRulesDir = resolve19(claudeDir, "rules");
+    if (existsSync12(claudeRulesDir)) {
+      const files = listFiles(claudeRulesDir, { extension: ".md" });
+      for (const file of files) {
+        const dest = join19(rulesDir, basename8(file));
+        copyFileSync3(file, dest);
+        filesImported.push(dest);
+      }
+    }
+    const settingsPath = resolve19(claudeDir, "settings.json");
+    if (existsSync12(settingsPath)) {
+      try {
+        const raw = readFileSync12(settingsPath, "utf-8");
+        const settings = JSON.parse(raw);
+        const mcpServers = settings.mcpServers ?? settings.mcp_servers;
+        if (mcpServers && typeof mcpServers === "object") {
+          const mcpConfig = { servers: mcpServers };
+          const dest = join19(packDir, "mcp.json");
+          writeFileSync8(dest, JSON.stringify(mcpConfig, null, 2) + `
+`);
+          filesImported.push(dest);
+        }
+      } catch {
+        warnings.push("Failed to parse .claude/settings.json");
+      }
+    }
+  }
+  const packJson = {
+    name: "claude-import",
+    version: "1.0.0",
+    description: "Imported from Claude Code",
+    tags: ["imported", "claude-code"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  const packJsonPath = join19(packDir, "pack.json");
+  writeFileSync8(packJsonPath, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(packJsonPath);
+  return { packDir, filesImported, warnings, configGenerated: false };
+}
+
+// src/importers/opencode.ts
+import { existsSync as existsSync13, readFileSync as readFileSync13, writeFileSync as writeFileSync9, copyFileSync as copyFileSync4 } from "fs";
+import { resolve as resolve20, join as join20, basename as basename9 } from "path";
+function importFromOpenCode(projectRoot, outputPackDir) {
+  const warnings = [];
+  const filesImported = [];
+  const ocDir = resolve20(projectRoot, ".opencode");
+  if (!existsSync13(ocDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .opencode/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve20(projectRoot, "packs", "opencode-import");
+  ensureDir(packDir);
+  importDirMd(resolve20(ocDir, "rules"), resolve20(packDir, "rules"), filesImported);
+  importDirMd(resolve20(ocDir, "commands"), resolve20(packDir, "commands"), filesImported);
+  importDirMd(resolve20(ocDir, "agents"), resolve20(packDir, "agents"), filesImported);
+  const skillDir = resolve20(ocDir, "skill");
+  if (existsSync13(skillDir)) {
+    const outSkillDir = resolve20(packDir, "skills");
+    ensureDir(outSkillDir);
+    const dirs = listDirs(skillDir);
+    for (const dir of dirs) {
+      const name = basename9(dir);
+      if (name.startsWith("."))
+        continue;
+      const skillMd = join20(dir, "SKILL.md");
+      if (existsSync13(skillMd)) {
+        const outDir = join20(outSkillDir, name);
+        ensureDir(outDir);
+        copyFileSync4(skillMd, join20(outDir, "SKILL.md"));
+        filesImported.push(join20(outDir, "SKILL.md"));
+      }
+    }
+  }
+  const pluginsDir = resolve20(ocDir, "plugins");
+  if (existsSync13(pluginsDir)) {
+    const outPluginsDir = resolve20(packDir, "plugins");
+    ensureDir(outPluginsDir);
+    const files = listFiles(pluginsDir);
+    for (const file of files) {
+      if (file.endsWith(".ts") || file.endsWith(".js")) {
+        const dest2 = join20(outPluginsDir, basename9(file));
+        copyFileSync4(file, dest2);
+        filesImported.push(dest2);
+      }
+    }
+  }
+  const agentsMd = resolve20(projectRoot, "AGENTS.md");
+  if (existsSync13(agentsMd)) {
+    const outRulesDir = resolve20(packDir, "rules");
+    ensureDir(outRulesDir);
+    const raw = readFileSync13(agentsMd, "utf-8");
+    const ruleContent = [
+      "---",
+      "root: true",
+      'description: "AGENTS.md root rules"',
+      "---",
+      "",
+      raw
+    ].join(`
+`);
+    const dest2 = join20(outRulesDir, "agents-md-root.md");
+    writeFileSync9(dest2, ruleContent);
+    filesImported.push(dest2);
+  }
+  const ocJson = resolve20(projectRoot, "opencode.json");
+  if (existsSync13(ocJson)) {
+    try {
+      const raw = readFileSync13(ocJson, "utf-8");
+      const config = JSON.parse(raw);
+      const mcpObj = config.mcp;
+      if (mcpObj) {
+        const dest2 = join20(packDir, "mcp.json");
+        writeFileSync9(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
+`);
+        filesImported.push(dest2);
+      }
+    } catch {
+      warnings.push("Failed to parse opencode.json");
+    }
+  }
+  const ocIgnore = resolve20(projectRoot, ".opencodeignore");
+  if (existsSync13(ocIgnore)) {
+    copyFileSync4(ocIgnore, join20(packDir, "ignore"));
+    filesImported.push(join20(packDir, "ignore"));
+  }
+  const packJson = {
+    name: "opencode-import",
+    version: "1.0.0",
+    description: "Imported from OpenCode",
+    tags: ["imported", "opencode"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  const dest = join20(packDir, "pack.json");
+  writeFileSync9(dest, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(dest);
+  return { packDir, filesImported, warnings, configGenerated: false };
+}
+function importDirMd(srcDir, outDir, filesImported) {
+  if (!existsSync13(srcDir))
+    return;
+  ensureDir(outDir);
+  const files = listFiles(srcDir, { extension: ".md" });
+  for (const file of files) {
+    const dest = join20(outDir, basename9(file));
+    copyFileSync4(file, dest);
+    filesImported.push(dest);
+  }
+}
+
+// src/cli/export-cmd.ts
+init_config();
+import { resolve as resolve21 } from "path";
+import chalk from "chalk";
+function runExport(projectRoot, options) {
+  const config = loadWorkspaceConfig(projectRoot);
+  const verbose = options.verbose ?? config.verbose;
+  const loader = new PackLoader(projectRoot, config);
+  const { packs, warnings: loadWarnings } = loader.loadAll();
+  for (const w of loadWarnings) {
+    console.log(chalk.yellow(`  warn: ${w}`));
+  }
+  if (packs.length === 0) {
+    console.log(chalk.red("No packs loaded. Nothing to export."));
+    return;
+  }
+  const packsToExport = options.pack ? packs.filter((p) => p.manifest.name === options.pack) : packs;
+  if (packsToExport.length === 0) {
+    console.log(chalk.red(`Pack "${options.pack}" not found.`));
+    return;
+  }
+  const outputDir = resolve21(projectRoot, options.output ?? "dist/cursor-plugins");
+  switch (options.format) {
+    case "cursor-plugin": {
+      let totalFiles = 0;
+      for (const pack of packsToExport) {
+        if (verbose) {
+          console.log(chalk.dim(`  Exporting ${pack.manifest.name}...`));
+        }
+        const result = exportCursorPlugin(pack, outputDir);
+        totalFiles += result.filesWritten.length;
+        if (verbose) {
+          console.log(chalk.dim(`    ${result.filesWritten.length} file(s) written`));
+        }
+      }
+      console.log(chalk.green(`Exported ${packsToExport.length} pack(s) as Cursor plugins (${totalFiles} files) to ${outputDir}`));
+      break;
+    }
+    default:
+      console.log(chalk.red(`Unknown export format: "${options.format}". Supported: cursor-plugin`));
+  }
+}
+
+// src/utils/diff.ts
+import { existsSync as existsSync14, readFileSync as readFileSync14 } from "fs";
+function diffFile(filepath, newContent) {
+  if (!existsSync14(filepath)) {
+    return {
+      filepath,
+      status: "added",
+      diffLines: formatAddedDiff(filepath, newContent)
+    };
+  }
+  const existing = readFileSync14(filepath, "utf-8");
+  if (existing === newContent) {
+    return { filepath, status: "unchanged", diffLines: [] };
+  }
+  return {
+    filepath,
+    status: "modified",
+    diffLines: computeUnifiedDiff(filepath, existing, newContent)
+  };
+}
+function formatAddedDiff(filepath, content) {
+  const lines = [
+    `--- /dev/null`,
+    `+++ ${filepath}`,
+    `@@ -0,0 +1,${content.split(`
+`).length} @@`
+  ];
+  for (const line of content.split(`
+`)) {
+    lines.push(`+${line}`);
+  }
+  return lines;
+}
+function computeUnifiedDiff(filepath, oldContent, newContent) {
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  const result = [`--- ${filepath}`, `+++ ${filepath}`];
+  const hunks = findHunks(oldLines, newLines);
+  for (const hunk of hunks) {
+    result.push(`@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@`);
+    for (const line of hunk.lines) {
+      result.push(line);
+    }
+  }
+  return result;
+}
+function findHunks(oldLines, newLines) {
+  const CONTEXT = 3;
+  const changes = [];
+  let oi = 0;
+  let ni = 0;
+  while (oi < oldLines.length || ni < newLines.length) {
+    if (oi < oldLines.length && ni < newLines.length && oldLines[oi] === newLines[ni]) {
+      changes.push({ type: " ", line: oldLines[oi], oldIdx: oi, newIdx: ni });
+      oi++;
+      ni++;
+    } else if (ni < newLines.length && (oi >= oldLines.length || !newLines.slice(ni).includes(oldLines[oi]))) {
+      changes.push({ type: "+", line: newLines[ni], oldIdx: oi, newIdx: ni });
+      ni++;
+    } else {
+      changes.push({ type: "-", line: oldLines[oi], oldIdx: oi, newIdx: oi });
+      oi++;
+    }
+  }
+  const hunks = [];
+  let currentHunk = null;
+  let unchangedCount = 0;
+  for (const change of changes) {
+    if (change.type === " ") {
+      unchangedCount++;
+      if (currentHunk && unchangedCount <= CONTEXT) {
+        currentHunk.lines.push(` ${change.line}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+      } else if (currentHunk && unchangedCount > CONTEXT * 2) {
+        hunks.push(currentHunk);
+        currentHunk = null;
+      }
+    } else {
+      if (!currentHunk) {
+        const contextStart = Math.max(0, changes.indexOf(change) - CONTEXT);
+        currentHunk = {
+          oldStart: change.oldIdx - Math.min(CONTEXT, changes.indexOf(change) - contextStart),
+          oldCount: 0,
+          newStart: change.newIdx - Math.min(CONTEXT, changes.indexOf(change) - contextStart),
+          newCount: 0,
+          lines: []
+        };
+        for (let i = contextStart;i < changes.indexOf(change); i++) {
+          if (changes[i].type === " ") {
+            currentHunk.lines.push(` ${changes[i].line}`);
+            currentHunk.oldCount++;
+            currentHunk.newCount++;
+          }
+        }
+      }
+      unchangedCount = 0;
+      currentHunk.lines.push(`${change.type}${change.line}`);
+      if (change.type === "-")
+        currentHunk.oldCount++;
+      if (change.type === "+")
+        currentHunk.newCount++;
+    }
+  }
+  if (currentHunk)
+    hunks.push(currentHunk);
+  return hunks;
+}
+
+// src/cli/generate.ts
+init_config();
+import { existsSync as existsSync15, readFileSync as readFileSync15 } from "fs";
+import chalk2 from "chalk";
+function runGenerate(projectRoot, options) {
+  const config = loadWorkspaceConfig(projectRoot);
+  if (options.targets) {
+    const targetList = options.targets === "*" ? "*" : options.targets.split(",");
+    config.targets = targetList;
+  }
+  if (options.features) {
+    const featureList = options.features === "*" ? "*" : options.features.split(",");
+    config.features = featureList;
+  }
+  if (options.verbose !== undefined) {
+    config.verbose = options.verbose;
+  }
+  const verbose = config.verbose;
+  if (verbose)
+    console.log(chalk2.dim("Loading packs..."));
+  const loader = new PackLoader(projectRoot, config);
+  const { packs, warnings: loadWarnings } = loader.loadAll();
+  for (const w of loadWarnings) {
+    console.log(chalk2.yellow(`  warn: ${w}`));
+  }
+  if (packs.length === 0) {
+    console.log(chalk2.red("No packs loaded. Nothing to generate."));
+    console.log(chalk2.dim("Run 'agentpacks init' to create a default pack."));
+    return;
+  }
+  if (verbose) {
+    console.log(chalk2.dim(`  Loaded ${packs.length} pack(s): ${packs.map((p) => p.manifest.name).join(", ")}`));
+  }
+  if (verbose)
+    console.log(chalk2.dim("Merging features..."));
+  const merger = new FeatureMerger(packs);
+  const { features, warnings: mergeWarnings } = merger.merge();
+  for (const w of mergeWarnings) {
+    console.log(chalk2.yellow(`  warn: ${w}`));
+  }
+  const targetIds = resolveTargets(config);
+  if (!targetIds.includes("agentsmd")) {
+    targetIds.push("agentsmd");
+  }
+  const targets = getTargets(targetIds);
+  if (targets.length === 0) {
+    console.log(chalk2.red("No valid targets found."));
+    return;
+  }
+  const allResults = [];
+  const diffEntries = [];
+  for (const baseDir of config.baseDirs) {
+    for (const target of targets) {
+      const enabledFeatures = resolveFeatures(config, target.id);
+      const effectiveFeatures = enabledFeatures.filter((f) => target.supportsFeature(f));
+      if (effectiveFeatures.length === 0 && target.id !== "agentsmd") {
+        if (verbose) {
+          console.log(chalk2.dim(`  Skipping ${target.name} (no enabled features)`));
+        }
+        continue;
+      }
+      if (options.dryRun && !options.diff) {
+        console.log(chalk2.cyan(`  [dry-run] Would generate ${target.name} in ${baseDir}`));
+        continue;
+      }
+      const generateOptions = {
+        projectRoot,
+        baseDir,
+        features,
+        enabledFeatures,
+        deleteExisting: options.diff ? false : config.delete,
+        global: config.global,
+        verbose: config.verbose
+      };
+      const preSnapshot = new Map;
+      try {
+        const result = target.generate(generateOptions);
+        allResults.push(result);
+        if (options.diff) {
+          for (const filepath of result.filesWritten) {
+            const newContent = existsSync15(filepath) ? readFileSync15(filepath, "utf-8") : "";
+            const entry = diffFile(filepath, newContent);
+            if (entry.status !== "unchanged") {
+              diffEntries.push(entry);
+            }
+          }
+        }
+        for (const w of result.warnings) {
+          console.log(chalk2.yellow(`  warn [${target.name}]: ${w}`));
+        }
+        if (verbose && result.filesWritten.length > 0) {
+          console.log(chalk2.dim(`  ${target.name}: wrote ${result.filesWritten.length} file(s)`));
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk2.red(`  error [${target.name}]: ${message}`));
+      }
+    }
+  }
+  if (options.diff && diffEntries.length > 0) {
+    const added = diffEntries.filter((e) => e.status === "added").length;
+    const modified = diffEntries.filter((e) => e.status === "modified").length;
+    console.log(chalk2.bold(`
+Diff: ${added} added, ${modified} modified
+`));
+    for (const entry of diffEntries) {
+      const label = entry.status === "added" ? chalk2.green("[+] " + entry.filepath) : chalk2.yellow("[M] " + entry.filepath);
+      console.log(label);
+      if (verbose) {
+        for (const line of entry.diffLines.slice(0, 50)) {
+          if (line.startsWith("+") && !line.startsWith("+++")) {
+            console.log(chalk2.green(line));
+          } else if (line.startsWith("-") && !line.startsWith("---")) {
+            console.log(chalk2.red(line));
+          } else {
+            console.log(chalk2.dim(line));
+          }
+        }
+        if (entry.diffLines.length > 50) {
+          console.log(chalk2.dim(`  ... ${entry.diffLines.length - 50} more lines`));
+        }
+      }
+    }
+    console.log();
+  } else if (options.diff) {
+    console.log(chalk2.dim("No changes detected."));
+  }
+  if (!options.dryRun) {
+    const totalWritten = allResults.reduce((sum, r) => sum + r.filesWritten.length, 0);
+    const totalDeleted = allResults.reduce((sum, r) => sum + r.filesDeleted.length, 0);
+    const targetNames = allResults.map((r) => r.targetId);
+    const uniqueTargets = [...new Set(targetNames)];
+    console.log(chalk2.green(`Generated ${totalWritten} file(s) for ${uniqueTargets.length} target(s)` + (totalDeleted > 0 ? ` (cleaned ${totalDeleted} dir(s))` : "")));
+  }
+}
+
+// src/cli/import-cmd.ts
+import chalk3 from "chalk";
+function runImport(projectRoot, options) {
+  const { from, output } = options;
+  switch (from) {
+    case "rulesync": {
+      console.log(chalk3.dim("Importing from .rulesync/ ..."));
+      const result = importFromRulesync(projectRoot, output);
+      if (result.warnings.length > 0) {
+        for (const w of result.warnings) {
+          console.log(chalk3.yellow(`  warn: ${w}`));
+        }
+        return;
+      }
+      console.log(chalk3.green(`Imported ${result.filesImported.length} file(s) to ${result.packDir}`));
+      if (result.configGenerated) {
+        console.log(chalk3.green("Generated agentpacks.jsonc from rulesync.jsonc"));
+      }
+      console.log(chalk3.cyan(`
+Next steps:`), `
+  1. Review the imported pack at`, chalk3.bold(result.packDir), `
+  2. Run`, chalk3.bold("agentpacks generate"), "to generate tool configs");
+      break;
+    }
+    case "cursor": {
+      console.log(chalk3.dim("Importing from .cursor/ ..."));
+      const cursorResult = importFromCursor(projectRoot, output);
+      printImportResult(cursorResult, "Cursor");
+      break;
+    }
+    case "claude":
+    case "claudecode":
+    case "claude-code": {
+      console.log(chalk3.dim("Importing from Claude Code..."));
+      const claudeResult = importFromClaudeCode(projectRoot, output);
+      printImportResult(claudeResult, "Claude Code");
+      break;
+    }
+    case "opencode": {
+      console.log(chalk3.dim("Importing from .opencode/ ..."));
+      const ocResult = importFromOpenCode(projectRoot, output);
+      printImportResult(ocResult, "OpenCode");
+      break;
+    }
+    default:
+      console.log(chalk3.red(`Unknown import source: "${from}"`));
+      console.log(chalk3.dim("Supported sources: rulesync, cursor, claude-code, opencode"));
+      break;
+  }
+}
+function printImportResult(result, sourceName) {
+  if (result.warnings.length > 0 && result.filesImported.length === 0) {
+    for (const w of result.warnings) {
+      console.log(chalk3.yellow(`  warn: ${w}`));
+    }
+    return;
+  }
+  for (const w of result.warnings) {
+    console.log(chalk3.yellow(`  warn: ${w}`));
+  }
+  console.log(chalk3.green(`Imported ${result.filesImported.length} file(s) from ${sourceName} to ${result.packDir}`));
+  console.log(chalk3.cyan(`
+Next steps:`), `
+  1. Review the imported pack at`, chalk3.bold(result.packDir), `
+  2. Run`, chalk3.bold("agentpacks generate"), "to generate tool configs");
+}
+
+// src/cli/init.ts
+import { existsSync as existsSync16, copyFileSync as copyFileSync5, writeFileSync as writeFileSync10 } from "fs";
+import { resolve as resolve22, join as join21 } from "path";
+import chalk4 from "chalk";
+function runInit(projectRoot) {
+  const configPath = resolve22(projectRoot, "agentpacks.jsonc");
+  const packsDir = resolve22(projectRoot, "packs", "default");
+  if (existsSync16(configPath)) {
+    console.log(chalk4.yellow("agentpacks.jsonc already exists. Skipping config creation."));
+  } else {
+    const templateDir = resolve22(import.meta.dirname, "..", "..", "templates");
+    const templateConfig = resolve22(templateDir, "workspace", "agentpacks.jsonc");
+    if (existsSync16(templateConfig)) {
+      copyFileSync5(templateConfig, configPath);
+    } else {
+      const config = {
+        $schema: "https://unpkg.com/agentpacks/schema.json",
+        packs: ["./packs/default"],
+        disabled: [],
+        targets: [
+          "opencode",
+          "cursor",
+          "claudecode",
+          "geminicli",
+          "codexcli",
+          "copilot"
+        ],
+        features: ["*"],
+        mode: "repo",
+        baseDirs: ["."],
+        global: false,
+        delete: true
+      };
+      writeFileSync10(configPath, JSON.stringify(config, null, 2) + `
+`);
+    }
+    console.log(chalk4.green("Created agentpacks.jsonc"));
+  }
+  if (existsSync16(packsDir)) {
+    console.log(chalk4.yellow("packs/default/ already exists. Skipping pack scaffold."));
+  } else {
+    ensureDir(packsDir);
+    ensureDir(join21(packsDir, "rules"));
+    ensureDir(join21(packsDir, "commands"));
+    ensureDir(join21(packsDir, "agents"));
+    ensureDir(join21(packsDir, "skills"));
+    const packJson = {
+      name: "default",
+      version: "1.0.0",
+      description: "Default project pack",
+      tags: [],
+      dependencies: [],
+      conflicts: [],
+      targets: "*",
+      features: "*"
+    };
+    writeFileSync10(join21(packsDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+`);
+    const templateRule = resolve22(import.meta.dirname, "..", "..", "templates", "pack", "rules", "overview.md");
+    if (existsSync16(templateRule)) {
+      copyFileSync5(templateRule, join21(packsDir, "rules", "overview.md"));
+    }
+    console.log(chalk4.green("Created packs/default/ with scaffold"));
+  }
+  console.log(chalk4.cyan(`
+Next steps:`), `
+  1. Edit packs/default/rules/overview.md with your project guidelines`, `
+  2. Run`, chalk4.bold("agentpacks generate"), "to generate tool configs", `
+  3. Or run`, chalk4.bold("agentpacks import --from rulesync"), "to migrate from rulesync");
+}
+
+// src/cli/install.ts
+init_config();
+import chalk5 from "chalk";
+async function runInstall(projectRoot, options) {
+  const config = loadWorkspaceConfig(projectRoot);
+  const lockfile = loadLockfile(projectRoot);
+  const verbose = options.verbose ?? config.verbose;
+  const remotePacks = config.packs.filter((ref) => isGitPackRef(ref) || isNpmPackRef(ref));
+  const localPacks = config.packs.filter((ref) => isLocalPackRef(ref));
+  if (remotePacks.length === 0) {
+    console.log(chalk5.dim("No remote packs to install. All packs are local."));
+    return;
+  }
+  if (verbose) {
+    console.log(chalk5.dim(`Found ${remotePacks.length} remote pack(s) to install`));
+    console.log(chalk5.dim(`  (${localPacks.length} local pack(s) skipped)`));
+  }
+  if (options.frozen) {
+    const sourceKeys = remotePacks.map((ref) => ref);
+    const frozenCheck = isLockfileFrozenValid(lockfile, sourceKeys);
+    if (!frozenCheck.valid) {
+      console.log(chalk5.red(`Frozen install failed. Missing lockfile entries: ${frozenCheck.missing.join(", ")}`));
+      process.exit(1);
+    }
+  }
+  let totalInstalled = 0;
+  const allWarnings = [];
+  for (const packRef of remotePacks) {
+    if (verbose) {
+      console.log(chalk5.dim(`  Installing ${packRef}...`));
+    }
+    try {
+      let result;
+      if (isGitPackRef(packRef)) {
+        const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? undefined;
+        result = await installGitSource(projectRoot, packRef, lockfile, {
+          update: options.update,
+          frozen: options.frozen,
+          token
+        });
+      } else if (isNpmPackRef(packRef)) {
+        result = await installNpmSource(projectRoot, packRef, lockfile, {
+          update: options.update,
+          frozen: options.frozen
+        });
+      } else {
+        continue;
+      }
+      totalInstalled += result.installed.length;
+      allWarnings.push(...result.warnings);
+      if (verbose && result.installed.length > 0) {
+        console.log(chalk5.dim(`    ${result.installed.length} file(s) installed`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk5.red(`  error [${packRef}]: ${msg}`));
+      allWarnings.push(`Failed to install ${packRef}: ${msg}`);
+    }
+  }
+  for (const w of allWarnings) {
+    console.log(chalk5.yellow(`  warn: ${w}`));
+  }
+  saveLockfile(projectRoot, lockfile);
+  console.log(chalk5.green(`Installed ${totalInstalled} file(s) from ${remotePacks.length} source(s)`));
+  if (verbose) {
+    console.log(chalk5.dim("Lockfile updated: agentpacks.lock"));
+  }
+}
+
+// src/cli/pack/create.ts
+import { existsSync as existsSync17, writeFileSync as writeFileSync11 } from "fs";
+import { resolve as resolve23, join as join22 } from "path";
+import chalk6 from "chalk";
+function runPackCreate(projectRoot, name) {
+  const packDir = resolve23(projectRoot, "packs", name);
+  if (existsSync17(packDir)) {
+    console.log(chalk6.red(`Pack "${name}" already exists at packs/${name}/`));
+    return;
+  }
+  ensureDir(packDir);
+  ensureDir(join22(packDir, "rules"));
+  ensureDir(join22(packDir, "commands"));
+  ensureDir(join22(packDir, "agents"));
+  ensureDir(join22(packDir, "skills"));
+  const packJson = {
+    name,
+    version: "1.0.0",
+    description: "",
+    tags: [],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  writeFileSync11(join22(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+`);
+  console.log(chalk6.green(`Created pack "${name}" at packs/${name}/`));
+  console.log(chalk6.dim("  Add rules, commands, agents, skills, hooks, plugins, mcp.json, or ignore files."));
+  console.log(chalk6.dim(`  Then add "${join22("./packs", name)}" to packs[] in agentpacks.jsonc.`));
+}
+
+// src/cli/pack/enable.ts
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync18 } from "fs";
+import { resolve as resolve24 } from "path";
+import chalk7 from "chalk";
+var CONFIG_FILENAME = "agentpacks.jsonc";
+function readConfigRaw(projectRoot) {
+  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
+  if (!existsSync18(filepath)) {
+    throw new Error(`No ${CONFIG_FILENAME} found. Run 'agentpacks init' first.`);
+  }
+  return readFileSync16(filepath, "utf-8");
+}
+function parseDisabledFromRaw(raw) {
+  const regex = /"disabled"\s*:\s*\[([^\]]*)\]/;
+  const match = regex.exec(raw);
+  if (!match)
+    return { list: [], match: null };
+  const inner = match[1].trim();
+  if (!inner)
+    return { list: [], match };
+  const list = inner.split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+  return { list, match };
+}
+function writeDisabled(raw, newList, match) {
+  const formatted = newList.length === 0 ? '"disabled": []' : `"disabled": [${newList.map((n) => `"${n}"`).join(", ")}]`;
+  if (!match) {
+    return raw.replace(/("packs"\s*:\s*\[[^\]]*\],?)/, `$1
+
+  // Packs to disable (override)
+  ${formatted},`);
+  }
+  return raw.slice(0, match.index) + formatted + raw.slice(match.index + match[0].length);
+}
+function runPackDisable(projectRoot, packName) {
+  const raw = readConfigRaw(projectRoot);
+  const { list, match } = parseDisabledFromRaw(raw);
+  if (list.includes(packName)) {
+    console.log(chalk7.dim(`Pack "${packName}" is already disabled.`));
+    return;
+  }
+  list.push(packName);
+  const updated = writeDisabled(raw, list, match);
+  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
+  writeFileSync12(filepath, updated);
+  console.log(chalk7.green(`Disabled pack "${packName}".`));
+  console.log(chalk7.dim("Run 'agentpacks generate' to regenerate configs."));
+}
+function runPackEnable(projectRoot, packName) {
+  const raw = readConfigRaw(projectRoot);
+  const { list, match } = parseDisabledFromRaw(raw);
+  if (!list.includes(packName)) {
+    console.log(chalk7.dim(`Pack "${packName}" is not disabled.`));
+    return;
+  }
+  const newList = list.filter((n) => n !== packName);
+  const updated = writeDisabled(raw, newList, match);
+  const filepath = resolve24(projectRoot, CONFIG_FILENAME);
+  writeFileSync12(filepath, updated);
+  console.log(chalk7.green(`Enabled pack "${packName}".`));
+  console.log(chalk7.dim("Run 'agentpacks generate' to regenerate configs."));
+}
+
+// src/cli/pack/list.ts
+init_config();
+import chalk8 from "chalk";
+function runPackList(projectRoot) {
+  const config = loadWorkspaceConfig(projectRoot);
+  const loader = new PackLoader(projectRoot, config);
+  const { packs, warnings } = loader.loadAll();
+  const disabledSet = new Set(config.disabled);
+  for (const w of warnings) {
+    console.log(chalk8.yellow(`  warn: ${w}`));
+  }
+  if (packs.length === 0 && config.packs.length === 0) {
+    console.log(chalk8.dim("No packs configured. Run 'agentpacks init' to get started."));
+    return;
+  }
+  console.log(chalk8.bold(`Active packs:
+`));
+  for (const pack of packs) {
+    const m = pack.manifest;
+    const features = [];
+    if (pack.rules.length > 0)
+      features.push(`${pack.rules.length} rules`);
+    if (pack.commands.length > 0)
+      features.push(`${pack.commands.length} commands`);
+    if (pack.agents.length > 0)
+      features.push(`${pack.agents.length} agents`);
+    if (pack.skills.length > 0)
+      features.push(`${pack.skills.length} skills`);
+    if (pack.hooks)
+      features.push("hooks");
+    if (pack.plugins.length > 0)
+      features.push(`${pack.plugins.length} plugins`);
+    if (pack.mcp)
+      features.push(`${Object.keys(pack.mcp.servers).length} MCP servers`);
+    if (pack.ignore)
+      features.push("ignore");
+    const status = disabledSet.has(m.name) ? chalk8.red("[disabled]") : chalk8.green("[active]");
+    console.log(`  ${status} ${chalk8.bold(m.name)} v${m.version}`);
+    if (m.description) {
+      console.log(`    ${chalk8.dim(m.description)}`);
+    }
+    if (features.length > 0) {
+      console.log(`    ${chalk8.dim(features.join(", "))}`);
+    }
+    console.log();
+  }
+  for (const ref of config.disabled) {
+    if (!packs.some((p) => p.manifest.name === ref)) {
+      console.log(`  ${chalk8.red("[disabled]")} ${chalk8.dim(ref)}`);
+    }
+  }
+}
+
+// src/cli/pack/validate.ts
+init_config();
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve25, join as join23 } from "path";
+import chalk9 from "chalk";
+function runPackValidate(projectRoot) {
+  const config = loadWorkspaceConfig(projectRoot);
+  let hasErrors = false;
+  for (const packRef of config.packs) {
+    const packDir = resolvePackDir(projectRoot, packRef);
+    console.log(chalk9.bold(`
+Validating pack: ${packRef}`));
+    if (!packDir || !existsSync19(packDir)) {
+      console.log(chalk9.red(`  ERROR: Pack directory not found: ${packRef}`));
+      hasErrors = true;
+      continue;
+    }
+    const packJsonPath = resolve25(packDir, "pack.json");
+    if (!existsSync19(packJsonPath)) {
+      console.log(chalk9.yellow("  warn: No pack.json found. Name will be inferred from directory."));
+    } else {
+      try {
+        loadPackManifest(packDir);
+        console.log(chalk9.green("  pack.json: valid"));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk9.red(`  ERROR pack.json: ${message}`));
+        hasErrors = true;
+      }
+    }
+    const subdirs = ["rules", "commands", "agents", "skills"];
+    for (const sub of subdirs) {
+      const subDir = join23(packDir, sub);
+      if (existsSync19(subDir)) {
+        if (sub === "skills") {
+          const skillDirs = listDirs(subDir);
+          for (const skillDir of skillDirs) {
+            const skillMd = join23(skillDir, "SKILL.md");
+            if (!existsSync19(skillMd)) {
+              console.log(chalk9.yellow(`  warn: skills/${skillDir.split("/").pop()} missing SKILL.md`));
+            }
+          }
+          console.log(chalk9.green(`  ${sub}/: ${skillDirs.length} skill(s)`));
+        } else {
+          const files = listFiles(subDir, { extension: ".md" });
+          console.log(chalk9.green(`  ${sub}/: ${files.length} file(s)`));
+        }
+      }
+    }
+    const optionalFiles = ["mcp.json", "ignore", ".aiignore"];
+    for (const file of optionalFiles) {
+      if (existsSync19(join23(packDir, file))) {
+        console.log(chalk9.green(`  ${file}: present`));
+      }
+    }
+    const hooksJson = join23(packDir, "hooks", "hooks.json");
+    if (existsSync19(hooksJson)) {
+      console.log(chalk9.green("  hooks/hooks.json: present"));
+    }
+    const pluginsDir = join23(packDir, "plugins");
+    if (existsSync19(pluginsDir)) {
+      const pluginFiles = [
+        ...listFiles(pluginsDir, { extension: ".ts" }),
+        ...listFiles(pluginsDir, { extension: ".js" })
+      ];
+      console.log(chalk9.green(`  plugins/: ${pluginFiles.length} file(s)`));
+    }
+  }
+  console.log();
+  if (hasErrors) {
+    console.log(chalk9.red("Validation failed with errors."));
+    process.exit(1);
+  } else {
+    console.log(chalk9.green("All packs valid."));
+  }
+}
+function resolvePackDir(projectRoot, packRef) {
+  if (packRef.startsWith("./") || packRef.startsWith("../")) {
+    return resolve25(projectRoot, packRef);
+  }
+  return resolve25(projectRoot, packRef);
+}
+
+// src/index.ts
+import { Command } from "commander";
+import { resolve as resolve26 } from "path";
+var program = new Command;
+program.name("agentpacks").description("Composable AI agent configuration manager. Pack-based rules, commands, skills, hooks, and MCP sync across OpenCode, Cursor, Claude Code, Codex, Gemini, Copilot, and more.").version("0.1.0");
+program.command("init").description("Initialize agentpacks in the current project").action(() => {
+  runInit(resolve26("."));
+});
+program.command("generate").description("Generate tool configs from active packs").option("-t, --targets <targets>", "Comma-separated target IDs or '*' for all").option("-f, --features <features>", "Comma-separated feature IDs or '*' for all").option("--dry-run", "Preview changes without writing files").option("--diff", "Show diff of what would change").option("-v, --verbose", "Enable verbose logging").action((options) => {
+  runGenerate(resolve26("."), options);
+});
+program.command("install").description("Install remote packs (git, npm) into local cache").option("--update", "Re-resolve all refs (ignore lockfile)").option("--frozen", "Fail if lockfile is missing or incomplete").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+  await runInstall(resolve26("."), options);
+});
+program.command("export").description("Export packs to target-native format (e.g. Cursor plugin)").requiredOption("--format <format>", "Export format (cursor-plugin)").option("-o, --output <dir>", "Output directory").option("--pack <name>", "Export a specific pack only").option("-v, --verbose", "Enable verbose logging").action((options) => {
+  runExport(resolve26("."), options);
+});
+program.command("import").description("Import from existing tool configurations").requiredOption("--from <source>", "Import source (rulesync)").option("-o, --output <dir>", "Output pack directory").action((options) => {
+  runImport(resolve26("."), options);
+});
+var packCmd = program.command("pack").description("Manage packs");
+packCmd.command("create <name>").description("Create a new pack scaffold").action((name) => {
+  runPackCreate(resolve26("."), name);
+});
+packCmd.command("list").description("List all configured packs and their status").action(() => {
+  runPackList(resolve26("."));
+});
+packCmd.command("validate").description("Validate all configured packs").action(() => {
+  runPackValidate(resolve26("."));
+});
+packCmd.command("enable <name>").description("Enable a previously disabled pack").action((name) => {
+  runPackEnable(resolve26("."), name);
+});
+packCmd.command("disable <name>").description("Disable a pack without removing it").action((name) => {
+  runPackDisable(resolve26("."), name);
+});
+program.parse();