@smicolon/ai-kit 0.3.2 → 0.4.1

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/init.ts
 import { Command } from "commander";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import path6 from "path";
+import path7 from "path";
 
 // src/tools.ts
 var TOOL_REGISTRY = {
@@ -154,29 +154,123 @@ var TOOL_IDS = Object.keys(TOOL_REGISTRY);
 var CANONICAL_SKILLS_DIR = ".agents/skills";
 
 // src/discovery.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/registry.ts
 import fs from "fs";
 import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+var REPO = "smicolon/ai-kit";
+var DEFAULT_BRANCH = "main";
+function getCacheDir() {
+  return path.join(os.homedir(), ".config", "ai-kit", "cache");
+}
+function getRepoDir() {
+  return path.join(getCacheDir(), "repo");
+}
+function getCachedMarketplacePath() {
+  return path.join(getCacheDir(), "marketplace.json");
+}
+function rawUrl(branch, filePath) {
+  return `https://raw.githubusercontent.com/${REPO}/${branch}/${filePath}`;
+}
+function tarballUrl(branch) {
+  return `https://github.com/${REPO}/archive/refs/heads/${branch}.tar.gz`;
+}
+async function fetchMarketplaceRaw(branch) {
+  const url = rawUrl(branch, ".claude-plugin/marketplace.json");
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch marketplace.json: ${res.status} ${res.statusText}`);
+  }
+  return res.text();
+}
+async function downloadRepo(branch) {
+  const cacheDir = getCacheDir();
+  const repoDir = getRepoDir();
+  const tarPath = path.join(cacheDir, "repo.tar.gz");
+  if (fs.existsSync(repoDir)) {
+    fs.rmSync(repoDir, { recursive: true });
+  }
+  fs.mkdirSync(repoDir, { recursive: true });
+  const url = tarballUrl(branch);
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to download repo tarball: ${res.status} ${res.statusText}`);
+  }
+  const buffer = Buffer.from(await res.arrayBuffer());
+  fs.writeFileSync(tarPath, buffer);
+  execSync(`tar xzf "${tarPath}" --strip-components=1 -C "${repoDir}"`, {
+    stdio: "ignore"
+  });
+  fs.unlinkSync(tarPath);
+}
+async function ensureRepo(options = {}) {
+  const branch = options.branch ?? DEFAULT_BRANCH;
+  const cacheDir = getCacheDir();
+  const repoDir = getRepoDir();
+  const cachedMpPath = getCachedMarketplacePath();
+  fs.mkdirSync(cacheDir, { recursive: true });
+  if (options.noCache) {
+    const mpContent = await fetchMarketplaceRaw(branch);
+    await downloadRepo(branch);
+    fs.writeFileSync(cachedMpPath, mpContent);
+    return repoDir;
+  }
+  try {
+    const remoteMp = await fetchMarketplaceRaw(branch);
+    let needsDownload = true;
+    if (fs.existsSync(cachedMpPath) && fs.existsSync(repoDir)) {
+      const cachedMp = fs.readFileSync(cachedMpPath, "utf-8");
+      needsDownload = remoteMp !== cachedMp;
+    }
+    if (needsDownload) {
+      await downloadRepo(branch);
+      fs.writeFileSync(cachedMpPath, remoteMp);
+    }
+    return repoDir;
+  } catch (err) {
+    if (fs.existsSync(repoDir) && fs.existsSync(path.join(repoDir, ".claude-plugin", "marketplace.json"))) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Warning: Could not reach GitHub (${msg}). Using cached packs.`);
+      return repoDir;
+    }
+    throw new Error(
+      "Could not fetch packs from GitHub and no local cache exists. Check your internet connection and try again."
+    );
+  }
+}
+function clearCache() {
+  const cacheDir = getCacheDir();
+  if (fs.existsSync(cacheDir)) {
+    fs.rmSync(cacheDir, { recursive: true });
+  }
+}
+
+// src/discovery.ts
 function findMarketplaceJson(startDir) {
   let dir = startDir;
   while (true) {
-    const candidate = path.join(dir, ".claude-plugin", "marketplace.json");
-    if (fs.existsSync(candidate)) return candidate;
-    const parent = path.dirname(dir);
+    const candidate = path2.join(dir, ".claude-plugin", "marketplace.json");
+    if (fs2.existsSync(candidate)) return candidate;
+    const parent = path2.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function resolvePack(plugin, marketplaceDir) {
-  const sourceDir = path.resolve(marketplaceDir, plugin.source);
-  const resolveFiles = (files) => (files ?? []).map((f) => path.resolve(sourceDir, f));
+  const sourceDir = path2.resolve(marketplaceDir, plugin.source);
+  const resolveFiles = (files) => (files ?? []).map((f) => path2.resolve(sourceDir, f));
   let rules = [];
-  const rulesDir = path.join(sourceDir, "rules");
-  if (fs.existsSync(rulesDir)) {
-    rules = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).map((f) => path.join(rulesDir, f));
+  const rulesDir = path2.join(sourceDir, "rules");
+  if (fs2.existsSync(rulesDir)) {
+    rules = fs2.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).map((f) => path2.join(rulesDir, f));
   }
   const skills = (plugin.skills ?? []).map((s) => {
-    const skillMdPath = path.resolve(sourceDir, s);
-    return path.dirname(skillMdPath);
+    const skillMdPath = path2.resolve(sourceDir, s);
+    return path2.dirname(skillMdPath);
   });
   return {
     name: plugin.name,
@@ -190,39 +284,48 @@ function resolvePack(plugin, marketplaceDir) {
     skills,
     rules,
     hooks: resolveFiles(plugin.hooks),
-    mcpServers: plugin.mcpServers ? path.resolve(sourceDir, plugin.mcpServers) : void 0
+    mcpServers: plugin.mcpServers ? path2.resolve(sourceDir, plugin.mcpServers) : void 0
   };
 }
-function discoverPacks(startDir) {
-  const start = startDir ?? path.dirname(new URL(import.meta.url).pathname);
-  const marketplacePath = findMarketplaceJson(start);
-  if (!marketplacePath) {
+function resolvePacksFromPath(marketplacePath) {
+  const marketplaceDir = path2.dirname(path2.dirname(marketplacePath));
+  const raw = JSON.parse(fs2.readFileSync(marketplacePath, "utf-8"));
+  return raw.plugins.map((p3) => resolvePack(p3, marketplaceDir)).filter((p3) => fs2.existsSync(p3.sourceDir));
+}
+async function discoverPacks(registryOptions) {
+  const start = path2.dirname(new URL(import.meta.url).pathname);
+  const localPath = findMarketplaceJson(start);
+  if (localPath) {
+    return resolvePacksFromPath(localPath);
+  }
+  const repoDir = await ensureRepo(registryOptions);
+  const remotePath = path2.join(repoDir, ".claude-plugin", "marketplace.json");
+  if (!fs2.existsSync(remotePath)) {
     throw new Error(
-      "Could not find .claude-plugin/marketplace.json. Make sure ai-kit is installed correctly."
+      "Could not find .claude-plugin/marketplace.json in cached repo. Try running: ai-kit cache clear"
     );
   }
-  const marketplaceDir = path.dirname(path.dirname(marketplacePath));
-  const raw = JSON.parse(fs.readFileSync(marketplacePath, "utf-8"));
-  return raw.plugins.map((p3) => resolvePack(p3, marketplaceDir)).filter((p3) => fs.existsSync(p3.sourceDir));
+  return resolvePacksFromPath(remotePath);
 }
-function findPack(name, startDir) {
-  return discoverPacks(startDir).find((p3) => p3.name === name);
+async function findPack(name, registryOptions) {
+  const packs = await discoverPacks(registryOptions);
+  return packs.find((p3) => p3.name === name);
 }
 
 // src/config.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var CONFIG_FILE = ".ai-kit.json";
 function configPath(projectDir) {
-  return path2.join(projectDir, CONFIG_FILE);
+  return path3.join(projectDir, CONFIG_FILE);
 }
 function readConfig(projectDir) {
   const fp = configPath(projectDir);
-  if (!fs2.existsSync(fp)) return null;
-  return JSON.parse(fs2.readFileSync(fp, "utf-8"));
+  if (!fs3.existsSync(fp)) return null;
+  return JSON.parse(fs3.readFileSync(fp, "utf-8"));
 }
 function writeConfig(projectDir, config) {
-  fs2.writeFileSync(configPath(projectDir), JSON.stringify(config, null, 2) + "\n");
+  fs3.writeFileSync(configPath(projectDir), JSON.stringify(config, null, 2) + "\n");
 }
 function mergeInstall(config, result) {
   const components = {};
@@ -257,8 +360,8 @@ function createDefaultConfig(tools) {
 }
 
 // src/gitignore.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 var MANAGED_COMMENT = "# AI coding tools (managed by @smicolon/ai-kit)";
 var LOCAL_PATTERNS = [
   ".ai-kit.json",
@@ -268,14 +371,14 @@ var LOCAL_PATTERNS = [
 function findGitRoot(startDir) {
   let dir = startDir;
   while (true) {
-    if (fs3.existsSync(path3.join(dir, ".git"))) return dir;
-    const parent = path3.dirname(dir);
+    if (fs4.existsSync(path4.join(dir, ".git"))) return dir;
+    const parent = path4.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function appendToGitignore(gitignorePath, entries) {
-  const existing = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf-8") : "";
+  const existing = fs4.existsSync(gitignorePath) ? fs4.readFileSync(gitignorePath, "utf-8") : "";
   const lines = existing.split("\n");
   const newEntries = entries.filter(
     (entry) => !lines.some(
@@ -300,29 +403,29 @@ ${newEntries.join("\n")}
 `;
     updated = existing.endsWith("\n") ? existing + block : existing + "\n" + block;
   }
-  fs3.writeFileSync(gitignorePath, updated);
+  fs4.writeFileSync(gitignorePath, updated);
 }
 function updateGitignore(projectDir) {
-  const projectGitignore = path3.join(projectDir, ".gitignore");
+  const projectGitignore = path4.join(projectDir, ".gitignore");
   appendToGitignore(projectGitignore, LOCAL_PATTERNS);
   const gitRoot = findGitRoot(projectDir);
-  if (gitRoot && path3.resolve(gitRoot) !== path3.resolve(projectDir)) {
-    const relFromRoot = path3.relative(gitRoot, projectDir);
+  if (gitRoot && path4.resolve(gitRoot) !== path4.resolve(projectDir)) {
+    const relFromRoot = path4.relative(gitRoot, projectDir);
     const rootEntries = LOCAL_PATTERNS.map(
       (e) => e.startsWith("**/") ? e : `${relFromRoot}/${e}`
     );
-    appendToGitignore(path3.join(gitRoot, ".gitignore"), rootEntries);
+    appendToGitignore(path4.join(gitRoot, ".gitignore"), rootEntries);
   }
 }
 
 // src/installer.ts
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/converters/cursor-mdc.ts
-import fs4 from "fs";
+import fs5 from "fs";
 function convertToMdc(mdFilePath, packName) {
-  const content = fs4.readFileSync(mdFilePath, "utf-8");
+  const content = fs5.readFileSync(mdFilePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(content);
   const paths = frontmatter.paths;
   const globs = paths && paths.length > 0 ? paths.length === 1 ? paths[0] : paths.join(", ") : "";
@@ -377,63 +480,63 @@ function parseFrontmatter(content) {
 var trackedFiles = [];
 var currentProjectDir = "";
 function trackFile(absPath) {
-  trackedFiles.push(path4.relative(currentProjectDir, absPath));
+  trackedFiles.push(path5.relative(currentProjectDir, absPath));
 }
 function ensureDir(dir) {
-  fs5.mkdirSync(dir, { recursive: true });
+  fs6.mkdirSync(dir, { recursive: true });
 }
 function copyFile(src, dest) {
-  ensureDir(path4.dirname(dest));
-  fs5.copyFileSync(src, dest);
+  ensureDir(path5.dirname(dest));
+  fs6.copyFileSync(src, dest);
   trackFile(dest);
 }
 function copyDir(src, dest) {
   ensureDir(dest);
-  for (const entry of fs5.readdirSync(src, { withFileTypes: true })) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
+  for (const entry of fs6.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path5.join(src, entry.name);
+    const destPath = path5.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs5.copyFileSync(srcPath, destPath);
+      fs6.copyFileSync(srcPath, destPath);
       trackFile(destPath);
     }
   }
 }
 function createSymlink(target, linkPath) {
-  ensureDir(path4.dirname(linkPath));
-  if (fs5.existsSync(linkPath)) {
-    const stat = fs5.lstatSync(linkPath);
-    if (stat.isSymbolicLink()) fs5.unlinkSync(linkPath);
+  ensureDir(path5.dirname(linkPath));
+  if (fs6.existsSync(linkPath)) {
+    const stat = fs6.lstatSync(linkPath);
+    if (stat.isSymbolicLink()) fs6.unlinkSync(linkPath);
     else return;
   }
   const type = process.platform === "win32" ? "junction" : void 0;
-  fs5.symlinkSync(target, linkPath, type);
+  fs6.symlinkSync(target, linkPath, type);
   trackFile(linkPath);
 }
 function installSkills(skillDirs, tools, projectDir) {
   if (skillDirs.length === 0 || tools.length === 0) return 0;
   const skillTools = tools.filter((t) => TOOL_REGISTRY[t].components.skills);
   if (skillTools.length === 0) return 0;
-  const canonicalBase = path4.join(projectDir, CANONICAL_SKILLS_DIR);
+  const canonicalBase = path5.join(projectDir, CANONICAL_SKILLS_DIR);
   let count = 0;
   for (const skillDir of skillDirs) {
-    const skillName = path4.basename(skillDir);
-    const canonicalDest = path4.join(canonicalBase, skillName);
-    if (!fs5.existsSync(canonicalDest)) {
+    const skillName = path5.basename(skillDir);
+    const canonicalDest = path5.join(canonicalBase, skillName);
+    if (!fs6.existsSync(canonicalDest)) {
       copyDir(skillDir, canonicalDest);
       count++;
     }
   }
   for (const toolId of skillTools) {
-    const toolSkillsDir = path4.join(projectDir, TOOL_REGISTRY[toolId].skillsDir);
-    if (path4.resolve(toolSkillsDir) === path4.resolve(canonicalBase)) continue;
+    const toolSkillsDir = path5.join(projectDir, TOOL_REGISTRY[toolId].skillsDir);
+    if (path5.resolve(toolSkillsDir) === path5.resolve(canonicalBase)) continue;
     ensureDir(toolSkillsDir);
     for (const skillDir of skillDirs) {
-      const skillName = path4.basename(skillDir);
-      const canonicalDest = path4.join(canonicalBase, skillName);
-      const linkPath = path4.join(toolSkillsDir, skillName);
-      const relTarget = path4.relative(path4.dirname(linkPath), canonicalDest);
+      const skillName = path5.basename(skillDir);
+      const canonicalDest = path5.join(canonicalBase, skillName);
+      const linkPath = path5.join(toolSkillsDir, skillName);
+      const relTarget = path5.relative(path5.dirname(linkPath), canonicalDest);
       createSymlink(relTarget, linkPath);
     }
   }
@@ -444,18 +547,18 @@ function installMdFiles(files, componentType, tools, projectDir, packName) {
   for (const toolId of tools) {
     const targetDir = TOOL_REGISTRY[toolId].components[componentType];
     if (!targetDir) continue;
-    const dest = path4.join(projectDir, targetDir);
+    const dest = path5.join(projectDir, targetDir);
     ensureDir(dest);
     for (const file of files) {
       if (componentType === "rules" && toolId === "cursor") {
         const mdcContent = convertToMdc(file, packName ?? "unknown");
-        const mdcName = path4.basename(file, ".md") + ".mdc";
-        const destPath = path4.join(dest, mdcName);
-        ensureDir(path4.dirname(destPath));
-        fs5.writeFileSync(destPath, mdcContent);
+        const mdcName = path5.basename(file, ".md") + ".mdc";
+        const destPath = path5.join(dest, mdcName);
+        ensureDir(path5.dirname(destPath));
+        fs6.writeFileSync(destPath, mdcContent);
         trackFile(destPath);
       } else {
-        copyFile(file, path4.join(dest, path4.basename(file)));
+        copyFile(file, path5.join(dest, path5.basename(file)));
       }
     }
   }
@@ -465,24 +568,24 @@ function installHooks(hookFiles, tools, projectDir) {
   if (hookFiles.length === 0) return 0;
   if (!tools.includes("claude-code")) return 0;
   let count = 0;
-  const targetHooksDir = path4.join(projectDir, ".claude", "hooks");
+  const targetHooksDir = path5.join(projectDir, ".claude", "hooks");
   for (const hookFile of hookFiles) {
-    if (!fs5.existsSync(hookFile)) continue;
-    const raw = JSON.parse(fs5.readFileSync(hookFile, "utf-8"));
+    if (!fs6.existsSync(hookFile)) continue;
+    const raw = JSON.parse(fs6.readFileSync(hookFile, "utf-8"));
     if (!raw.hooks || Object.keys(raw.hooks).length === 0) continue;
-    const hookSourceDir = path4.dirname(hookFile);
+    const hookSourceDir = path5.dirname(hookFile);
     const scriptFiles = findScriptFiles(hookSourceDir);
     for (const script of scriptFiles) {
-      const relPath = path4.relative(hookSourceDir, script);
-      const destPath = path4.join(targetHooksDir, relPath);
+      const relPath = path5.relative(hookSourceDir, script);
+      const destPath = path5.join(targetHooksDir, relPath);
       copyFile(script, destPath);
-      fs5.chmodSync(destPath, 493);
+      fs6.chmodSync(destPath, 493);
     }
     const rewritten = JSON.stringify(raw.hooks).replace(/\$\{CLAUDE_PLUGIN_ROOT\}\/hooks/g, ".claude/hooks");
-    const projectHooksPath = path4.join(projectDir, ".claude", "hooks.json");
+    const projectHooksPath = path5.join(projectDir, ".claude", "hooks.json");
     let existing = {};
-    if (fs5.existsSync(projectHooksPath)) {
-      const parsed = JSON.parse(fs5.readFileSync(projectHooksPath, "utf-8"));
+    if (fs6.existsSync(projectHooksPath)) {
+      const parsed = JSON.parse(fs6.readFileSync(projectHooksPath, "utf-8"));
       existing = parsed.hooks ?? parsed;
     }
     const newHooks = JSON.parse(rewritten);
@@ -490,8 +593,8 @@ function installHooks(hookFiles, tools, projectDir) {
       if (!existing[event]) existing[event] = [];
       existing[event].push(...handlers);
     }
-    ensureDir(path4.dirname(projectHooksPath));
-    fs5.writeFileSync(
+    ensureDir(path5.dirname(projectHooksPath));
+    fs6.writeFileSync(
       projectHooksPath,
       JSON.stringify({ hooks: existing }, null, 2) + "\n"
     );
@@ -502,9 +605,9 @@ function installHooks(hookFiles, tools, projectDir) {
 }
 function findScriptFiles(dir) {
   const scripts = [];
-  if (!fs5.existsSync(dir)) return scripts;
-  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = path4.join(dir, entry.name);
+  if (!fs6.existsSync(dir)) return scripts;
+  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path5.join(dir, entry.name);
     if (entry.isDirectory()) {
       scripts.push(...findScriptFiles(fullPath));
     } else if (/\.(sh|js|ts)$/.test(entry.name)) {
@@ -545,64 +648,64 @@ function installPack(options) {
 function removePack2(projectDir, files) {
   let removed = 0;
   for (const relFile of files) {
-    const absPath = path4.join(projectDir, relFile);
-    if (!fs5.existsSync(absPath) && !isSymlink(absPath)) continue;
+    const absPath = path5.join(projectDir, relFile);
+    if (!fs6.existsSync(absPath) && !isSymlink(absPath)) continue;
     if (isSymlink(absPath)) {
-      fs5.unlinkSync(absPath);
-    } else if (fs5.statSync(absPath).isDirectory()) {
-      fs5.rmSync(absPath, { recursive: true });
+      fs6.unlinkSync(absPath);
+    } else if (fs6.statSync(absPath).isDirectory()) {
+      fs6.rmSync(absPath, { recursive: true });
     } else {
-      fs5.unlinkSync(absPath);
+      fs6.unlinkSync(absPath);
     }
     removed++;
-    let parent = path4.dirname(absPath);
+    let parent = path5.dirname(absPath);
     while (parent !== projectDir && parent.length > projectDir.length) {
       try {
-        const entries = fs5.readdirSync(parent);
+        const entries = fs6.readdirSync(parent);
         if (entries.length === 0) {
-          fs5.rmdirSync(parent);
+          fs6.rmdirSync(parent);
         } else {
           break;
         }
       } catch {
         break;
       }
-      parent = path4.dirname(parent);
+      parent = path5.dirname(parent);
     }
   }
   return removed;
 }
 function isSymlink(p3) {
   try {
-    return fs5.lstatSync(p3).isSymbolicLink();
+    return fs6.lstatSync(p3).isSymbolicLink();
   } catch {
     return false;
   }
 }
 
 // src/global-config.ts
-import fs6 from "fs";
-import path5 from "path";
-import os from "os";
+import fs7 from "fs";
+import path6 from "path";
+import os2 from "os";
 function getConfigDir() {
-  return path5.join(os.homedir(), ".config", "ai-kit");
+  return path6.join(os2.homedir(), ".config", "ai-kit");
 }
 function getConfigPath() {
-  return path5.join(getConfigDir(), "config.json");
+  return path6.join(getConfigDir(), "config.json");
 }
 function readGlobalConfig() {
   const fp = getConfigPath();
-  if (!fs6.existsSync(fp)) return null;
+  if (!fs7.existsSync(fp)) return null;
   try {
-    return JSON.parse(fs6.readFileSync(fp, "utf-8"));
+    return JSON.parse(fs7.readFileSync(fp, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeGlobalConfig(config) {
   const dir = getConfigDir();
-  fs6.mkdirSync(dir, { recursive: true });
-  fs6.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n");
+  fs7.mkdirSync(dir, { recursive: true });
+  fs7.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n");
 }
 function getGlobalTools() {
   const config = readGlobalConfig();
@@ -613,10 +716,19 @@ function saveGlobalTools(tools) {
   writeGlobalConfig({ ...existing, tools });
 }
 
+// src/global-opts.ts
+var _opts = {};
+function setGlobalRegistryOptions(opts) {
+  _opts = opts;
+}
+function getRegistryOptions() {
+  return _opts;
+}
+
 // src/commands/init.ts
 var initCommand = new Command("init").description("Interactive first-time setup").option("--cwd <dir>", "Project directory (for monorepo sub-packages)").action(async (opts) => {
   p.intro(pc.bgCyan(pc.black(" ai-kit ")));
-  const projectDir = opts.cwd ? path6.resolve(opts.cwd) : process.cwd();
+  const projectDir = opts.cwd ? path7.resolve(opts.cwd) : process.cwd();
   const existing = readConfig(projectDir);
   if (existing) {
     const action = await p.select({
@@ -632,7 +744,58 @@ var initCommand = new Command("init").description("Interactive first-time setup"
       return;
     }
     if (action === "add") {
-      p.outro(`Run ${pc.cyan("ai-kit add <pack>")} to add packs.`);
+      const s2 = p.spinner();
+      let packs2;
+      try {
+        s2.start("Fetching available packs...");
+        packs2 = await discoverPacks(getRegistryOptions());
+        s2.stop("Packs loaded.");
+      } catch {
+        s2.stop("Failed.");
+        p.log.error("Could not fetch packs.");
+        p.outro("Failed.");
+        return;
+      }
+      const installedNames = Object.keys(existing.packs);
+      const available = packs2.filter((pk) => !installedNames.includes(pk.name));
+      if (available.length === 0) {
+        p.outro("All packs are already installed!");
+        return;
+      }
+      const packSelection2 = await p.autocompleteMultiselect({
+        message: "Which packs do you want to add? (type to filter)",
+        options: available.map((pk) => ({
+          value: pk.name,
+          label: pk.name,
+          hint: pk.description
+        })),
+        required: true
+      });
+      if (p.isCancel(packSelection2)) {
+        p.outro("Cancelled.");
+        return;
+      }
+      const selectedNames = packSelection2;
+      const installSpinner2 = p.spinner();
+      installSpinner2.start("Installing packs...");
+      let config2 = existing;
+      const selectedPacks2 = packs2.filter((pk) => selectedNames.includes(pk.name));
+      for (const pack of selectedPacks2) {
+        const result = installPack({
+          pack,
+          tools: existing.tools,
+          projectDir
+        });
+        config2 = mergeInstall(config2, result);
+        config2.packs[pack.name].version = pack.version;
+      }
+      writeConfig(projectDir, config2);
+      updateGitignore(projectDir);
+      installSpinner2.stop("Done!");
+      for (const pack of selectedPacks2) {
+        p.log.message(`  ${pc.green("+")} ${pack.name} ${pc.dim(`v${pack.version}`)}`);
+      }
+      p.outro(`Added ${selectedPacks2.length} pack(s).`);
       return;
     }
   }
@@ -653,10 +816,14 @@ var initCommand = new Command("init").description("Interactive first-time setup"
   }
   const selectedTools = toolSelection;
   saveGlobalTools(selectedTools);
+  const s = p.spinner();
   let packs;
   try {
-    packs = discoverPacks();
+    s.start("Fetching available packs...");
+    packs = await discoverPacks(getRegistryOptions());
+    s.stop("Packs loaded.");
   } catch {
+    s.stop("Failed.");
     p.log.error("Could not find marketplace.json. Is ai-kit installed correctly?");
     p.outro("Setup failed.");
     return;
@@ -708,8 +875,8 @@ var initCommand = new Command("init").description("Interactive first-time setup"
     }
     filter = components;
   }
-  const s = p.spinner();
-  s.start("Installing packs...");
+  const installSpinner = p.spinner();
+  installSpinner.start("Installing packs...");
   let config = createDefaultConfig(selectedTools);
   const selectedPacks = packs.filter((p3) => selectedPackNames.includes(p3.name));
   for (const pack of selectedPacks) {
@@ -723,7 +890,7 @@ var initCommand = new Command("init").description("Interactive first-time setup"
   }
   writeConfig(projectDir, config);
   updateGitignore(projectDir);
-  s.stop("Done!");
+  installSpinner.stop("Done!");
   p.log.success(`Installed ${selectedPacks.length} pack(s) for ${selectedTools.length} tool(s):`);
   for (const pack of selectedPacks) {
     p.log.message(`  ${pc.green("+")} ${pack.name} ${pc.dim(`v${pack.version}`)}`);
@@ -733,7 +900,7 @@ var initCommand = new Command("init").description("Interactive first-time setup"
 
 // src/commands/add.ts
 import { Command as Command2 } from "commander";
-import path7 from "path";
+import path8 from "path";
 import pc2 from "picocolors";
 import * as p2 from "@clack/prompts";
 async function resolveTools(toolsFlag, projectDir) {
@@ -763,10 +930,11 @@ async function resolveTools(toolsFlag, projectDir) {
   return tools;
 }
 var addCommand = new Command2("add").description("Add a pack to your project").argument("<pack>", "Pack name (e.g., django, nextjs)").option("--skills-only", "Only install skills").option("--agents-only", "Only install agents").option("--rules-only", "Only install rules").option("--commands-only", "Only install commands").option("--hooks-only", "Only install hooks").option("--tools <tools>", "Comma-separated tool IDs (overrides config)").option("--cwd <dir>", "Project directory (for monorepo sub-packages)").action(async (packName, opts) => {
-  const projectDir = opts.cwd ? path7.resolve(opts.cwd) : process.cwd();
-  const pack = findPack(packName);
+  const projectDir = opts.cwd ? path8.resolve(opts.cwd) : process.cwd();
+  const registryOpts = getRegistryOptions();
+  const pack = await findPack(packName, registryOpts);
   if (!pack) {
-    const available = discoverPacks().map((p3) => p3.name);
+    const available = (await discoverPacks(registryOpts)).map((p3) => p3.name);
     console.error(
       pc2.red(`Pack "${packName}" not found.`) + "\nAvailable: " + available.join(", ")
     );
@@ -803,7 +971,7 @@ var addCommand = new Command2("add").description("Add a pack to your project").a
 // src/commands/list.ts
 import { Command as Command3 } from "commander";
 import pc3 from "picocolors";
-var listCommand = new Command3("list").description("List available or installed packs").option("--installed", "Show only installed packs").option("--cwd <dir>", "Project directory").action((opts) => {
+var listCommand = new Command3("list").description("List available or installed packs").option("--installed", "Show only installed packs").option("--cwd <dir>", "Project directory").action(async (opts) => {
   const projectDir = opts.cwd ? opts.cwd : process.cwd();
   if (opts.installed) {
     const config2 = readConfig(projectDir);
@@ -822,7 +990,7 @@ ${pc3.dim(`Tools: ${config2.tools.join(", ")}`)}`);
   }
   let packs;
   try {
-    packs = discoverPacks();
+    packs = await discoverPacks(getRegistryOptions());
   } catch {
     console.error(pc3.red("Could not find marketplace.json."));
     process.exit(1);
@@ -851,10 +1019,10 @@ ${pc3.dim(`${packs.length} packs available`)}`);
 
 // src/commands/remove.ts
 import { Command as Command4 } from "commander";
-import path8 from "path";
+import path9 from "path";
 import pc4 from "picocolors";
 var removeCommand = new Command4("remove").description("Remove a pack from your project").argument("<pack>", "Pack name to remove").option("--cwd <dir>", "Project directory").action((packName, opts) => {
-  const projectDir = opts.cwd ? path8.resolve(opts.cwd) : process.cwd();
+  const projectDir = opts.cwd ? path9.resolve(opts.cwd) : process.cwd();
   const config = readConfig(projectDir);
   if (!config) {
     console.log(pc4.dim("No packs installed."));
@@ -881,16 +1049,17 @@ var removeCommand = new Command4("remove").description("Remove a pack from your
 
 // src/commands/update.ts
 import { Command as Command5 } from "commander";
-import path9 from "path";
+import path10 from "path";
 import pc5 from "picocolors";
 var updateCommand = new Command5("update").description("Update installed packs").argument("[pack]", "Pack name (omit to update all)").option("--cwd <dir>", "Project directory").action(async (packName, opts) => {
-  const projectDir = opts.cwd ? path9.resolve(opts.cwd) : process.cwd();
+  const projectDir = opts.cwd ? path10.resolve(opts.cwd) : process.cwd();
   const config = readConfig(projectDir);
   if (!config || Object.keys(config.packs).length === 0) {
     console.log(pc5.dim("No packs installed yet. Starting setup...\n"));
     await initCommand.parseAsync(["init", ...opts.cwd ? ["--cwd", opts.cwd] : []], { from: "user" });
     return;
   }
+  const registryOpts = { ...getRegistryOptions(), noCache: true };
   const packsToUpdate = packName ? [packName] : Object.keys(config.packs);
   let updated = 0;
   let skipped = 0;
@@ -901,7 +1070,7 @@ var updateCommand = new Command5("update").description("Update installed packs")
       skipped++;
       continue;
     }
-    const available = findPack(name);
+    const available = await findPack(name, registryOpts);
     if (!available) {
       console.log(pc5.yellow(`"${name}" not found in marketplace, skipping.`));
       skipped++;
@@ -942,10 +1111,10 @@ Updated ${updated} pack(s).`));
 // src/commands/search.ts
 import { Command as Command6 } from "commander";
 import pc6 from "picocolors";
-var searchCommand = new Command6("search").description("Search available packs by name or keyword").argument("<query>", "Search term (matches name, description, keywords)").action((query) => {
+var searchCommand = new Command6("search").description("Search available packs by name or keyword").argument("<query>", "Search term (matches name, description, keywords)").action(async (query) => {
   let packs;
   try {
-    packs = discoverPacks();
+    packs = await discoverPacks(getRegistryOptions());
   } catch {
     console.error(pc6.red("Could not find marketplace.json."));
     process.exit(1);
@@ -984,12 +1153,28 @@ All packs: ${packs.map((p3) => p3.name).join(", ")}`));
   }
 });
 
+// src/commands/cache.ts
+import { Command as Command7 } from "commander";
+import pc7 from "picocolors";
+var cacheCommand = new Command7("cache").description("Manage cached packs");
+cacheCommand.command("clear").description("Clear cached packs (forces re-download on next run)").action(() => {
+  clearCache();
+  console.log(pc7.green("Cache cleared.") + " Packs will be re-downloaded on next run.");
+});
+
 // src/index.ts
-var program = new Command7().name("ai-kit").description("AI coding tool pack manager").version("0.0.1");
+var program = new Command8().name("ai-kit").description("AI coding tool pack manager").version("0.0.1").option("--no-cache", "Force re-download from GitHub (skip cache check)").option("--branch <branch>", "Use specific branch (default: main)").hook("preAction", () => {
+  const opts = program.opts();
+  setGlobalRegistryOptions({
+    noCache: opts.cache === false,
+    branch: opts.branch
+  });
+});
 program.addCommand(initCommand);
 program.addCommand(addCommand);
 program.addCommand(listCommand);
 program.addCommand(removeCommand);
 program.addCommand(updateCommand);
 program.addCommand(searchCommand);
+program.addCommand(cacheCommand);
 program.parse();