@kitnai/cli 0.1.22 → 0.1.24

package/dist/index.js

@@ -9,9 +9,72 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/detect.ts
+import { access } from "fs/promises";
+import { join } from "path";
+async function detectPackageManager(dir) {
+  for (const [lockfile, pm] of LOCKFILE_MAP) {
+    try {
+      await access(join(dir, lockfile));
+      return pm;
+    } catch {
+    }
+  }
+  return null;
+}
+function getRunCommand(pm) {
+  switch (pm) {
+    case "bun":
+      return "bunx";
+    case "pnpm":
+      return "pnpm dlx";
+    case "yarn":
+      return "yarn dlx";
+    case "npm":
+      return "npx";
+  }
+}
+function detectCliInstaller() {
+  const userAgent = process.env.npm_config_user_agent ?? "";
+  if (userAgent.startsWith("bun/")) return "bun";
+  if (userAgent.startsWith("pnpm/")) return "pnpm";
+  if (userAgent.startsWith("yarn/")) return "yarn";
+  if (userAgent.startsWith("npm/")) return "npm";
+  const invoker = process.env._ ?? "";
+  if (invoker.includes("bun")) return "bun";
+  if (invoker.includes("pnpm")) return "pnpm";
+  if (invoker.includes("yarn")) return "yarn";
+  return "npm";
+}
+function getGlobalInstallCommand(pm, pkg) {
+  switch (pm) {
+    case "bun":
+      return `bun install -g ${pkg}`;
+    case "pnpm":
+      return `pnpm add -g ${pkg}`;
+    case "yarn":
+      return `yarn global add ${pkg}`;
+    case "npm":
+      return `npm install -g ${pkg}`;
+  }
+}
+var LOCKFILE_MAP;
+var init_detect = __esm({
+  "src/utils/detect.ts"() {
+    "use strict";
+    LOCKFILE_MAP = [
+      ["bun.lock", "bun"],
+      ["bun.lockb", "bun"],
+      ["pnpm-lock.yaml", "pnpm"],
+      ["yarn.lock", "yarn"],
+      ["package-lock.json", "npm"]
+    ];
+  }
+});
+
 // src/utils/update-check.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
+import { join as join2 } from "path";
 import { homedir } from "os";
 import pc from "picocolors";
 async function readCache() {
@@ -65,10 +128,13 @@ function startUpdateCheck(currentVersion) {
       }
     }
     if (latest && isNewer(latest, currentVersion)) {
+      const pm = detectCliInstaller();
+      const runCmd = `${getRunCommand(pm)} @kitnai/cli@latest`;
+      const installCmd = getGlobalInstallCommand(pm, "@kitnai/cli");
       message = [
         "",
         pc.yellow(`  Update available: ${pc.dim(currentVersion)} \u2192 ${pc.green(latest)}`),
-        pc.dim(`  Run ${pc.cyan("npx @kitnai/cli@latest")} or ${pc.cyan("npm i -g @kitnai/cli")}`),
+        pc.dim(`  Run ${pc.cyan(runCmd)} or ${pc.cyan(installCmd)}`),
         ""
       ].join("\n");
     }
@@ -83,15 +149,16 @@ var CACHE_DIR, CACHE_FILE, CHECK_INTERVAL;
 var init_update_check = __esm({
   "src/utils/update-check.ts"() {
     "use strict";
-    CACHE_DIR = join(homedir(), ".kitn");
-    CACHE_FILE = join(CACHE_DIR, "update-check.json");
+    init_detect();
+    CACHE_DIR = join2(homedir(), ".kitn");
+    CACHE_FILE = join2(CACHE_DIR, "update-check.json");
     CHECK_INTERVAL = 60 * 60 * 1e3;
   }
 });
 
 // src/utils/config.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { z } from "zod";
 function getRegistryUrl(entry) {
   return typeof entry === "string" ? entry : entry.url;
@@ -102,7 +169,7 @@ function resolveRoutesAlias(config) {
 }
 async function readConfig(projectDir) {
   try {
-    const raw = await readFile2(join2(projectDir, CONFIG_FILE), "utf-8");
+    const raw = await readFile2(join3(projectDir, CONFIG_FILE), "utf-8");
     return configSchema.parse(JSON.parse(raw));
   } catch {
     return null;
@@ -110,16 +177,16 @@ async function readConfig(projectDir) {
 }
 async function writeConfig(projectDir, config) {
   const data = { $schema: "https://kitn.dev/schema/config.json", ...config };
-  await writeFile2(join2(projectDir, CONFIG_FILE), JSON.stringify(data, null, 2) + "\n");
+  await writeFile2(join3(projectDir, CONFIG_FILE), JSON.stringify(data, null, 2) + "\n");
 }
 function getInstallPath(config, type, fileName, namespace) {
   const aliasKey = typeToAliasKey[type];
   const base = config.aliases[aliasKey];
   if (namespace && namespace !== "@kitn") {
     const nsDir = namespace.replace("@", "");
-    return join2(base, nsDir, fileName);
+    return join3(base, nsDir, fileName);
   }
-  return join2(base, fileName);
+  return join3(base, fileName);
 }
 var componentType, installedComponentSchema, registryEntrySchema, registryValueSchema, configSchema, FRAMEWORK_TO_ADAPTER, CONFIG_FILE, typeToAliasKey;
 var init_config = __esm({
@@ -128,10 +195,13 @@ var init_config = __esm({
     componentType = z.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage", "kitn:package"]);
     installedComponentSchema = z.object({
       registry: z.string().optional(),
+      type: componentType,
+      slot: z.string().optional(),
       version: z.string(),
       installedAt: z.string(),
       files: z.array(z.string()),
-      hash: z.string()
+      hash: z.string(),
+      registryDependencies: z.array(z.string()).optional()
     });
     registryEntrySchema = z.object({
       url: z.string(),
@@ -142,7 +212,7 @@ var init_config = __esm({
     configSchema = z.object({
       $schema: z.string().optional(),
       runtime: z.enum(["bun", "node", "deno"]),
-      framework: z.enum(["hono", "cloudflare", "elysia", "fastify", "express"]).optional(),
+      framework: z.enum(["hono", "hono-openapi", "cloudflare", "elysia", "fastify", "express"]).optional(),
       aliases: z.object({
         base: z.string().optional(),
         agents: z.string(),
@@ -155,6 +225,7 @@ var init_config = __esm({
     });
     FRAMEWORK_TO_ADAPTER = {
       hono: "hono",
+      "hono-openapi": "hono-openapi",
       elysia: "elysia"
     };
     CONFIG_FILE = "kitn.json";
@@ -169,7 +240,7 @@ var init_config = __esm({
 
 // src/installers/tsconfig-patcher.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function stripJsonc(text3) {
   return text3.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
 }
@@ -208,7 +279,7 @@ function patchTsconfig(tsconfigContent, paths, removePrefixes) {
   return JSON.stringify(config, null, 2) + "\n";
 }
 async function patchProjectTsconfig(projectDir, paths, removePrefixes) {
-  const tsconfigPath = join3(projectDir, "tsconfig.json");
+  const tsconfigPath = join4(projectDir, "tsconfig.json");
   let content;
   try {
     content = await readFile3(tsconfigPath, "utf-8");
@@ -258,33 +329,6 @@ var init_barrel_manager = __esm({
   }
 });
 
-// src/utils/detect.ts
-import { access } from "fs/promises";
-import { join as join4 } from "path";
-async function detectPackageManager(dir) {
-  for (const [lockfile, pm] of LOCKFILE_MAP) {
-    try {
-      await access(join4(dir, lockfile));
-      return pm;
-    } catch {
-    }
-  }
-  return null;
-}
-var LOCKFILE_MAP;
-var init_detect = __esm({
-  "src/utils/detect.ts"() {
-    "use strict";
-    LOCKFILE_MAP = [
-      ["bun.lock", "bun"],
-      ["bun.lockb", "bun"],
-      ["pnpm-lock.yaml", "pnpm"],
-      ["yarn.lock", "yarn"],
-      ["package-lock.json", "npm"]
-    ];
-  }
-});
-
 // src/registry/fetcher.ts
 function urlOf(entry) {
   return typeof entry === "string" ? entry : entry.url;
@@ -728,6 +772,7 @@ var init_schema = __esm({
       tsconfig: z2.record(z2.string(), z2.array(z2.string())).optional(),
       envVars: z2.record(z2.string(), envVarConfigSchema).optional(),
       categories: z2.array(z2.string()).optional(),
+      slot: z2.string().optional(),
       docs: z2.string().optional(),
       changelog: z2.array(changelogEntrySchema).optional()
     });
@@ -745,6 +790,7 @@ var init_schema = __esm({
       tsconfig: z2.record(z2.string(), z2.array(z2.string())).optional(),
       docs: z2.string().optional(),
       categories: z2.array(z2.string()).optional(),
+      slot: z2.string().optional(),
       version: z2.string().optional(),
       updatedAt: z2.string().optional(),
       changelog: z2.array(changelogEntrySchema).optional()
@@ -755,6 +801,7 @@ var init_schema = __esm({
       description: z2.string(),
       registryDependencies: z2.array(z2.string()).optional(),
       categories: z2.array(z2.string()).optional(),
+      slot: z2.string().optional(),
       version: z2.string().optional(),
       versions: z2.array(z2.string()).optional(),
       updatedAt: z2.string().optional()
@@ -781,9 +828,9 @@ __export(add_exports, {
 });
 import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
-import { join as join7 } from "path";
+import { join as join7, dirname as dirname3 } from "path";
 import { existsSync } from "fs";
-import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir3 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir3, unlink } from "fs/promises";
 import { relative as relative2 } from "path";
 async function addCommand(components, opts) {
   p2.intro(pc3.bgCyan(pc3.black(" kitn add ")));
@@ -794,8 +841,63 @@ async function addCommand(components, opts) {
     process.exit(1);
   }
   if (components.length === 0) {
-    p2.log.error("Please specify at least one component to add.");
-    process.exit(1);
+    const fetcher2 = new RegistryFetcher(config.registries);
+    const s2 = p2.spinner();
+    s2.start("Fetching registry...");
+    const allItems = [];
+    for (const namespace of Object.keys(config.registries)) {
+      try {
+        const index = await fetcher2.fetchIndex(namespace);
+        for (const item of index.items) {
+          allItems.push({ name: item.name, type: item.type, description: item.description, namespace });
+        }
+      } catch {
+      }
+    }
+    s2.stop(`Found ${allItems.length} component(s)`);
+    if (allItems.length === 0) {
+      p2.log.warn("No components found in configured registries.");
+      process.exit(0);
+    }
+    const installed = new Set(Object.keys(config.installed ?? {}));
+    const typeLabels = {
+      "kitn:agent": "Agents",
+      "kitn:tool": "Tools",
+      "kitn:skill": "Skills",
+      "kitn:storage": "Storage",
+      "kitn:package": "Packages"
+    };
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of allItems) {
+      if (!groups.has(item.type)) groups.set(item.type, []);
+      groups.get(item.type).push(item);
+    }
+    const options = [];
+    for (const [type, items] of groups) {
+      const label = typeLabels[type] ?? type;
+      options.push({ value: `__separator_${type}`, label: pc3.bold(`\u2500\u2500 ${label} ${"\u2500".repeat(Math.max(0, 40 - label.length))}`), hint: "" });
+      for (const item of items) {
+        const isInstalled = installed.has(item.name);
+        options.push({
+          value: item.name,
+          label: isInstalled ? pc3.dim(`${item.name} (installed)`) : item.name,
+          hint: item.description
+        });
+      }
+    }
+    const selected = await p2.multiselect({
+      message: "Select components to install:",
+      options
+    });
+    if (p2.isCancel(selected)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    components = selected.filter((s3) => !s3.startsWith("__separator_"));
+    if (components.length === 0) {
+      p2.log.warn("No components selected.");
+      process.exit(0);
+    }
   }
   let typeFilter;
   const firstAlias = resolveTypeAlias(components[0]);
@@ -853,7 +955,45 @@ async function addCommand(components, opts) {
         matches = matches.filter((m) => m.type === filteredType);
       }
       if (matches.length === 0) {
-        newExpandedNames.push(name);
+        let fuzzyMatches = allIndexItems.filter(
+          (i) => i.name.includes(name) && (ref.namespace === "@kitn" || i.namespace === ref.namespace)
+        );
+        if (typeFilter) {
+          const filteredType = toComponentType(typeFilter);
+          fuzzyMatches = fuzzyMatches.filter((m) => m.type === filteredType);
+        }
+        if (fuzzyMatches.length === 0) {
+          newExpandedNames.push(name);
+        } else if (fuzzyMatches.length === 1) {
+          preResolvedTypes.set(fuzzyMatches[0].name, fuzzyMatches[0].type);
+          newExpandedNames.push(fuzzyMatches[0].name);
+        } else {
+          s.stop("Multiple matches found");
+          if (!process.stdin.isTTY) {
+            const suggestions = fuzzyMatches.map((m) => `${m.name} (${m.type.replace("kitn:", "")})`).join(", ");
+            p2.log.error(
+              `Component ${pc3.bold(name)} not found. Did you mean one of: ${suggestions}`
+            );
+            process.exit(1);
+          }
+          const selected = await p2.multiselect({
+            message: `No exact match for ${pc3.bold(name)}. Select component(s) to install:`,
+            options: fuzzyMatches.map((m) => ({
+              value: `${m.name}::${m.type}`,
+              label: `${m.name} ${pc3.dim(`(${m.type.replace("kitn:", "")})`)}`
+            }))
+          });
+          if (p2.isCancel(selected)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          for (const sel of selected) {
+            const [selName, selType] = sel.split("::");
+            preResolvedTypes.set(selName, selType);
+            newExpandedNames.push(selName);
+          }
+          s.start("Resolving dependencies...");
+        }
       } else if (matches.length === 1) {
         preResolvedTypes.set(name, matches[0].type);
         newExpandedNames.push(name);
@@ -913,6 +1053,68 @@ async function addCommand(components, opts) {
     process.exit(1);
   }
   s.stop(`Resolved ${resolved.length} component(s)`);
+  const slotReplacements = /* @__PURE__ */ new Map();
+  for (const item of resolved) {
+    if (!item.slot) continue;
+    const existing = Object.entries(config.installed ?? {}).find(
+      ([key, entry]) => key !== item.name && entry.slot === item.slot
+    );
+    if (!existing) continue;
+    const [existingKey] = existing;
+    const action = await p2.select({
+      message: `${pc3.bold(existingKey)} already fills the ${pc3.cyan(item.slot)} slot. What would you like to do?`,
+      options: [
+        { value: "replace", label: `Replace ${existingKey} with ${item.name}` },
+        { value: "add", label: `Add alongside ${existingKey}` }
+      ]
+    });
+    if (p2.isCancel(action)) {
+      p2.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (action === "replace") {
+      slotReplacements.set(existingKey, item.name);
+    }
+  }
+  if (slotReplacements.size > 0) {
+    const baseDir2 = config.aliases.base ?? "src/ai";
+    for (const [oldKey] of slotReplacements) {
+      const oldEntry = config.installed[oldKey];
+      if (!oldEntry) continue;
+      for (const filePath of oldEntry.files) {
+        try {
+          await unlink(join7(cwd, filePath));
+        } catch {
+        }
+      }
+      const barrelPath2 = join7(cwd, baseDir2, "index.ts");
+      const barrelEligibleDirs = /* @__PURE__ */ new Set([
+        config.aliases.agents,
+        config.aliases.tools,
+        config.aliases.skills
+      ]);
+      if (existsSync(barrelPath2)) {
+        let barrelContent = await readFile6(barrelPath2, "utf-8");
+        let barrelChanged = false;
+        for (const filePath of oldEntry.files) {
+          const fileDir = dirname3(filePath);
+          if (!barrelEligibleDirs.has(fileDir)) continue;
+          const barrelDir2 = join7(cwd, baseDir2);
+          const importPath = "./" + relative2(barrelDir2, join7(cwd, filePath)).replace(/\\/g, "/");
+          const updated2 = removeImportFromBarrel(barrelContent, importPath);
+          if (updated2 !== barrelContent) {
+            barrelContent = updated2;
+            barrelChanged = true;
+          }
+        }
+        if (barrelChanged) {
+          await writeFile6(barrelPath2, barrelContent);
+        }
+      }
+      delete config.installed[oldKey];
+      p2.log.info(`Replaced ${pc3.dim(oldKey)} \u2192 ${pc3.cyan(slotReplacements.get(oldKey))}`);
+    }
+  }
   p2.log.info("Components to install:\n" + resolved.map((item) => {
     const isExplicit = expandedNames.includes(item.name) || components.includes(item.name);
     const label = isExplicit ? item.name : `${item.name} ${pc3.dim("(dependency)")}`;
@@ -978,10 +1180,13 @@ async function addCommand(components, opts) {
       const installedKey = ref.namespace === "@kitn" ? item.name : `${ref.namespace}/${item.name}`;
       installed[installedKey] = {
         registry: ref.namespace,
+        type: item.type,
+        ...item.slot && { slot: item.slot },
         version: item.version ?? "1.0.0",
         installedAt: (/* @__PURE__ */ new Date()).toISOString(),
         files: item.files.map((f) => join7(baseDir2, f.path)),
-        hash: contentHash(allContent)
+        hash: contentHash(allContent),
+        registryDependencies: item.registryDependencies
       };
       config.installed = installed;
     } else {
@@ -1047,13 +1252,16 @@ async function addCommand(components, opts) {
       const installedKey = ns === "@kitn" ? item.name : `${ns}/${item.name}`;
       installed[installedKey] = {
         registry: ns,
+        type: item.type,
+        ...item.slot && { slot: item.slot },
         version: item.version ?? "1.0.0",
         installedAt: (/* @__PURE__ */ new Date()).toISOString(),
         files: item.files.map((f) => {
           const fileName = f.path.split("/").pop();
           return getInstallPath(config, item.type, fileName, ns);
         }),
-        hash: contentHash(allContent)
+        hash: contentHash(allContent),
+        registryDependencies: item.registryDependencies
       };
       config.installed = installed;
     }
@@ -1175,6 +1383,28 @@ import * as p3 from "@clack/prompts";
 import pc4 from "picocolors";
 import { mkdir as mkdir4, writeFile as writeFile7 } from "fs/promises";
 import { join as join8 } from "path";
+function getPluginTemplate(framework) {
+  const adapterName = framework === "hono-openapi" ? "hono-openapi" : framework;
+  return `import { createAIPlugin } from "@kitn/adapters/${adapterName}";
+import { registerWithPlugin } from "./index.js";
+
+export const ai = createAIPlugin({
+  // To enable agent chat, add an AI provider:
+  // https://sdk.vercel.ai/providers/ai-sdk-providers
+  //
+  // Example with OpenRouter (access to many models):
+  //   import { openrouter } from "@openrouter/ai-sdk-provider";
+  //   model: (id) => openrouter(id ?? "openai/gpt-4o-mini"),
+  //
+  // Example with OpenAI directly:
+  //   import { openai } from "@ai-sdk/openai";
+  //   model: (id) => openai(id ?? "gpt-4o-mini"),
+});
+
+// Flush all auto-registered components into the plugin
+registerWithPlugin(ai);
+`;
+}
 async function initCommand(opts = {}) {
   p3.intro(pc4.bgCyan(pc4.black(" kitn init ")));
   const cwd = process.cwd();
@@ -1218,6 +1448,31 @@ async function initCommand(opts = {}) {
     }
     runtime = selected;
   }
+  const validFrameworks = ["hono", "hono-openapi", "elysia"];
+  let framework;
+  if (opts.framework) {
+    if (!validFrameworks.includes(opts.framework)) {
+      p3.log.error(`Invalid framework: ${opts.framework}. Must be one of: ${validFrameworks.join(", ")}`);
+      process.exit(1);
+    }
+    framework = opts.framework;
+  } else if (opts.yes) {
+    framework = "hono";
+  } else {
+    const selected = await p3.select({
+      message: "Which HTTP framework do you use?",
+      options: [
+        { value: "hono", label: "Hono", hint: "recommended" },
+        { value: "hono-openapi", label: "Hono + OpenAPI", hint: "zod-openapi routes with /doc endpoint" },
+        { value: "elysia", label: "Elysia", hint: "Bun-native framework" }
+      ]
+    });
+    if (p3.isCancel(selected)) {
+      p3.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    framework = selected;
+  }
   let baseDir;
   if (opts.base) {
     baseDir = opts.base;
@@ -1237,7 +1492,7 @@ async function initCommand(opts = {}) {
   }
   const config = {
     runtime,
-    framework: "hono",
+    framework,
     aliases: {
       base: baseDir,
       agents: `${baseDir}/agents`,
@@ -1263,20 +1518,21 @@ async function initCommand(opts = {}) {
     ["@kitn", "@kitnai"]
   );
   p3.log.info(`Patched tsconfig.json with path: ${pc4.bold("@kitn/*")}`);
-  p3.log.info("Installing core engine and routes...");
+  p3.log.info("Installing core engine and adapter...");
   await addCommand(["core", "routes"], { overwrite: true });
   const aiDir = join8(cwd, baseDir);
   await mkdir4(aiDir, { recursive: true });
   const barrelPath = join8(aiDir, "index.ts");
   await writeFile7(barrelPath, createBarrelFile());
   const pluginPath = join8(aiDir, "plugin.ts");
-  await writeFile7(pluginPath, PLUGIN_TEMPLATE);
+  await writeFile7(pluginPath, getPluginTemplate(framework));
   p3.log.success(`Created ${pc4.bold(baseDir + "/plugin.ts")} \u2014 configure your AI provider there`);
+  const mountCode = framework === "elysia" ? `app.use(ai.router);` : `app.route("/api", ai.router);`;
   p3.note(
     [
       `import { ai } from "./${baseDir.replace(/^src\//, "")}/plugin";`,
       ``,
-      `app.route("/api", ai.router);`
+      mountCode
     ].join("\n"),
     "Add this to your server entry point:"
   );
@@ -1291,7 +1547,6 @@ async function initCommand(opts = {}) {
   );
   p3.outro("Done!");
 }
-var PLUGIN_TEMPLATE;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
@@ -1299,25 +1554,6 @@ var init_init = __esm({
     init_tsconfig_patcher();
     init_barrel_manager();
     init_add();
-    PLUGIN_TEMPLATE = `import { createAIPlugin } from "@kitn/routes";
-import { registerWithPlugin } from "./index.js";
-
-export const ai = createAIPlugin({
-  // To enable agent chat, add an AI provider:
-  // https://sdk.vercel.ai/providers/ai-sdk-providers
-  //
-  // Example with OpenRouter (access to many models):
-  //   import { openrouter } from "@openrouter/ai-sdk-provider";
-  //   model: (id) => openrouter(id ?? "openai/gpt-4o-mini"),
-  //
-  // Example with OpenAI directly:
-  //   import { openai } from "@ai-sdk/openai";
-  //   model: (id) => openai(id ?? "gpt-4o-mini"),
-});
-
-// Flush all auto-registered components into the plugin
-registerWithPlugin(ai);
-`;
   }
 });
 
@@ -1542,36 +1778,16 @@ __export(remove_exports, {
 });
 import * as p6 from "@clack/prompts";
 import pc6 from "picocolors";
-import { join as join10, relative as relative3, dirname as dirname3 } from "path";
-import { unlink, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import { join as join10, relative as relative3, dirname as dirname4 } from "path";
+import { unlink as unlink2, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
-async function removeCommand(componentName) {
-  const cwd = process.cwd();
-  const config = await readConfig(cwd);
-  if (!config) {
-    p6.log.error("No kitn.json found. Run `kitn init` first.");
-    process.exit(1);
-  }
-  const input = componentName === "routes" ? resolveRoutesAlias(config) : componentName;
-  const ref = parseComponentRef(input);
-  const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
+async function removeSingleComponent(installedKey, config, cwd) {
   const installed = config.installed?.[installedKey];
-  if (!installed) {
-    p6.log.error(`Component '${ref.name}' is not installed.`);
-    process.exit(1);
-  }
-  const shouldRemove = await p6.confirm({
-    message: `Remove ${ref.name}? This will delete ${installed.files.length} file(s).`,
-    initialValue: false
-  });
-  if (p6.isCancel(shouldRemove) || !shouldRemove) {
-    p6.cancel("Remove cancelled.");
-    process.exit(0);
-  }
+  if (!installed) return;
   const deleted = [];
   for (const filePath of installed.files) {
     try {
-      await unlink(join10(cwd, filePath));
+      await unlink2(join10(cwd, filePath));
       deleted.push(filePath);
     } catch {
       p6.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
@@ -1589,7 +1805,7 @@ async function removeCommand(componentName) {
     let barrelContent = await readFile7(barrelPath, "utf-8");
     let barrelChanged = false;
     for (const filePath of deleted) {
-      const fileDir = dirname3(filePath);
+      const fileDir = dirname4(filePath);
       if (!barrelEligibleDirs.has(fileDir)) continue;
       const importPath = "./" + relative3(barrelDir, join10(cwd, filePath)).replace(/\\/g, "/");
       const updated = removeImportFromBarrel(barrelContent, importPath);
@@ -1604,14 +1820,113 @@ async function removeCommand(componentName) {
     }
   }
   delete config.installed[installedKey];
+  if (deleted.length > 0) {
+    p6.log.success(`Removed ${installedKey}:
+` + deleted.map((f) => `  ${pc6.red("-")} ${f}`).join("\n"));
+  }
+}
+async function offerOrphanRemoval(removedDeps, config, cwd) {
+  if (removedDeps.size === 0) return;
+  const remaining = Object.entries(config.installed ?? {});
+  const neededDeps = /* @__PURE__ */ new Set();
+  for (const [, entry] of remaining) {
+    const deps = entry.registryDependencies;
+    if (deps) {
+      for (const dep of deps) {
+        neededDeps.add(dep);
+      }
+    }
+  }
+  const orphans = [...removedDeps].filter(
+    (dep) => dep !== "core" && !neededDeps.has(dep) && config.installed?.[dep]
+  );
+  if (orphans.length === 0) return;
+  const selected = await p6.multiselect({
+    message: "The following dependencies are no longer used. Remove them?",
+    options: orphans.map((dep) => ({
+      value: dep,
+      label: dep,
+      hint: `${config.installed[dep].files.length} file(s)`
+    })),
+    initialValues: orphans
+    // all checked by default
+  });
+  if (p6.isCancel(selected)) return;
+  for (const key of selected) {
+    await removeSingleComponent(key, config, cwd);
+  }
+}
+async function removeCommand(componentName) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    p6.log.error("No kitn.json found. Run `kitn init` first.");
+    process.exit(1);
+  }
+  if (!componentName) {
+    const installed2 = config.installed ?? {};
+    const installedKeys = Object.keys(installed2);
+    if (installedKeys.length === 0) {
+      p6.log.warn("No components installed.");
+      process.exit(0);
+    }
+    const selected = await p6.multiselect({
+      message: "Select components to remove:",
+      options: installedKeys.map((key) => ({
+        value: key,
+        label: key,
+        hint: `${installed2[key].files.length} file(s)`
+      }))
+    });
+    if (p6.isCancel(selected)) {
+      p6.cancel("Cancelled.");
+      process.exit(0);
+    }
+    const selectedKeys = selected;
+    if (selectedKeys.length === 0) {
+      p6.log.warn("No components selected.");
+      process.exit(0);
+    }
+    for (const key of selectedKeys) {
+      await removeSingleComponent(key, config, cwd);
+    }
+    const allRemovedDeps = /* @__PURE__ */ new Set();
+    for (const key of selectedKeys) {
+      const entry = installed2[key];
+      if (entry?.registryDependencies) {
+        for (const dep of entry.registryDependencies) {
+          allRemovedDeps.add(dep);
+        }
+      }
+    }
+    await offerOrphanRemoval(allRemovedDeps, config, cwd);
+    await writeConfig(cwd, config);
+    p6.outro(pc6.green("Done!"));
+    return;
+  }
+  const input = componentName === "routes" ? resolveRoutesAlias(config) : componentName;
+  const ref = parseComponentRef(input);
+  const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
+  const installed = config.installed?.[installedKey];
+  if (!installed) {
+    p6.log.error(`Component '${ref.name}' is not installed.`);
+    process.exit(1);
+  }
+  const shouldRemove = await p6.confirm({
+    message: `Remove ${ref.name}? This will delete ${installed.files.length} file(s).`,
+    initialValue: false
+  });
+  if (p6.isCancel(shouldRemove) || !shouldRemove) {
+    p6.cancel("Remove cancelled.");
+    process.exit(0);
+  }
+  await removeSingleComponent(installedKey, config, cwd);
+  const removedDeps = new Set(installed.registryDependencies ?? []);
+  await offerOrphanRemoval(removedDeps, config, cwd);
   if (Object.keys(config.installed).length === 0) {
     delete config.installed;
   }
   await writeConfig(cwd, config);
-  if (deleted.length > 0) {
-    p6.log.success(`Removed ${ref.name}:
-` + deleted.map((f) => `  ${pc6.red("-")} ${f}`).join("\n"));
-  }
 }
 var init_remove = __esm({
   "src/commands/remove.ts"() {
@@ -1946,6 +2261,7 @@ var check_exports = {};
 __export(check_exports, {
   checkCommand: () => checkCommand
 });
+import { execSync as execSync2 } from "child_process";
 import * as p10 from "@clack/prompts";
 import pc9 from "picocolors";
 async function checkCommand(currentVersion) {
@@ -1961,7 +2277,22 @@ async function checkCommand(currentVersion) {
   }
   if (isNewer(latest, currentVersion)) {
     s.stop(pc9.yellow(`Update available: ${currentVersion} \u2192 ${latest}`));
-    p10.log.message(`  Run: ${pc9.cyan("npm i -g @kitnai/cli")}`);
+    const pm = detectCliInstaller();
+    const installCmd = getGlobalInstallCommand(pm, "@kitnai/cli");
+    const shouldUpdate = await p10.confirm({ message: "Update now?" });
+    if (p10.isCancel(shouldUpdate) || !shouldUpdate) {
+      p10.log.message(`  Run: ${pc9.cyan(installCmd)}`);
+    } else {
+      const us = p10.spinner();
+      us.start("Updating...");
+      try {
+        execSync2(installCmd, { stdio: "pipe" });
+        us.stop(pc9.green(`Updated to v${latest}`));
+      } catch {
+        us.stop(pc9.red("Update failed"));
+        p10.log.message(`  Run manually: ${pc9.cyan(installCmd)}`);
+      }
+    }
   } else {
     s.stop(pc9.green("You're on the latest version"));
   }
@@ -1970,6 +2301,7 @@ async function checkCommand(currentVersion) {
 var init_check = __esm({
   "src/commands/check.ts"() {
     "use strict";
+    init_detect();
     init_update_check();
   }
 });
@@ -2073,14 +2405,14 @@ var init_registry = __esm({
 // src/index.ts
 init_update_check();
 import { Command } from "commander";
-var VERSION = true ? "0.1.22" : "0.0.0-dev";
+var VERSION = true ? "0.1.24" : "0.0.0-dev";
 var printUpdateNotice = startUpdateCheck(VERSION);
 var program = new Command().name("kitn").description("Install AI agent components from the kitn registry").version(VERSION);
-program.command("init").description("Initialize kitn in your project").option("-r, --runtime <runtime>", "runtime to use (bun, node, deno)").option("-b, --base <path>", "base directory for components (default: src/ai)").option("-y, --yes", "accept all defaults without prompting").action(async (opts) => {
+program.command("init").description("Initialize kitn in your project").option("-r, --runtime <runtime>", "runtime to use (bun, node, deno)").option("-f, --framework <framework>", "HTTP framework (hono, hono-openapi, elysia)").option("-b, --base <path>", "base directory for components (default: src/ai)").option("-y, --yes", "accept all defaults without prompting").action(async (opts) => {
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2(opts);
 });
-program.command("add").description("Add components from the registry (supports type-first: kitn add agent <name>)").argument("[components...]", "component names or type followed by names").option("-o, --overwrite", "overwrite existing files without prompting").option("-t, --type <type>", "filter by component type during resolution").action(async (components, opts) => {
+program.command("add").alias("install").description("Add components from the registry (supports type-first: kitn add agent <name>)").argument("[components...]", "component names or type followed by names").option("-o, --overwrite", "overwrite existing files without prompting").option("-t, --type <type>", "filter by component type during resolution").action(async (components, opts) => {
   const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
   await addCommand2(components, opts);
 });
@@ -2092,7 +2424,7 @@ program.command("diff").description("Show differences between local and registry
   const { diffCommand: diffCommand2 } = await Promise.resolve().then(() => (init_diff(), diff_exports));
   await diffCommand2(component);
 });
-program.command("remove").description("Remove an installed component").argument("<component>", "component name to remove").action(async (component) => {
+program.command("remove").alias("uninstall").description("Remove an installed component").argument("[component]", "component name to remove (interactive if omitted)").action(async (component) => {
   const { removeCommand: removeCommand2 } = await Promise.resolve().then(() => (init_remove(), remove_exports));
   await removeCommand2(component);
 });