llmstxt-cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -23,23 +23,23 @@ function error(message) {
 function spinner2(_text) {
   const s = p.spinner();
   return {
-    start(text) {
-      s.start(text || _text || "");
+    start(text2) {
+      s.start(text2 || _text || "");
     },
-    stop(text) {
-      s.stop(text || "");
+    stop(text2) {
+      s.stop(text2 || "");
     },
-    succeed(text) {
-      s.stop(`${pc.green("\u2713")} ${text}`);
+    succeed(text2) {
+      s.stop(`${pc.green("\u2713")} ${text2}`);
     },
-    fail(text) {
-      s.stop(`${pc.red("\u2717")} ${text}`);
+    fail(text2) {
+      s.stop(`${pc.red("\u2717")} ${text2}`);
     },
-    info(text) {
-      s.stop(`${pc.blue("\u2139")} ${text}`);
+    info(text2) {
+      s.stop(`${pc.blue("\u2139")} ${text2}`);
     },
-    warn(text) {
-      s.stop(`${pc.yellow("\u26A0")} ${text}`);
+    warn(text2) {
+      s.stop(`${pc.yellow("\u26A0")} ${text2}`);
     }
   };
 }
@@ -6390,6 +6390,9 @@ function searchRegistry(query, categories) {
 function getEntry2(slug) {
   return entries.find((e) => e.slug === slug);
 }
+function getAllEntries(categories) {
+  return categories ? filterByCategories(entries, categories) : entries;
+}
 function resolveSlug(nameOrSlug) {
   const exact = entries.find((e) => e.slug === nameOrSlug);
   if (exact) return exact;
@@ -6401,7 +6404,7 @@ function resolveSlug(nameOrSlug) {
 
 // src/lib/storage.ts
 import { createHash } from "crypto";
-import { appendFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
 
 // src/lib/agents.ts
@@ -6457,7 +6460,7 @@ var agents = [
     displayName: "Antigravity",
     skillsDir: ".agent/skills",
     isUniversal: false,
-    detectInstalled: () => existsSync2(join3(process.cwd(), ".agent")) || existsSync2(join3(home, ".gemini/antigravity"))
+    detectInstalled: () => existsSync2(join3(home, ".gemini/antigravity"))
   },
   {
     name: "augment",
@@ -6485,7 +6488,7 @@ var agents = [
     displayName: "CodeBuddy",
     skillsDir: ".codebuddy/skills",
     isUniversal: false,
-    detectInstalled: () => existsSync2(join3(process.cwd(), ".codebuddy")) || existsSync2(join3(home, ".codebuddy"))
+    detectInstalled: () => existsSync2(join3(home, ".codebuddy"))
   },
   {
     name: "codex",
@@ -6506,7 +6509,7 @@ var agents = [
     displayName: "Continue",
     skillsDir: ".continue/skills",
     isUniversal: false,
-    detectInstalled: () => existsSync2(join3(process.cwd(), ".continue")) || existsSync2(join3(home, ".continue"))
+    detectInstalled: () => existsSync2(join3(home, ".continue"))
   },
   {
     name: "crush",
@@ -6541,7 +6544,7 @@ var agents = [
     displayName: "GitHub Copilot",
     skillsDir: ".agents/skills",
     isUniversal: true,
-    detectInstalled: () => existsSync2(join3(process.cwd(), ".github")) || existsSync2(join3(home, ".copilot"))
+    detectInstalled: () => existsSync2(join3(home, ".copilot"))
   },
   {
     name: "goose",
@@ -6632,7 +6635,7 @@ var agents = [
     displayName: "OpenCode",
     skillsDir: ".agents/skills",
     isUniversal: true,
-    detectInstalled: () => existsSync2(join3(configHome, "opencode")) || existsSync2(join3(claudeHome, "skills"))
+    detectInstalled: () => existsSync2(join3(configHome, "opencode"))
   },
   {
     name: "openhands",
@@ -6753,15 +6756,6 @@ function removeAgentSkill({ projectDir, slug, agent }) {
   } catch {
   }
 }
-function getGitignoreEntries() {
-  const dirs = /* @__PURE__ */ new Set([`${CANONICAL_DIR}/`]);
-  for (const agent of agents) {
-    if (!agent.isUniversal) {
-      dirs.add(`${agent.skillsDir}/`);
-    }
-  }
-  return [...dirs].sort();
-}
 
 // src/lib/storage.ts
 var LLMS_DIR = ".llms";
@@ -6812,7 +6806,8 @@ function installToAgents({
   slug,
   entry,
   content,
-  format
+  format,
+  targetAgents
 }) {
   const checksum = createHash("sha256").update(content).digest("hex");
   const size = Buffer.byteLength(content, "utf-8");
@@ -6827,8 +6822,8 @@ function installToAgents({
     writeFileSync3(join4(canonicalDir, "reference.md"), referenceMd, "utf-8");
   }
   installedAgents.push("universal");
-  const detectedAgents = detectInstalledAgents();
-  for (const agent of detectedAgents) {
+  const agentsToLink = targetAgents ?? detectInstalledAgents();
+  for (const agent of agentsToLink) {
     if (agent.isUniversal) {
       if (!installedAgents.includes(agent.name)) {
         installedAgents.push(agent.name);
@@ -6858,30 +6853,6 @@ function isInstalled({ projectDir, slug }) {
   sanitizeSlug(slug);
   return existsSync3(join4(projectDir, CANONICAL_DIR, slug, "SKILL.md"));
 }
-function addToGitignore(projectDir) {
-  try {
-    const gitignorePath = join4(projectDir, ".gitignore");
-    const gitignoreEntries = [".llms/", ...getGitignoreEntries()];
-    if (existsSync3(gitignorePath)) {
-      const content = readFileSync3(gitignorePath, "utf-8");
-      const missing = gitignoreEntries.filter((e) => !content.includes(e));
-      if (missing.length === 0) return false;
-      appendFileSync(gitignorePath, `
-# llms.txt documentation
-${missing.join("\n")}
-`);
-    } else {
-      writeFileSync3(gitignorePath, `# llms.txt documentation
-${gitignoreEntries.join("\n")}
-`);
-    }
-    return true;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.warn(`Could not update .gitignore: ${msg}`);
-    return false;
-  }
-}
 
 // src/commands/info.ts
 async function info(name) {
@@ -6934,6 +6905,68 @@ ${pc2.dim("Full:")}        ${entry.llmsFullTxtUrl}` : ""}`
 import * as p3 from "@clack/prompts";
 import pc4 from "picocolors";
 
+// src/lib/agent-selection.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
+var PREFS_DIR = ".llms";
+var PREFS_FILE = "agent-prefs.json";
+var DEFAULT_AGENTS = ["claude-code", "cursor", "codex"];
+function detectProjectAgents(opts) {
+  const detected = [];
+  for (const agent of opts.allAgents) {
+    if (agent.isUniversal) continue;
+    const configDir = agent.skillsDir.split("/")[0];
+    if (configDir && configDir !== "skills" && existsSync4(join5(opts.projectDir, configDir))) {
+      detected.push(agent.name);
+    }
+  }
+  return detected;
+}
+function getInitialAgents(opts) {
+  const validNames = new Set(opts.allAgents.map((a) => a.name));
+  if (opts.savedPrefs && opts.savedPrefs.length > 0) {
+    const filtered = opts.savedPrefs.filter((name) => validNames.has(name));
+    if (filtered.length > 0) return filtered;
+  }
+  if (opts.projectDir) {
+    const detected = detectProjectAgents({ projectDir: opts.projectDir, allAgents: opts.allAgents });
+    if (detected.length > 0) return detected;
+  }
+  return DEFAULT_AGENTS.filter((name) => validNames.has(name));
+}
+function ensureUniversalAgents(opts) {
+  const result = [...opts.selected];
+  for (const agent of opts.allAgents) {
+    if (agent.isUniversal && !result.includes(agent.name)) {
+      result.push(agent.name);
+    }
+  }
+  return result;
+}
+function loadSavedAgentPrefs(projectDir) {
+  try {
+    const filePath = join5(projectDir, PREFS_DIR, PREFS_FILE);
+    if (!existsSync4(filePath)) return null;
+    const data = JSON.parse(readFileSync4(filePath, "utf-8"));
+    if (Array.isArray(data.agents)) return data.agents;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveAgentPrefs(projectDir, agentNames) {
+  try {
+    const dir = join5(projectDir, PREFS_DIR);
+    mkdirSync5(dir, { recursive: true });
+    writeFileSync4(
+      join5(dir, PREFS_FILE),
+      JSON.stringify({ agents: agentNames }, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch {
+  }
+}
+
 // src/lib/banner.ts
 import pc3 from "picocolors";
 var BANNER_LINES = [
@@ -6959,18 +6992,18 @@ ${pc3.dim(`  v${version} \xB7 Install llms.txt documentation for AI coding tools
 }
 
 // src/lib/context.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
 var START_MARKER = "<!-- llmstxt:start -->";
 var END_MARKER = "<!-- llmstxt:end -->";
 function syncClaudeMd(projectDir) {
   try {
     const lockfile = readLockfile(projectDir);
     const entries2 = Object.values(lockfile.entries);
-    const claudeMdPath = join5(projectDir, "CLAUDE.md");
+    const claudeMdPath = join6(projectDir, "CLAUDE.md");
     let content = "";
-    if (existsSync4(claudeMdPath)) {
-      content = readFileSync4(claudeMdPath, "utf-8");
+    if (existsSync5(claudeMdPath)) {
+      content = readFileSync5(claudeMdPath, "utf-8");
     }
     const section = buildSection(entries2);
     if (content.includes(START_MARKER)) {
@@ -6993,12 +7026,12 @@ function syncClaudeMd(projectDir) {
         new RegExp(`\\n?${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\\n?`),
         ""
       ).trim();
-      if (content.length === 0 && !existsSync4(claudeMdPath)) {
+      if (content.length === 0 && !existsSync5(claudeMdPath)) {
         return;
       }
     }
-    if (content.length > 0 || existsSync4(claudeMdPath)) {
-      writeFileSync4(claudeMdPath, content.endsWith("\n") ? content : `${content}
+    if (content.length > 0 || existsSync5(claudeMdPath)) {
+      writeFileSync5(claudeMdPath, content.endsWith("\n") ? content : `${content}
 `, "utf-8");
     }
   } catch (err) {
@@ -7026,701 +7059,76 @@ function escapeRegex(s) {
 }
 
 // src/lib/detector.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
-import { join as join6 } from "path";
-
-// data/package-mappings.json
-var package_mappings_default = {
-  version: 1,
-  npm: {
-    agent: "agent",
-    "02aidev": "02aidev",
-    "abstract-api": "abstract-api",
-    aceessayai: "aceessayai",
-    acrcloud: "acrcloud",
-    activepieces: "activepieces",
-    adiacent: "adiacent",
-    "advin-servers": "advin-servers",
-    adx: "adx",
-    "affordable-nvme-ssd-web-hosting-pakistan": "affordable-nvme-ssd-web-hosting-pakistan",
-    aftermath: "aftermath",
-    agentai: "agentai",
-    agentlayer: "agentlayer",
-    agentql: "agentql",
-    agno: "agno",
-    "ai-consulting": "ai-consulting",
-    "ai-dream-scope": "ai-dream-scope",
-    "ai-predict-stock": "ai-predict-stock",
-    "ai-sdk": "ai-sdk",
-    "ai-squared": "ai-squared",
-    aicryptocore: "aicryptocore",
-    akool: "akool",
-    alexopdev: "alexopdev",
-    "all-in": "all-in",
-    "alpha-fi": "alpha-fi",
-    alphagate: "alphagate",
-    altostrat: "altostrat",
-    alva: "alva",
-    amema: "amema",
-    amplemarket: "amplemarket",
-    analog: "analog",
-    annoto: "annoto",
-    answerai: "answerai",
-    "ant-design": "ant-design",
-    anthropic: "anthropic",
-    anytrack: "anytrack",
-    anytype: "anytype",
-    "apex-protocol": "apex-protocol",
-    apibara: "apibara",
-    apify: "apify",
-    aporia: "aporia",
-    appointo: "appointo",
-    appzung: "appzung",
-    "aps-sdks-openapi-specification-aps": "aps-sdks-openapi-specification-aps",
-    aptible: "aptible",
-    arbiscan: "arbiscan",
-    arcade: "arcade",
-    "argil-ai": "argil-ai",
-    "ark-ui": "ark-ui",
-    arpeggi: "arpeggi",
-    artzero: "artzero",
-    asapp: "asapp",
-    "asposewords-product-family": "asposewords-product-family",
-    "ast-grep": "ast-grep",
-    astro: "astro",
-    "augment-code": "augment-code",
-    autentique: "autentique",
-    avaamo: "avaamo",
-    avacloud: "avacloud",
-    "avada-seo-suite": "avada-seo-suite",
-    "avalanche-hvac-services-heating-air": "avalanche-hvac-services-heating-air",
-    avo: "avo",
-    awesomeapi: "awesomeapi",
-    axiom: "axiom",
-    axle: "axle",
-    azumuta: "azumuta",
-    basehub: "basehub",
-    beacon: "beacon",
-    "best-app-development-company": "best-app-development-company",
-    "best-boat-lifts": "best-boat-lifts",
-    "beta-three-professional-audio": "beta-three-professional-audio",
-    "better-auth": "better-auth",
-    beyondwords: "beyondwords",
-    bika: "bika",
-    birdie: "birdie",
-    "bitcoin-cold-storage-tools": "bitcoin-cold-storage-tools",
-    bito: "bito",
-    "bits-ui": "bits-ui",
-    bixgrow: "bixgrow",
-    blacknet: "blacknet",
-    "blue-media-services": "blue-media-services",
-    blueshift: "blueshift",
-    booqable: "booqable",
-    bottalk: "bottalk",
-    braintrust: "braintrust",
-    brandfetch: "brandfetch",
-    "bright-data": "bright-data",
-    browsee: "browsee",
-    bucket: "bucket",
-    bugsplat: "bugsplat",
-    builtwith: "builtwith",
-    bun: "bun",
-    bunny: "bunny",
-    butlr: "butlr",
-    caf: "caf",
-    calcom: "calcom",
-    calendarscripts: "calendarscripts",
-    "callback-technologies": "callback-technologies",
-    campsite: "campsite",
-    captivaterecipes: "captivaterecipes",
-    "car-rental-in-airports-ofgeorgia": "car-rental-in-airports-ofgeorgia",
-    cardknox: "cardknox",
-    carto: "carto",
-    carv: "carv",
-    catizen: "catizen",
-    "cdata-software": "cdata-software",
-    "chakra-ui": "chakra-ui",
-    chargeblast: "chargeblast",
-    chartbeat: "chartbeat",
-    chatbase: "chatbase",
-    chatknow: "chatknow",
-    chatling: "chatling",
-    "checkmate-live": "checkmate-live",
-    "chic-room": "chic-room",
-    "chirp-wireless": "chirp-wireless",
-    "cid-contact": "cid-contact",
-    cipherstash: "cipherstash",
-    circleci: "circleci",
-    citizenshipper: "citizenshipper",
-    citrusad: "citrusad",
-    civic: "civic",
-    "claude-mcp-community": "claude-mcp-community",
-    clerk: "clerk",
-    "clever-cloud": "clever-cloud",
-    cloreai: "cloreai",
-    cloudfix: "cloudfix",
-    cloudflare: "cloudflare",
-    clouve: "clouve",
-    cloverspace: "cloverspace",
-    "cnpjws-api": "cnpjws-api",
-    cobo: "cobo",
-    cobrowse: "cobrowse",
-    codecrafters: "codecrafters",
-    codeium: "codeium",
-    coefont: "coefont",
-    coframe: "coframe",
-    cog: "cog",
-    cohere: "cohere",
-    comforterp: "comforterp",
-    comforthrm: "comforthrm",
-    comfy: "comfy",
-    "commerce-layer": "commerce-layer",
-    "common-ninja": "common-ninja",
-    "community-helm-charts": "community-helm-charts",
-    comparisonator: "comparisonator",
-    "concept-designs-marketing": "concept-designs-marketing",
-    conductor: "conductor",
-    configcat: "configcat",
-    consentik: "consentik",
-    contentsquare: "contentsquare",
-    "contractor-marketing-agency": "contractor-marketing-agency",
-    contravault: "contravault",
-    convex: "convex",
-    coolify: "coolify",
-    coollabs: "coollabs",
-    "copenhagen-art-and-photography": "copenhagen-art-and-photography",
-    "corso-seo-online-certificato": "corso-seo-online-certificato",
-    cosmic: "cosmic",
-    couchdrop: "couchdrop",
-    count: "count",
-    courier: "courier",
-    craftco: "craftco",
-    "cre-data-and-location-intelligence-app": "cre-data-and-location-intelligence-app",
-    "creative-handbook-production-resource-directory": "creative-handbook-production-resource-directory",
-    creatopy: "creatopy",
-    crewai: "crewai",
-    "cross-browser-mobile-app-testing": "cross-browser-mobile-app-testing",
-    cryptlex: "cryptlex",
-    "curling-io": "curling-io",
-    cursor: "cursor",
-    "customer-service-ai-platform": "customer-service-ai-platform",
-    "cyber-security-news": "cyber-security-news",
-    daisyui: "daisyui",
-    dappier: "dappier",
-    dat1co: "dat1co",
-    "data-surfer": "data-surfer",
-    "databuddy-analytics": "databuddy-analytics",
-    datacamp: "datacamp",
-    datafold: "datafold",
-    dataimpulse: "dataimpulse",
-    "datastax-astra-db": "datastax-astra-db",
-    daytona: "daytona",
-    decocx: "decocx",
-    deepconverse: "deepconverse",
-    "demo-time": "demo-time",
-    "deno-documentation": "deno-documentation",
-    deployhq: "deployhq",
-    designmodo: "designmodo",
-    devhub: "devhub",
-    devunus: "devunus",
-    "dexpaprika-api-live-crypto-pool-data": "dexpaprika-api-live-crypto-pool-data",
-    dns0eu: "dns0eu",
-    docetl: "docetl",
-    "docker-docs": "docker-docs",
-    docspring: "docspring",
-    "document-file-translation-powered-by-ai": "document-file-translation-powered-by-ai",
-    donobu: "donobu",
-    "dopp-finance": "dopp-finance",
-    dotenvx: "dotenvx",
-    "drizzle-orm": "drizzle-orm",
-    dub: "dub",
-    duckdb: "duckdb",
-    "duende-software": "duende-software",
-    dynamic: "dynamic",
-    e6data: "e6data",
-    effect: "effect",
-    elevenlabs: "elevenlabs",
-    elysia: "elysia",
-    emailgic: "emailgic",
-    "embed-notion-pages-into-your-website": "embed-notion-pages-into-your-website",
-    embedchain: "embedchain",
-    envoyer: "envoyer",
-    equipment: "equipment",
-    essio: "essio",
-    "expo-documentation": "expo-documentation",
-    fabric: "fabric",
-    facets: "facets",
-    "fantasy-sports-app-development-company": "fantasy-sports-app-development-company",
-    "farcaster-miniapps": "farcaster-miniapps",
-    "feedback-sync": "feedback-sync",
-    fern: "fern",
-    fibery: "fibery",
-    "film-and-screenwriter-school": "film-and-screenwriter-school",
-    finch: "finch",
-    fireproof: "fireproof",
-    "fireworks-ai": "fireworks-ai",
-    firmly: "firmly",
-    flatfile: "flatfile",
-    flipto: "flipto",
-    flows: "flows",
-    flowx: "flowx",
-    "fork-force-australia": "fork-force-australia",
-    formo: "formo",
-    formwerk: "formwerk",
-    fractalpay: "fractalpay",
-    "fraction-ai": "fraction-ai",
-    fragbin: "fragbin",
-    "frank-krav-maga-self-defense-bengaluru": "frank-krav-maga-self-defense-bengaluru",
-    "free-ai-image-generator-maker": "free-ai-image-generator-maker",
-    frigade: "frigade",
-    "front-matter-cms-a-cms-in-your-vs-code-editor": "front-matter-cms-a-cms-in-your-vs-code-editor",
-    "funny-stories-of-horrible-stories": "funny-stories-of-horrible-stories",
-    galileo: "galileo",
-    "game-development-hub": "game-development-hub",
-    gaminator: "gaminator",
-    "gaslighting-check": "gaslighting-check",
-    genaiscript: "genaiscript",
-    "generate-ai-ugc-videos-for-ads": "generate-ai-ugc-videos-for-ads",
-    getinbox: "getinbox",
-    getmarked: "getmarked",
-    giselle: "giselle",
-    glama: "glama",
-    gloodai: "gloodai",
-    glucncom: "glucncom",
-    "gnosis-chain": "gnosis-chain",
-    goody: "goody",
-    gradio: "gradio",
-    "graphite-note": "graphite-note",
-    "greece-vacation-search": "greece-vacation-search",
-    "green-apple-travel-tourism": "green-apple-travel-tourism",
-    groqcloud: "groqcloud",
-    gumlet: "gumlet",
-    helicone: "helicone",
-    "help-for-erectile-dysfunction": "help-for-erectile-dysfunction",
-    "henan-pengfei-pvp-k30-povidone": "henan-pengfei-pvp-k30-povidone",
-    herd: "herd",
-    "heritage-collection": "heritage-collection",
-    heyflow: "heyflow",
-    hola: "hola",
-    home: "home",
-    "home-llms-txt": "home-llms-txt",
-    "home-tz": "home-tz",
-    "home-angular": "home-angular",
-    hono: "hono",
-    hub88: "hub88",
-    hubspot: "hubspot",
-    "hugging-face-accelerate": "hugging-face-accelerate",
-    "hugging-face-diffusers": "hugging-face-diffusers",
-    "hugging-face-hub": "hugging-face-hub",
-    "hugging-face-hub-python-library": "hugging-face-hub-python-library",
-    "hugging-face-transformers": "hugging-face-transformers",
-    "humanity-protocol": "humanity-protocol",
-    hybridai: "hybridai",
-    hyperbeam: "hyperbeam",
-    hyperline: "hyperline",
-    hypermode: "hypermode",
-    hypertune: "hypertune",
-    i3dnet: "i3dnet",
-    "iagent-protocol": "iagent-protocol",
-    icepanel: "icepanel",
-    id21: "id21",
-    ideogram: "ideogram",
-    "ig-exporter": "ig-exporter",
-    illuvium: "illuvium",
-    imaginstudio: "imaginstudio",
-    imagineart: "imagineart",
-    "img-arena": "img-arena",
-    "immortal-rising-2": "immortal-rising-2",
-    infera: "infera",
-    infisical: "infisical",
-    inkeep: "inkeep",
-    inngest: "inngest",
-    inspector: "inspector",
-    "inspira-ui-build-beautiful-websites-using-vue-nuxt": "inspira-ui-build-beautiful-websites-using-vue-nuxt",
-    instant: "instant",
-    instruqt: "instruqt",
-    intelligems: "intelligems",
-    intract: "intract",
-    intuned: "intuned",
-    ionos: "ionos",
-    ionq: "ionq",
-    ipaper: "ipaper",
-    iproyalcom: "iproyalcom",
-    irev: "irev",
-    "island-router": "island-router",
-    jam: "jam",
-    jazztools: "jazztools",
-    journeyapps: "journeyapps",
-    journify: "journify",
-    jsfiddle: "jsfiddle",
-    jumptask: "jumptask",
-    "juniper-creates": "juniper-creates",
-    juno: "juno",
-    "kaisar-network": "kaisar-network",
-    "karrier-one": "karrier-one",
-    keeper: "keeper",
-    ketch: "ketch",
-    kick: "kick",
-    koala: "koala",
-    kruzty: "kruzty",
-    lacremeai: "lacremeai",
-    lago: "lago",
-    lambdatest: "lambdatest",
-    "langchain-javascript-docs": "langchain-javascript-docs",
-    "langchain-python-docs": "langchain-python-docs",
-    langflow: "langflow",
-    langfuse: "langfuse",
-    "langgraph-javascript-docs": "langgraph-javascript-docs",
-    "langgraph-python-docs": "langgraph-python-docs",
-    launchfast: "launchfast",
-    lavita: "lavita",
-    "law-firm-digital-marketing-agency": "law-firm-digital-marketing-agency",
-    layouthub: "layouthub",
-    "leather-jackets-coats-for-men-women": "leather-jackets-coats-for-men-women",
-    legend: "legend",
-    "legend-state": "legend-state",
-    "legends-of-learning": "legends-of-learning",
-    legitt: "legitt",
-    lettermint: "lettermint",
-    "liam-erd": "liam-erd",
-    liblab: "liblab",
-    libmodulor: "libmodulor",
-    likec4: "likec4",
-    linktree: "linktree",
-    litdb: "litdb",
-    liveblocks: "liveblocks",
-    livecaller: "livecaller",
-    livecodes: "livecodes",
-    livespotting: "livespotting",
-    "llms-txtio": "llms-txtio",
-    llmstxt: "llmstxt",
-    llmvo: "llmvo",
-    "lm-studio": "lm-studio",
-    lobehub: "lobehub",
-    loglayer: "loglayer",
-    loops: "loops",
-    "lots-of-csvs": "lots-of-csvs",
-    lottielab: "lottielab",
-    lunacy: "lunacy",
-    luxalgo: "luxalgo",
-    luxid: "luxid",
-    lynx: "lynx",
-    mailmodo: "mailmodo",
-    mako: "mako",
-    mangopay: "mangopay",
-    "manifestly-checklists": "manifestly-checklists",
-    "marco-ronco-seo-specialist": "marco-ronco-seo-specialist",
-    marimo: "marimo",
-    "marketing-doctors": "marketing-doctors",
-    "marketing-integration-and-automation": "marketing-integration-and-automation",
-    massive: "massive",
-    mastory: "mastory",
-    mastra: "mastra",
-    "material-ui-aka-mui": "material-ui-aka-mui",
-    "maxim-ai": "maxim-ai",
-    "mdutil-free-markdown-tools": "mdutil-free-markdown-tools",
-    mealbymeal: "mealbymeal",
-    "meds-canada": "meds-canada",
-    medusa: "medusa",
-    meilisearch: "meilisearch",
-    "mekalite-cnc-machining-services": "mekalite-cnc-machining-services",
-    meshconnect: "meshconnect",
-    "method-financial": "method-financial",
-    micro1: "micro1",
-    mintlify: "mintlify",
-    mixo: "mixo",
-    "model-context-protocol-mcp": "model-context-protocol-mcp",
-    "monster-ui": "monster-ui",
-    moondream: "moondream",
-    "morphic-solutions": "morphic-solutions",
-    movehealth: "movehealth",
-    "mubashir-hassan": "mubashir-hassan",
-    "mui-x-advanced-react-components-for-complex-use-cases": "mui-x-advanced-react-components-for-complex-use-cases",
-    multiplier: "multiplier",
-    multisynq: "multisynq",
-    mux: "mux",
-    "mystery-o-matic": "mystery-o-matic",
-    nash: "nash",
-    nativescript: "nativescript",
-    navi: "navi",
-    "naviga-global": "naviga-global",
-    "needle-cloud": "needle-cloud",
-    netlify: "netlify",
-    nextevo: "nextevo",
-    nextevogroup: "nextevogroup",
-    "nile-postgres": "nile-postgres",
-    nomadhelperai: "nomadhelperai",
-    "nonprofit-management-consulting": "nonprofit-management-consulting",
-    "novi-labs": "novi-labs",
-    nsoftware: "nsoftware",
-    nuxt: "nuxt",
-    "omnimind-docs-oss-mcp-client": "omnimind-docs-oss-mcp-client",
-    onagentsorg: "onagentsorg",
-    "once-ui": "once-ui",
-    onetrust: "onetrust",
-    openfort: "openfort",
-    openphone: "openphone",
-    openpipe: "openpipe",
-    openrouter: "openrouter",
-    "openvpn-zero-trust-vpn": "openvpn-zero-trust-vpn",
-    "opik-by-comet": "opik-by-comet",
-    "optimajet-form-builder": "optimajet-form-builder",
-    oxla: "oxla",
-    papergraderpro: "papergraderpro",
-    paragon: "paragon",
-    "parcelcube-static-dimensioning-systems": "parcelcube-static-dimensioning-systems",
-    parseable: "parseable",
-    pastaclean: "pastaclean",
-    payperfax: "payperfax",
-    payrollrabbit: "payrollrabbit",
-    "pentesting-red-teaming-company": "pentesting-red-teaming-company",
-    perplexity: "perplexity",
-    "personal-page": "personal-page",
-    "petite-box": "petite-box",
-    pgflow: "pgflow",
-    phare: "phare",
-    pikaicons: "pikaicons",
-    pinata: "pinata",
-    pinecone: "pinecone",
-    plain: "plain",
-    "plan-harmony-travel-planning": "plan-harmony-travel-planning",
-    platformsh: "platformsh",
-    playai: "playai",
-    popsmash: "popsmash",
-    postfast: "postfast",
-    preact: "preact",
-    prettier: "prettier",
-    primev: "primev",
-    prisma: "prisma",
-    profound: "profound",
-    progressrocks: "progressrocks",
-    "proguard-pest-control": "proguard-pest-control",
-    projectdiscovery: "projectdiscovery",
-    "prompt-kit": "prompt-kit",
-    promptfoo: "promptfoo",
-    pydantic: "pydantic",
-    pydanticai: "pydanticai",
-    qrcoau: "qrcoau",
-    quill: "quill",
-    qwikrank: "qwikrank",
-    rainbowkit: "rainbowkit",
-    raincamp: "raincamp",
-    rankscaleai: "rankscaleai",
-    rapidtextai: "rapidtextai",
-    raycast: "raycast",
-    rcponline: "rcponline",
-    redpanda: "redpanda",
-    rememberizer: "rememberizer",
-    remotion: "remotion",
-    remult: "remult",
-    render: "render",
-    reown: "reown",
-    replit: "replit",
-    resend: "resend",
-    respondio: "respondio",
-    retainful: "retainful",
-    "ri-xu-online": "ri-xu-online",
-    "rims-tires-for-cars-and-trucks": "rims-tires-for-cars-and-trucks",
-    roc: "roc",
-    rsbuild: "rsbuild",
-    rsdoctor: "rsdoctor",
-    rslib: "rslib",
-    rspack: "rspack",
-    rubric: "rubric",
-    "ruleta-aleatoria-online-gratis": "ruleta-aleatoria-online-gratis",
-    rushdb: "rushdb",
-    saev: "saev",
-    salesbricks: "salesbricks",
-    "salesforce-marketing-cloud-consultants": "salesforce-marketing-cloud-consultants",
-    "samsung-food": "samsung-food",
-    sandisk: "sandisk",
-    sardine: "sardine",
-    "scottish-art-prints-by-carol-mcewan": "scottish-art-prints-by-carol-mcewan",
-    "scraping-proxies": "scraping-proxies",
-    screenshotone: "screenshotone",
-    sealos: "sealos",
-    "secure-fast-online-money-transfers": "secure-fast-online-money-transfers",
-    sekhlopk: "sekhlopk",
-    self: "self",
-    sellersprite: "sellersprite",
-    semgrep: "semgrep",
-    seo2llm: "seo2llm",
-    servicestack: "servicestack",
-    sgnlai: "sgnlai",
-    sherlock: "sherlock",
-    "shop-positioner-llc": "shop-positioner-llc",
-    "side-space": "side-space",
-    simplepdf: "simplepdf",
-    sinch: "sinch",
-    "singing-carrots": "singing-carrots",
-    sitespeakai: "sitespeakai",
-    skipgo: "skipgo",
-    "sky-follower-bridge": "sky-follower-bridge",
-    skydeckai: "skydeckai",
-    "skyworkthe-ai-workspace-agents": "skyworkthe-ai-workspace-agents",
-    smartcar: "smartcar",
-    social: "social",
-    socialityio: "socialityio",
-    solid: "solid",
-    sourcegraph: "sourcegraph",
-    spacetimedb: "spacetimedb",
-    speakeasy: "speakeasy",
-    starwind: "starwind",
-    statusfield: "statusfield",
-    stedi: "stedi",
-    "stephanie-kabi": "stephanie-kabi",
-    "stock-trading-investment-app": "stock-trading-investment-app",
-    stripe: "stripe",
-    "study-fetch": "study-fetch",
-    "sunra-ai": "sunra-ai",
-    supabase: "supabase",
-    supadata: "supadata",
-    superwall: "superwall",
-    svelte: "svelte",
-    "svg-viewer": "svg-viewer",
-    "swipe-simple-invoicing-and-payments-app": "swipe-simple-invoicing-and-payments-app",
-    tamagui: "tamagui",
-    "taskade-ai": "taskade-ai",
-    tavus: "tavus",
-    "tlassistance-snior": "tlassistance-snior",
-    televisionai: "televisionai",
-    tensorzero: "tensorzero",
-    "the-ai-engineers-handbook": "the-ai-engineers-handbook",
-    "the-bucket-hat": "the-bucket-hat",
-    "the-crawl-tool": "the-crawl-tool",
-    "the-data-driven-marketer": "the-data-driven-marketer",
-    "the-dinner-detective-murder-mystery-show": "the-dinner-detective-murder-mystery-show",
-    theirstack: "theirstack",
-    "therapydave-dave-lechnyr-lcsw": "therapydave-dave-lechnyr-lcsw",
-    tidb: "tidb",
-    tidio: "tidio",
-    tinybird: "tinybird",
-    tiptap: "tiptap",
-    toriut: "toriut",
-    trackingplan: "trackingplan",
-    trackvia: "trackvia",
-    "trail-of-bits": "trail-of-bits",
-    transloadit: "transloadit",
-    "travel-nepal": "travel-nepal",
-    triggerdev: "triggerdev",
-    triplit: "triplit",
-    trueprofit: "trueprofit",
-    truffle: "truffle",
-    turbo: "turbo",
-    turbodocx: "turbodocx",
-    turso: "turso",
-    "twicpics-by-frontify": "twicpics-by-frontify",
-    twoshoes: "twoshoes",
-    "ufc-velvet": "ufc-velvet",
-    "uminai-mcp": "uminai-mcp",
-    underrunio: "underrunio",
-    unifygtm: "unifygtm",
-    unistyles: "unistyles",
-    uniwebview: "uniwebview",
-    unkey: "unkey",
-    unstructured: "unstructured",
-    upstash: "upstash",
-    "upstreet-ai": "upstreet-ai",
-    upsun: "upsun",
-    useapinet: "useapinet",
-    "utrecht-golf-instructor-marina-romanik": "utrecht-golf-instructor-marina-romanik",
-    "ux-patterns-for-devs": "ux-patterns-for-devs",
-    vald: "vald",
-    "vald-health": "vald-health",
-    vapi: "vapi",
-    vdoninja: "vdoninja",
-    velt: "velt",
-    vendure: "vendure",
-    veniceai: "veniceai",
-    ventrata: "ventrata",
-    "vercel-ai-sdk": "vercel-ai-sdk",
-    verdn: "verdn",
-    "video-and-audio-frameworks-for-net": "video-and-audio-frameworks-for-net",
-    videosdklive: "videosdklive",
-    videowise: "videowise",
-    viem: "viem",
-    "vignette-id": "vignette-id",
-    vital: "vital",
-    "voxel-busters": "voxel-busters",
-    "voyager-shuffle": "voyager-shuffle",
-    vplayed: "vplayed",
-    "vue-macros": "vue-macros",
-    vuejs: "vuejs",
-    wandio: "wandio",
-    warp: "warp",
-    weathercom: "weathercom",
-    "web-design-company-qatar": "web-design-company-qatar",
-    "web-development-wordpress-maintenance": "web-development-wordpress-maintenance",
-    webrecorder: "webrecorder",
-    "wedgwood-insurance": "wedgwood-insurance",
-    weka: "weka",
-    "welcome-to-bunny": "welcome-to-bunny",
-    "welcome-to-htmlhint": "welcome-to-htmlhint",
-    "wf-content-creator-platform": "wf-content-creator-platform",
-    whereby: "whereby",
-    "wild-in-africa": "wild-in-africa",
-    wized: "wized",
-    wonderchat: "wonderchat",
-    woowup: "woowup",
-    wordlift: "wordlift",
-    workbookly: "workbookly",
-    workflow: "workflow",
-    "wot-design-uni": "wot-design-uni",
-    writer: "writer",
-    wxt: "wxt",
-    x: "x",
-    "x-cmd": "x-cmd",
-    xmcp: "xmcp",
-    xomatic: "xomatic",
-    yamlresume: "yamlresume",
-    youform: "youform",
-    zag: "zag",
-    zapts: "zapts",
-    "zaphyr-php-framework": "zaphyr-php-framework",
-    zapier: "zapier",
-    zeffy: "zeffy",
-    zenml: "zenml",
-    zep: "zep",
-    zigpoll: "zigpoll",
-    zipchat: "zipchat",
-    zipy: "zipy",
-    zodori: "zodori",
-    zoko: "zoko",
-    "zoomryconveyorshiploader-manufacturer": "zoomryconveyorshiploader-manufacturer"
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+function normalize(name) {
+  return name.toLowerCase().replace(/[-_./]/g, "");
+}
+function extractTokens(dep) {
+  const tokens = [];
+  const unscoped = dep.startsWith("@") ? dep.slice(1) : dep;
+  tokens.push(unscoped);
+  if (dep.startsWith("@") && unscoped.includes("/")) {
+    const [scope, pkg] = unscoped.split("/");
+    tokens.push(pkg);
+    tokens.push(scope);
+    const cleanScope = scope.replace(/js$/, "").replace(/-ai$/, "");
+    if (cleanScope !== scope) tokens.push(cleanScope);
   }
-};
-
-// src/lib/detector.ts
+  for (const suffix of ["-js", "-sdk", "-client", "-core", "-cli", "-types"]) {
+    if (dep.endsWith(suffix)) {
+      tokens.push(dep.slice(0, -suffix.length));
+    }
+  }
+  return tokens;
+}
+function matchesEntry(dep, entry) {
+  const tokens = extractTokens(dep);
+  const entrySlug = entry.slug.toLowerCase();
+  const entryName = normalize(entry.name);
+  for (const token of tokens) {
+    const norm = normalize(token);
+    if (norm === entrySlug) return true;
+    if (norm === entryName) return true;
+    if (entrySlug === norm) return true;
+    if (entryName.startsWith(norm) && norm.length >= 3) return true;
+  }
+  return false;
+}
 function detectFromPackageJson(projectDir) {
-  const pkgPath = join6(projectDir, "package.json");
-  if (!existsSync5(pkgPath)) return [];
+  const pkgPath = join7(projectDir, "package.json");
+  if (!existsSync6(pkgPath)) return [];
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+    pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
   } catch {
     return [];
   }
-  const allDeps = {
+  const depNames = Object.keys({
     ...pkg.dependencies,
     ...pkg.devDependencies
-  };
-  const mappings = package_mappings_default;
+  });
+  if (depNames.length === 0) return [];
+  const entries2 = getAllEntries();
   const matchesBySlug = /* @__PURE__ */ new Map();
-  for (const depName of Object.keys(allDeps)) {
-    const slug = mappings.npm[depName];
-    if (!slug) continue;
-    const existing = matchesBySlug.get(slug) || [];
-    existing.push(depName);
-    matchesBySlug.set(slug, existing);
-  }
-  const results = [];
-  for (const [slug, matchedPackages] of matchesBySlug) {
-    const registryEntry = getEntry2(slug);
-    if (registryEntry) {
-      results.push({ slug, matchedPackages, registryEntry });
+  for (const dep of depNames) {
+    for (const entry of entries2) {
+      if (matchesEntry(dep, entry)) {
+        const existing = matchesBySlug.get(entry.slug);
+        if (existing) {
+          existing.deps.push(dep);
+        } else {
+          matchesBySlug.set(entry.slug, { deps: [dep], entry });
+        }
+        break;
+      }
     }
   }
-  return results;
+  return [...matchesBySlug.values()].map(({ deps, entry }) => ({
+    slug: entry.slug,
+    matchedPackages: deps,
+    registryEntry: entry
+  }));
 }
 function filterMatchesByCategories(matches, categories) {
   if (categories.length === 0) return matches;
@@ -7832,12 +7240,12 @@ async function fetchLlmsTxt({ url, existingEtag }) {
     if (contentLength && Number.parseInt(contentLength, 10) > MAX_SIZE) {
       throw new Error(`Response too large (${contentLength} bytes, max ${MAX_SIZE})`);
     }
-    const text = await response.text();
-    if (text.length > MAX_SIZE) {
-      throw new Error(`Response too large (${text.length} bytes, max ${MAX_SIZE})`);
+    const text2 = await response.text();
+    if (text2.length > MAX_SIZE) {
+      throw new Error(`Response too large (${text2.length} bytes, max ${MAX_SIZE})`);
     }
     return {
-      content: text,
+      content: text2,
       etag: response.headers.get("etag"),
       lastModified: response.headers.get("last-modified"),
       notModified: false
@@ -7849,7 +7257,7 @@ async function fetchLlmsTxt({ url, existingEtag }) {
 
 // src/lib/telemetry.ts
 var TELEMETRY_ENDPOINT = "https://llmstxt.directory/api/cli/telemetry";
-var CLI_VERSION = "0.2.0";
+var CLI_VERSION = "0.4.0";
 var CI_ENV_VARS = ["CI", "GITHUB_ACTIONS", "GITLAB_CI", "CIRCLECI", "TRAVIS"];
 function isDisabled() {
   return process.env.DO_NOT_TRACK === "1" || process.env.LLMSTXT_TELEMETRY_DISABLED === "1";
@@ -7876,27 +7284,13 @@ function track(params) {
 async function init(options) {
   const projectDir = process.cwd();
   const isInteractive = process.stdin.isTTY && !options.yes;
-  printBanner("0.2.0");
+  printBanner("0.4.0");
   p3.intro("Install llms.txt documentation for your project");
   const spin = spinner2("Loading registry...");
   spin.start();
   await loadRegistry();
   spin.succeed("Registry loaded");
   const agents2 = detectInstalledAgents();
-  if (agents2.length > 0) {
-    p3.log.info(`Detected agents: ${agents2.map((a) => pc4.cyan(a.displayName)).join(", ")}`);
-  } else {
-    p3.log.warn("No AI coding tools detected \u2014 files will be installed to .agents/skills/ only");
-  }
-  const spin2 = spinner2("Detecting project dependencies...");
-  spin2.start();
-  let matches = detectFromPackageJson(projectDir);
-  if (matches.length === 0) {
-    spin2.info("No matching llms.txt entries found for your dependencies");
-    p3.log.message(pc4.dim("Try `llmstxt search <query>` to find entries manually"));
-    p3.outro("No skills to install.");
-    return;
-  }
   let activeCategories;
   if (options.allCategories) {
     activeCategories = [];
@@ -7905,95 +7299,223 @@ async function init(options) {
   } else {
     activeCategories = [...PRIMARY_CATEGORIES];
   }
+  let depMatches = detectFromPackageJson(projectDir);
   if (activeCategories.length > 0) {
-    matches = filterMatchesByCategories(matches, activeCategories);
+    depMatches = filterMatchesByCategories(depMatches, activeCategories);
+  }
+  const depSlugs = new Set(depMatches.map((m) => m.slug));
+  if (depMatches.length > 0) {
+    p3.log.info(
+      `Found ${depMatches.length} matching your dependencies: ${depMatches.map((m) => pc4.cyan(m.registryEntry.name)).join(", ")}`
+    );
   }
-  if (matches.length === 0) {
-    spin2.info("No matching entries in selected categories");
-    p3.log.message(pc4.dim("Try `llmstxt init --all-categories` to include all categories"));
-    p3.outro("No skills to install.");
+  if (!isInteractive) {
+    return installEntries({
+      projectDir,
+      entries: depMatches.map((m) => m.registryEntry),
+      options,
+      agents: agents2,
+      targetAgents: agents2
+    });
+  }
+  const selectedEntries = await browseAndSelect({ projectDir, depMatches, depSlugs });
+  if (selectedEntries.length === 0) {
+    p3.outro("No skills selected.");
     return;
   }
-  spin2.succeed(`Found ${matches.length} matching entries`);
-  if (options.dryRun) {
-    for (const match of matches) {
-      const already = isInstalled({ projectDir, slug: match.slug });
-      const status = already ? pc4.dim(" (already installed)") : "";
-      p3.log.message(`  ${pc4.cyan(match.registryEntry.name)}${status}`);
-    }
-    p3.outro("Dry run \u2014 no files were written");
+  const targetAgents = await pickAgents(projectDir);
+  if (!targetAgents) {
+    p3.cancel("Installation cancelled.");
     return;
   }
-  let selectedSlugs;
-  if (isInteractive) {
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const match of matches) {
-      const cat = match.registryEntry.category;
-      const group = byCategory.get(cat) || [];
-      group.push(match);
-      byCategory.set(cat, group);
-    }
-    const options_list = [];
-    for (const [category, group] of byCategory) {
-      for (const match of group) {
-        const already = isInstalled({ projectDir, slug: match.slug });
-        options_list.push({
-          value: match.slug,
-          label: match.registryEntry.name,
-          hint: already ? "already installed" : `${category} \xB7 matched: ${match.matchedPackages.join(", ")}`
-        });
-      }
-    }
-    const selected = await p3.multiselect({
-      message: "Select skills to install:",
-      options: options_list,
-      initialValues: matches.filter((m) => !isInstalled({ projectDir, slug: m.slug })).map((m) => m.slug),
-      required: false
+  const format = await pickFormat(selectedEntries, options);
+  if (!format) {
+    p3.cancel("Installation cancelled.");
+    return;
+  }
+  return installEntries({
+    projectDir,
+    entries: selectedEntries,
+    options: { ...options, full: format === "llms-full.txt" },
+    agents: agents2,
+    targetAgents
+  });
+}
+async function browseAndSelect({
+  projectDir,
+  depMatches,
+  depSlugs
+}) {
+  const selectedEntries = [];
+  while (true) {
+    const action = await p3.select({
+      message: selectedEntries.length === 0 ? "How would you like to find llms.txt documentation?" : `${selectedEntries.length} selected. Add more or install?`,
+      options: [
+        ...depMatches.length > 0 && selectedEntries.length === 0 ? [
+          {
+            value: "suggestions",
+            label: `Suggested from dependencies (${depMatches.length} found)`,
+            hint: depMatches.map((m) => m.registryEntry.name).join(", ")
+          }
+        ] : [],
+        { value: "browse", label: "Browse by category" },
+        { value: "search", label: "Search by name" },
+        ...selectedEntries.length > 0 ? [{ value: "install", label: `Install ${selectedEntries.length} selected` }] : [],
+        { value: "done", label: selectedEntries.length > 0 ? "Cancel" : "Exit" }
+      ]
     });
-    if (p3.isCancel(selected)) {
-      p3.cancel("Installation cancelled.");
-      process.exitCode = 0;
-      return;
+    if (p3.isCancel(action) || action === "done") {
+      if (selectedEntries.length > 0) p3.cancel("Installation cancelled.");
+      else p3.outro("No skills selected.");
+      return [];
     }
-    selectedSlugs = new Set(selected);
-    if (selectedSlugs.size === 0) {
-      p3.outro("No skills selected.");
-      return;
+    if (action === "install") break;
+    let picked = [];
+    if (action === "suggestions") {
+      picked = await pickFromList(
+        depMatches.map((m) => m.registryEntry),
+        projectDir,
+        depSlugs
+      );
+    } else if (action === "browse") {
+      picked = await browseByCategory(projectDir, depSlugs);
+    } else if (action === "search") {
+      picked = await searchByName(projectDir, depSlugs);
     }
-    const shouldContinue = await p3.confirm({
-      message: `Install ${selectedSlugs.size} skill(s)?`
-    });
-    if (p3.isCancel(shouldContinue) || !shouldContinue) {
-      p3.cancel("Installation cancelled.");
-      process.exitCode = 0;
-      return;
+    for (const entry of picked) {
+      if (!selectedEntries.some((e) => e.slug === entry.slug)) {
+        selectedEntries.push(entry);
+      }
     }
-  } else {
-    selectedSlugs = new Set(
-      matches.filter((m) => !isInstalled({ projectDir, slug: m.slug })).map((m) => m.slug)
-    );
-    if (!process.stdin.isTTY) {
-      p3.log.message(pc4.dim("Non-interactive mode. Use -y to skip prompts."));
+  }
+  return selectedEntries;
+}
+async function browseByCategory(projectDir, depSlugs) {
+  const allEntries = getAllEntries();
+  const categoryMap = /* @__PURE__ */ new Map();
+  for (const entry of allEntries) {
+    categoryMap.set(entry.category, (categoryMap.get(entry.category) || 0) + 1);
+  }
+  const categoryChoice = await p3.select({
+    message: "Select a category:",
+    options: [...categoryMap.entries()].sort((a, b) => b[1] - a[1]).map(([cat, count]) => ({
+      value: cat,
+      label: cat,
+      hint: `${count} entries`
+    }))
+  });
+  if (p3.isCancel(categoryChoice)) return [];
+  const categoryEntries = allEntries.filter((e) => e.category === categoryChoice);
+  return pickFromList(categoryEntries, projectDir, depSlugs);
+}
+async function searchByName(projectDir, depSlugs) {
+  const query = await p3.text({
+    message: "Search for:",
+    placeholder: "e.g. react, stripe, prisma..."
+  });
+  if (p3.isCancel(query) || !query) return [];
+  const results = searchRegistry(query).slice(0, 20);
+  if (results.length === 0) {
+    p3.log.warn(`No results for "${query}"`);
+    return [];
+  }
+  return pickFromList(results, projectDir, depSlugs);
+}
+async function pickFromList(entries2, projectDir, depSlugs) {
+  const optionsList = entries2.map((entry) => {
+    const already = isInstalled({ projectDir, slug: entry.slug });
+    const isDep = depSlugs.has(entry.slug);
+    const hints = [];
+    if (already) hints.push("installed");
+    if (isDep) hints.push("in your deps");
+    hints.push(entry.category);
+    return {
+      value: entry.slug,
+      label: entry.name,
+      hint: hints.join(" \xB7 ")
+    };
+  });
+  const selected = await p3.multiselect({
+    message: `Select entries (${entries2.length} available):`,
+    options: optionsList,
+    required: false
+  });
+  if (p3.isCancel(selected)) return [];
+  const slugSet = new Set(selected);
+  return entries2.filter((e) => slugSet.has(e.slug));
+}
+async function pickFormat(entries2, options) {
+  if (options.full) return "llms-full.txt";
+  const hasFullAvailable = entries2.some((e) => e.llmsFullTxtUrl);
+  if (!hasFullAvailable) return "llms.txt";
+  const fullCount = entries2.filter((e) => e.llmsFullTxtUrl).length;
+  const choice = await p3.select({
+    message: "Which documentation format?",
+    options: [
+      {
+        value: "llms.txt",
+        label: "llms.txt",
+        hint: "concise \u2014 smaller, faster to load"
+      },
+      {
+        value: "llms-full.txt",
+        label: "llms-full.txt",
+        hint: `comprehensive \u2014 ${fullCount}/${entries2.length} selected have full version`
+      }
+    ]
+  });
+  if (p3.isCancel(choice)) return null;
+  return choice;
+}
+async function pickAgents(projectDir) {
+  const savedPrefs = loadSavedAgentPrefs(projectDir);
+  const initialValues = getInitialAgents({ allAgents: agents, savedPrefs, projectDir });
+  const selected = await p3.multiselect({
+    message: "Which agents should receive the skills?",
+    options: agents.map((a) => ({
+      value: a.name,
+      label: a.displayName,
+      hint: a.isUniversal ? "always included" : a.skillsDir
+    })),
+    initialValues,
+    required: true
+  });
+  if (p3.isCancel(selected)) return null;
+  const finalNames = ensureUniversalAgents({ selected, allAgents: agents });
+  saveAgentPrefs(projectDir, selected);
+  const nameSet = new Set(finalNames);
+  return agents.filter((a) => nameSet.has(a.name));
+}
+async function installEntries({
+  projectDir,
+  entries: entries2,
+  options,
+  agents: agents2,
+  targetAgents
+}) {
+  if (options.dryRun) {
+    for (const entry of entries2) {
+      const already = isInstalled({ projectDir, slug: entry.slug });
+      const status = already ? pc4.dim(" (already installed)") : "";
+      p3.log.message(`  ${pc4.cyan(entry.name)}${status}`);
     }
+    p3.outro("Dry run \u2014 no files were written");
+    return;
   }
   const format = options.full ? "llms-full.txt" : "llms.txt";
   let installed = 0;
   let skipped = 0;
   let failed = 0;
   const installedSlugs = [];
-  for (const match of matches) {
-    if (!selectedSlugs.has(match.slug)) {
-      continue;
-    }
-    const entry = match.registryEntry;
+  for (const entry of entries2) {
     const actualFormat = format === "llms-full.txt" && entry.llmsFullTxtUrl ? "llms-full.txt" : "llms.txt";
     const url = actualFormat === "llms-full.txt" ? entry.llmsFullTxtUrl : entry.llmsTxtUrl;
-    if (isInstalled({ projectDir, slug: match.slug })) {
+    if (isInstalled({ projectDir, slug: entry.slug })) {
       skipped++;
       continue;
     }
-    const spin3 = spinner2(`Fetching ${entry.name}...`);
-    spin3.start();
+    const spin = spinner2(`Fetching ${entry.name}...`);
+    spin.start();
     try {
       const result = await fetchLlmsTxt({ url });
       const {
@@ -8002,15 +7524,16 @@ async function init(options) {
         agents: installedTo
       } = installToAgents({
         projectDir,
-        slug: match.slug,
+        slug: entry.slug,
         entry,
         content: result.content,
-        format: actualFormat
+        format: actualFormat,
+        targetAgents
       });
       addEntry({
         projectDir,
         entry: {
-          slug: match.slug,
+          slug: entry.slug,
           format: actualFormat,
           sourceUrl: url,
           etag: result.etag,
@@ -8021,12 +7544,12 @@ async function init(options) {
           name: entry.name
         }
       });
-      spin3.succeed(`${entry.name} ${pc4.dim(`\u2192 ${installedTo.join(", ")}`)}`);
+      spin.succeed(`${entry.name} ${pc4.dim(`\u2192 ${installedTo.join(", ")}`)}`);
       installed++;
-      installedSlugs.push(match.slug);
+      installedSlugs.push(entry.slug);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      spin3.fail(`${entry.name}: ${msg}`);
+      spin.fail(`${entry.name}: ${msg}`);
       failed++;
     }
   }
@@ -8037,9 +7560,6 @@ async function init(options) {
   if (summaryLines.length > 0) {
     p3.note(summaryLines.join("\n"), "Summary");
   }
-  if (addToGitignore(projectDir)) {
-    p3.log.success("Added .llms/ and .agents/skills/ to .gitignore");
-  }
   if (installed > 0) {
     syncClaudeMd(projectDir);
   }
@@ -8068,8 +7588,34 @@ async function install({ names, options }) {
   await loadRegistry();
   spin.succeed("Registry loaded");
   const agents2 = detectInstalledAgents();
-  if (agents2.length > 0) {
-    p4.log.message(pc5.dim(`Detected: ${agents2.map((a) => a.displayName).join(", ")}`));
+  let targetAgents;
+  if (!process.stdin.isTTY) {
+    targetAgents = agents2;
+    if (agents2.length > 0) {
+      const display = agents2.map((a) => a.displayName).join(", ");
+      p4.log.message(pc5.dim(`Installing to: ${display}`));
+    }
+  } else {
+    const savedPrefs = loadSavedAgentPrefs(projectDir);
+    const initialValues = getInitialAgents({ allAgents: agents, savedPrefs, projectDir });
+    const selected = await p4.multiselect({
+      message: "Which agents should receive the skills?",
+      options: agents.map((a) => ({
+        value: a.name,
+        label: a.displayName,
+        hint: a.isUniversal ? "always included" : a.skillsDir
+      })),
+      initialValues,
+      required: true
+    });
+    if (p4.isCancel(selected)) {
+      p4.cancel("Installation cancelled.");
+      return;
+    }
+    const finalNames = ensureUniversalAgents({ selected, allAgents: agents });
+    saveAgentPrefs(projectDir, selected);
+    const nameSet = new Set(finalNames);
+    targetAgents = agents.filter((a) => nameSet.has(a.name));
   }
   let installed = 0;
   let failed = 0;
@@ -8122,7 +7668,14 @@ async function install({ names, options }) {
         checksum,
         size,
         agents: installedTo
-      } = installToAgents({ projectDir, slug: entry.slug, entry, content: result.content, format });
+      } = installToAgents({
+        projectDir,
+        slug: entry.slug,
+        entry,
+        content: result.content,
+        format,
+        targetAgents
+      });
       addEntry({
         projectDir,
         entry: {
@@ -8154,7 +7707,6 @@ async function install({ names, options }) {
     p4.note(lines.join("\n"), "Summary");
   }
   if (installed > 0) {
-    addToGitignore(projectDir);
     syncClaudeMd(projectDir);
   }
   if (failed > 0) {
@@ -8378,8 +7930,8 @@ async function update(name, options) {
 
 // src/index.ts
 var program = new Command();
-program.name("llmstxt").description("Install llms.txt files from the llms-txt-hub registry into your AI coding tools").version("0.2.0").action(() => {
-  printBanner("0.2.0");
+program.name("llmstxt").description("Install llms.txt files from the llms-txt-hub registry into your AI coding tools").version("0.4.0").action(() => {
+  printBanner("0.4.0");
   program.outputHelp();
 });
 program.command("init").description("Auto-detect dependencies and install matching llms.txt files").option("--category <categories>", "Filter by categories (comma-separated)").option("--all-categories", "Include all categories").option("--dry-run", "Preview without installing").option("--full", "Prefer llms-full.txt when available").option("-y, --yes", "Skip confirmation prompts").action(init);