agentpacks 0.2.0

package/dist/cli/import-cmd.d.ts

@@ -0,0 +1,9 @@
+interface ImportOptions {
+    from: string;
+    output?: string;
+}
+/**
+ * Run the import command.
+ */
+export declare function runImport(projectRoot: string, options: ImportOptions): void;
+export {};

package/dist/cli/import-cmd.js

@@ -0,0 +1,691 @@
+// @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/utils/filesystem.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  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 (!existsSync(filepath))
+    return null;
+  return readFileSync(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync(targetPath)) {
+    removeSync(targetPath);
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync(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 (!existsSync(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/importers/rulesync.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, copyFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2, join as join2, basename } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+function importFromRulesync(projectRoot, outputPackDir) {
+  const rulesyncDir = resolve2(projectRoot, ".rulesync");
+  const warnings = [];
+  const filesImported = [];
+  if (!existsSync2(rulesyncDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .rulesync/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve2(projectRoot, "packs", "default");
+  ensureDir(packDir);
+  const rulesDir = resolve2(rulesyncDir, "rules");
+  if (existsSync2(rulesDir)) {
+    const outRulesDir = resolve2(packDir, "rules");
+    ensureDir(outRulesDir);
+    const files = listFiles(rulesDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join2(outRulesDir, basename(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const commandsDir = resolve2(rulesyncDir, "commands");
+  if (existsSync2(commandsDir)) {
+    const outCommandsDir = resolve2(packDir, "commands");
+    ensureDir(outCommandsDir);
+    const files = listFiles(commandsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join2(outCommandsDir, basename(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const subagentsDir = resolve2(rulesyncDir, "subagents");
+  if (existsSync2(subagentsDir)) {
+    const outAgentsDir = resolve2(packDir, "agents");
+    ensureDir(outAgentsDir);
+    const files = listFiles(subagentsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join2(outAgentsDir, basename(file));
+      copyFileSync(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const skillsDir = resolve2(rulesyncDir, "skills");
+  if (existsSync2(skillsDir)) {
+    const outSkillsDir = resolve2(packDir, "skills");
+    ensureDir(outSkillsDir);
+    const skillDirs = listDirs(skillsDir);
+    for (const skillDir of skillDirs) {
+      const skillName = basename(skillDir);
+      if (skillName.startsWith("."))
+        continue;
+      const skillMd = join2(skillDir, "SKILL.md");
+      if (existsSync2(skillMd)) {
+        const outSkillDir = join2(outSkillsDir, skillName);
+        ensureDir(outSkillDir);
+        copyFileSync(skillMd, join2(outSkillDir, "SKILL.md"));
+        filesImported.push(join2(outSkillDir, "SKILL.md"));
+      }
+    }
+  }
+  const hooksJson = resolve2(rulesyncDir, "hooks.json");
+  if (existsSync2(hooksJson)) {
+    const outHooksDir = resolve2(packDir, "hooks");
+    ensureDir(outHooksDir);
+    copyFileSync(hooksJson, join2(outHooksDir, "hooks.json"));
+    filesImported.push(join2(outHooksDir, "hooks.json"));
+  }
+  const mcpJson = resolve2(rulesyncDir, "mcp.json");
+  if (existsSync2(mcpJson)) {
+    copyFileSync(mcpJson, join2(packDir, "mcp.json"));
+    filesImported.push(join2(packDir, "mcp.json"));
+  }
+  const aiIgnore = resolve2(rulesyncDir, ".aiignore");
+  const rulesyncIgnore = resolve2(projectRoot, ".rulesyncignore");
+  if (existsSync2(aiIgnore)) {
+    copyFileSync(aiIgnore, join2(packDir, "ignore"));
+    filesImported.push(join2(packDir, "ignore"));
+  } else if (existsSync2(rulesyncIgnore)) {
+    copyFileSync(rulesyncIgnore, join2(packDir, "ignore"));
+    filesImported.push(join2(packDir, "ignore"));
+  }
+  const packJson = {
+    name: "default",
+    version: "1.0.0",
+    description: "Imported from rulesync",
+    tags: ["imported", "rulesync"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  writeFileSync2(join2(packDir, "pack.json"), JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(join2(packDir, "pack.json"));
+  let configGenerated = false;
+  const rulesyncConfig = resolve2(projectRoot, "rulesync.jsonc");
+  if (existsSync2(rulesyncConfig)) {
+    const agentpacksConfig = convertRulesyncConfig(rulesyncConfig, packDir, projectRoot);
+    const configPath = resolve2(projectRoot, "agentpacks.jsonc");
+    writeFileSync2(configPath, agentpacksConfig);
+    configGenerated = true;
+  }
+  return { packDir, filesImported, warnings, configGenerated };
+}
+function convertRulesyncConfig(rulesyncPath, packDir, projectRoot) {
+  const raw = readFileSync2(rulesyncPath, "utf-8");
+  const parsed = parseJsonc(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 = "./" + join2("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 existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2 } from "fs";
+import { resolve as resolve3, join as join3, basename as basename2 } from "path";
+function importFromCursor(projectRoot, outputPackDir) {
+  const cursorDir = resolve3(projectRoot, ".cursor");
+  const warnings = [];
+  const filesImported = [];
+  if (!existsSync3(cursorDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .cursor/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve3(projectRoot, "packs", "cursor-import");
+  ensureDir(packDir);
+  const rulesDir = resolve3(cursorDir, "rules");
+  if (existsSync3(rulesDir)) {
+    const outRulesDir = resolve3(packDir, "rules");
+    ensureDir(outRulesDir);
+    const files = listFiles(rulesDir, { extension: ".mdc" });
+    for (const file of files) {
+      const raw = readFileSync3(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 = basename2(file, ".mdc");
+      const dest = join3(outRulesDir, `${name}.md`);
+      writeFileSync3(dest, mdContent);
+      filesImported.push(dest);
+    }
+    const mdFiles = listFiles(rulesDir, { extension: ".md" });
+    for (const file of mdFiles) {
+      const dest = join3(outRulesDir, basename2(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const agentsDir = resolve3(cursorDir, "agents");
+  if (existsSync3(agentsDir)) {
+    const outDir = resolve3(packDir, "agents");
+    ensureDir(outDir);
+    const files = listFiles(agentsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join3(outDir, basename2(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const skillsDir = resolve3(cursorDir, "skills");
+  if (existsSync3(skillsDir)) {
+    const outDir = resolve3(packDir, "skills");
+    ensureDir(outDir);
+    const dirs = listDirs(skillsDir);
+    for (const dir of dirs) {
+      const name = basename2(dir);
+      const skillMd = join3(dir, "SKILL.md");
+      if (existsSync3(skillMd)) {
+        const outSkillDir = join3(outDir, name);
+        ensureDir(outSkillDir);
+        copyFileSync2(skillMd, join3(outSkillDir, "SKILL.md"));
+        filesImported.push(join3(outSkillDir, "SKILL.md"));
+      }
+    }
+  }
+  const commandsDir = resolve3(cursorDir, "commands");
+  if (existsSync3(commandsDir)) {
+    const outDir = resolve3(packDir, "commands");
+    ensureDir(outDir);
+    const files = listFiles(commandsDir, { extension: ".md" });
+    for (const file of files) {
+      const dest = join3(outDir, basename2(file));
+      copyFileSync2(file, dest);
+      filesImported.push(dest);
+    }
+  }
+  const mcpJson = resolve3(cursorDir, "mcp.json");
+  if (existsSync3(mcpJson)) {
+    copyFileSync2(mcpJson, join3(packDir, "mcp.json"));
+    filesImported.push(join3(packDir, "mcp.json"));
+  }
+  const cursorIgnore = resolve3(projectRoot, ".cursorignore");
+  if (existsSync3(cursorIgnore)) {
+    copyFileSync2(cursorIgnore, join3(packDir, "ignore"));
+    filesImported.push(join3(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 = join3(packDir, "pack.json");
+  writeFileSync3(dest, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(dest);
+}
+
+// src/importers/claude-code.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, copyFileSync as copyFileSync3 } from "fs";
+import { resolve as resolve4, join as join4, basename as basename3 } from "path";
+function importFromClaudeCode(projectRoot, outputPackDir) {
+  const warnings = [];
+  const filesImported = [];
+  const claudeDir = resolve4(projectRoot, ".claude");
+  const hasClaudeMd = existsSync4(resolve4(projectRoot, "CLAUDE.md"));
+  const hasClaudeDir = existsSync4(claudeDir);
+  if (!hasClaudeMd && !hasClaudeDir) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No CLAUDE.md or .claude/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve4(projectRoot, "packs", "claude-import");
+  ensureDir(packDir);
+  const rulesDir = resolve4(packDir, "rules");
+  ensureDir(rulesDir);
+  if (hasClaudeMd) {
+    const raw = readFileSync4(resolve4(projectRoot, "CLAUDE.md"), "utf-8");
+    const ruleContent = [
+      "---",
+      "root: true",
+      'description: "Root Claude Code rules"',
+      "---",
+      "",
+      raw
+    ].join(`
+`);
+    const dest = join4(rulesDir, "claude-root.md");
+    writeFileSync4(dest, ruleContent);
+    filesImported.push(dest);
+  }
+  if (hasClaudeDir) {
+    const claudeRulesDir = resolve4(claudeDir, "rules");
+    if (existsSync4(claudeRulesDir)) {
+      const files = listFiles(claudeRulesDir, { extension: ".md" });
+      for (const file of files) {
+        const dest = join4(rulesDir, basename3(file));
+        copyFileSync3(file, dest);
+        filesImported.push(dest);
+      }
+    }
+    const settingsPath = resolve4(claudeDir, "settings.json");
+    if (existsSync4(settingsPath)) {
+      try {
+        const raw = readFileSync4(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 = join4(packDir, "mcp.json");
+          writeFileSync4(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 = join4(packDir, "pack.json");
+  writeFileSync4(packJsonPath, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(packJsonPath);
+  return { packDir, filesImported, warnings, configGenerated: false };
+}
+
+// src/importers/opencode.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5, copyFileSync as copyFileSync4 } from "fs";
+import { resolve as resolve5, join as join5, basename as basename4 } from "path";
+function importFromOpenCode(projectRoot, outputPackDir) {
+  const warnings = [];
+  const filesImported = [];
+  const ocDir = resolve5(projectRoot, ".opencode");
+  if (!existsSync5(ocDir)) {
+    return {
+      packDir: "",
+      filesImported: [],
+      warnings: ["No .opencode/ directory found."],
+      configGenerated: false
+    };
+  }
+  const packDir = outputPackDir ?? resolve5(projectRoot, "packs", "opencode-import");
+  ensureDir(packDir);
+  importDirMd(resolve5(ocDir, "rules"), resolve5(packDir, "rules"), filesImported);
+  importDirMd(resolve5(ocDir, "commands"), resolve5(packDir, "commands"), filesImported);
+  importDirMd(resolve5(ocDir, "agents"), resolve5(packDir, "agents"), filesImported);
+  const skillDir = resolve5(ocDir, "skill");
+  if (existsSync5(skillDir)) {
+    const outSkillDir = resolve5(packDir, "skills");
+    ensureDir(outSkillDir);
+    const dirs = listDirs(skillDir);
+    for (const dir of dirs) {
+      const name = basename4(dir);
+      if (name.startsWith("."))
+        continue;
+      const skillMd = join5(dir, "SKILL.md");
+      if (existsSync5(skillMd)) {
+        const outDir = join5(outSkillDir, name);
+        ensureDir(outDir);
+        copyFileSync4(skillMd, join5(outDir, "SKILL.md"));
+        filesImported.push(join5(outDir, "SKILL.md"));
+      }
+    }
+  }
+  const pluginsDir = resolve5(ocDir, "plugins");
+  if (existsSync5(pluginsDir)) {
+    const outPluginsDir = resolve5(packDir, "plugins");
+    ensureDir(outPluginsDir);
+    const files = listFiles(pluginsDir);
+    for (const file of files) {
+      if (file.endsWith(".ts") || file.endsWith(".js")) {
+        const dest2 = join5(outPluginsDir, basename4(file));
+        copyFileSync4(file, dest2);
+        filesImported.push(dest2);
+      }
+    }
+  }
+  const agentsMd = resolve5(projectRoot, "AGENTS.md");
+  if (existsSync5(agentsMd)) {
+    const outRulesDir = resolve5(packDir, "rules");
+    ensureDir(outRulesDir);
+    const raw = readFileSync5(agentsMd, "utf-8");
+    const ruleContent = [
+      "---",
+      "root: true",
+      'description: "AGENTS.md root rules"',
+      "---",
+      "",
+      raw
+    ].join(`
+`);
+    const dest2 = join5(outRulesDir, "agents-md-root.md");
+    writeFileSync5(dest2, ruleContent);
+    filesImported.push(dest2);
+  }
+  const ocJson = resolve5(projectRoot, "opencode.json");
+  if (existsSync5(ocJson)) {
+    try {
+      const raw = readFileSync5(ocJson, "utf-8");
+      const config = JSON.parse(raw);
+      const mcpObj = config.mcp;
+      if (mcpObj) {
+        const dest2 = join5(packDir, "mcp.json");
+        writeFileSync5(dest2, JSON.stringify({ servers: mcpObj }, null, 2) + `
+`);
+        filesImported.push(dest2);
+      }
+    } catch {
+      warnings.push("Failed to parse opencode.json");
+    }
+  }
+  const ocIgnore = resolve5(projectRoot, ".opencodeignore");
+  if (existsSync5(ocIgnore)) {
+    copyFileSync4(ocIgnore, join5(packDir, "ignore"));
+    filesImported.push(join5(packDir, "ignore"));
+  }
+  const packJson = {
+    name: "opencode-import",
+    version: "1.0.0",
+    description: "Imported from OpenCode",
+    tags: ["imported", "opencode"],
+    dependencies: [],
+    conflicts: [],
+    targets: "*",
+    features: "*"
+  };
+  const dest = join5(packDir, "pack.json");
+  writeFileSync5(dest, JSON.stringify(packJson, null, 2) + `
+`);
+  filesImported.push(dest);
+  return { packDir, filesImported, warnings, configGenerated: false };
+}
+function importDirMd(srcDir, outDir, filesImported) {
+  if (!existsSync5(srcDir))
+    return;
+  ensureDir(outDir);
+  const files = listFiles(srcDir, { extension: ".md" });
+  for (const file of files) {
+    const dest = join5(outDir, basename4(file));
+    copyFileSync4(file, dest);
+    filesImported.push(dest);
+  }
+}
+
+// src/cli/import-cmd.ts
+import chalk from "chalk";
+function runImport(projectRoot, options) {
+  const { from, output } = options;
+  switch (from) {
+    case "rulesync": {
+      console.log(chalk.dim("Importing from .rulesync/ ..."));
+      const result = importFromRulesync(projectRoot, output);
+      if (result.warnings.length > 0) {
+        for (const w of result.warnings) {
+          console.log(chalk.yellow(`  warn: ${w}`));
+        }
+        return;
+      }
+      console.log(chalk.green(`Imported ${result.filesImported.length} file(s) to ${result.packDir}`));
+      if (result.configGenerated) {
+        console.log(chalk.green("Generated agentpacks.jsonc from rulesync.jsonc"));
+      }
+      console.log(chalk.cyan(`
+Next steps:`), `
+  1. Review the imported pack at`, chalk.bold(result.packDir), `
+  2. Run`, chalk.bold("agentpacks generate"), "to generate tool configs");
+      break;
+    }
+    case "cursor": {
+      console.log(chalk.dim("Importing from .cursor/ ..."));
+      const cursorResult = importFromCursor(projectRoot, output);
+      printImportResult(cursorResult, "Cursor");
+      break;
+    }
+    case "claude":
+    case "claudecode":
+    case "claude-code": {
+      console.log(chalk.dim("Importing from Claude Code..."));
+      const claudeResult = importFromClaudeCode(projectRoot, output);
+      printImportResult(claudeResult, "Claude Code");
+      break;
+    }
+    case "opencode": {
+      console.log(chalk.dim("Importing from .opencode/ ..."));
+      const ocResult = importFromOpenCode(projectRoot, output);
+      printImportResult(ocResult, "OpenCode");
+      break;
+    }
+    default:
+      console.log(chalk.red(`Unknown import source: "${from}"`));
+      console.log(chalk.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(chalk.yellow(`  warn: ${w}`));
+    }
+    return;
+  }
+  for (const w of result.warnings) {
+    console.log(chalk.yellow(`  warn: ${w}`));
+  }
+  console.log(chalk.green(`Imported ${result.filesImported.length} file(s) from ${sourceName} to ${result.packDir}`));
+  console.log(chalk.cyan(`
+Next steps:`), `
+  1. Review the imported pack at`, chalk.bold(result.packDir), `
+  2. Run`, chalk.bold("agentpacks generate"), "to generate tool configs");
+}
+export {
+  runImport
+};

package/dist/cli/init.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initialize a project with agentpacks.
+ * Creates agentpacks.jsonc and a default pack scaffold.
+ */
+export declare function runInit(projectRoot: string): void;