@kitnai/cli 0.1.23 → 0.1.25

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 { readFile as readFile2, writeFile as writeFile2, unlink } from "fs/promises";
+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,28 +177,49 @@ 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");
+}
+async function readLock(projectDir) {
+  try {
+    const raw = await readFile2(join3(projectDir, LOCK_FILE), "utf-8");
+    return lockSchema.parse(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+async function writeLock(projectDir, lock) {
+  if (Object.keys(lock).length === 0) {
+    try {
+      await unlink(join3(projectDir, LOCK_FILE));
+    } catch {
+    }
+    return;
+  }
+  await writeFile2(join3(projectDir, LOCK_FILE), JSON.stringify(lock, 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 componentType, installedComponentSchema, registryEntrySchema, registryValueSchema, configSchema, FRAMEWORK_TO_ADAPTER, CONFIG_FILE, LOCK_FILE, lockSchema, typeToAliasKey;
 var init_config = __esm({
   "src/utils/config.ts"() {
     "use strict";
     componentType = z.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage", "kitn:package"]);
     installedComponentSchema = z.object({
       registry: z.string().optional(),
+      type: componentType.optional(),
+      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(),
@@ -150,8 +238,7 @@ var init_config = __esm({
         skills: z.string(),
         storage: z.string()
       }),
-      registries: z.record(z.string(), registryValueSchema),
-      installed: z.record(z.string(), installedComponentSchema).optional()
+      registries: z.record(z.string(), registryValueSchema)
     });
     FRAMEWORK_TO_ADAPTER = {
       hono: "hono",
@@ -159,6 +246,8 @@ var init_config = __esm({
       elysia: "elysia"
     };
     CONFIG_FILE = "kitn.json";
+    LOCK_FILE = "kitn.lock";
+    lockSchema = z.record(z.string(), installedComponentSchema);
     typeToAliasKey = {
       "kitn:agent": "agents",
       "kitn:tool": "tools",
@@ -170,7 +259,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");
 }
@@ -209,7 +298,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");
@@ -259,33 +348,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;
@@ -729,6 +791,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()
     });
@@ -746,6 +809,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()
@@ -756,6 +820,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()
@@ -782,9 +847,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 as unlink2 } from "fs/promises";
 import { relative as relative2 } from "path";
 async function addCommand(components, opts) {
   p2.intro(pc3.bgCyan(pc3.black(" kitn add ")));
@@ -794,9 +859,65 @@ async function addCommand(components, opts) {
     p2.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
+  const lock = await readLock(cwd);
   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(lock));
+    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]);
@@ -952,6 +1073,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(lock).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 = lock[oldKey];
+      if (!oldEntry) continue;
+      for (const filePath of oldEntry.files) {
+        try {
+          await unlink2(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 lock[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)")}`;
@@ -965,7 +1148,7 @@ async function addCommand(components, opts) {
   for (const item of resolved) {
     if (item.dependencies) allDeps.push(...item.dependencies);
     if (item.devDependencies) allDevDeps.push(...item.devDependencies);
-    const existingInstall = (config.installed ?? {})[item.name];
+    const existingInstall = lock[item.name];
     if (existingInstall && item.type === "kitn:package") {
       const allContent = item.files.map((f) => f.content).join("\n");
       if (contentHash(allContent) === existingInstall.hash) {
@@ -1011,18 +1194,19 @@ async function addCommand(components, opts) {
             break;
         }
       }
-      const installed = config.installed ?? {};
       const allContent = item.files.map((f) => f.content).join("\n");
       const ref = refs.find((r) => r.name === item.name) ?? { namespace: "@kitn", name: item.name, version: void 0 };
       const installedKey = ref.namespace === "@kitn" ? item.name : `${ref.namespace}/${item.name}`;
-      installed[installedKey] = {
+      lock[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 {
       const ref = refs.find((r) => r.name === item.name) ?? { namespace: "@kitn", name: item.name, version: void 0 };
       const ns = ref.namespace;
@@ -1078,23 +1262,24 @@ async function addCommand(components, opts) {
             break;
         }
       }
-      const installed = config.installed ?? {};
       const allContent = item.files.map((f) => {
         const fn = f.path.split("/").pop();
         return rewriteKitnImports(f.content, item.type, fn, config.aliases);
       }).join("\n");
       const installedKey = ns === "@kitn" ? item.name : `${ns}/${item.name}`;
-      installed[installedKey] = {
+      lock[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;
     }
   }
   const BARREL_ELIGIBLE = /* @__PURE__ */ new Set(["kitn:agent", "kitn:tool", "kitn:skill"]);
@@ -1139,6 +1324,7 @@ async function addCommand(components, opts) {
     }
   }
   await writeConfig(cwd, config);
+  await writeLock(cwd, lock);
   const uniqueDeps = [...new Set(allDeps)];
   const uniqueDevDeps = [...new Set(allDevDeps)].filter((d) => !uniqueDeps.includes(d));
   const totalDeps = uniqueDeps.length + uniqueDevDeps.length;
@@ -1175,7 +1361,7 @@ async function addCommand(components, opts) {
     }
   }
   const resolvedNames = new Set(resolved.map((r) => r.name));
-  const projectInstalled = new Set(Object.keys(config.installed ?? {}));
+  const projectInstalled = new Set(Object.keys(lock));
   const hints = [];
   const adapterName = resolveRoutesAlias(config);
   if (resolvedNames.has("core") && !resolvedNames.has(adapterName) && !projectInstalled.has(adapterName)) {
@@ -1437,7 +1623,7 @@ async function listCommand(typeFilter, opts) {
   for (const e of errors) {
     p4.log.warn(`${pc5.yellow("\u26A0")} Failed to fetch ${e}`);
   }
-  const installed = config.installed ?? {};
+  const installed = await readLock(cwd);
   const typeGroups = /* @__PURE__ */ new Map();
   for (const item of allItems) {
     const group = item.type.replace("kitn:", "");
@@ -1530,8 +1716,9 @@ async function diffCommand(componentName) {
   }
   const input = componentName === "routes" ? resolveRoutesAlias(config) : componentName;
   const ref = parseComponentRef(input);
+  const lock = await readLock(cwd);
   const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
-  const installed = config.installed?.[installedKey];
+  const installed = lock[installedKey];
   if (!installed) {
     p5.log.error(`Component '${ref.name}' is not installed.`);
     process.exit(1);
@@ -1609,36 +1796,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 unlink3, 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}`;
-  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);
-  }
+async function removeSingleComponent(installedKey, lock, config, cwd) {
+  const entry = lock[installedKey];
+  if (!entry) return;
   const deleted = [];
-  for (const filePath of installed.files) {
+  for (const filePath of entry.files) {
     try {
-      await unlink(join10(cwd, filePath));
+      await unlink3(join10(cwd, filePath));
       deleted.push(filePath);
     } catch {
       p6.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
@@ -1656,7 +1823,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);
@@ -1670,16 +1837,111 @@ async function removeCommand(componentName) {
       p6.log.info(`Updated barrel file: ${join10(baseDir, "index.ts")}`);
     }
   }
-  delete config.installed[installedKey];
-  if (Object.keys(config.installed).length === 0) {
-    delete config.installed;
-  }
-  await writeConfig(cwd, config);
+  delete lock[installedKey];
   if (deleted.length > 0) {
-    p6.log.success(`Removed ${ref.name}:
+    p6.log.success(`Removed ${installedKey}:
 ` + deleted.map((f) => `  ${pc6.red("-")} ${f}`).join("\n"));
   }
 }
+async function offerOrphanRemoval(removedDeps, lock, config, cwd) {
+  if (removedDeps.size === 0) return;
+  const remaining = Object.entries(lock);
+  const neededDeps = /* @__PURE__ */ new Set();
+  for (const [, entry] of remaining) {
+    if (entry.registryDependencies) {
+      for (const dep of entry.registryDependencies) {
+        neededDeps.add(dep);
+      }
+    }
+  }
+  const orphans = [...removedDeps].filter(
+    (dep) => dep !== "core" && !neededDeps.has(dep) && lock[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: `${lock[dep].files.length} file(s)`
+    })),
+    initialValues: orphans
+    // all checked by default
+  });
+  if (p6.isCancel(selected)) return;
+  for (const key of selected) {
+    await removeSingleComponent(key, lock, 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);
+  }
+  const lock = await readLock(cwd);
+  if (!componentName) {
+    const installedKeys = Object.keys(lock);
+    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: `${lock[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);
+    }
+    const allRemovedDeps = /* @__PURE__ */ new Set();
+    for (const key of selectedKeys) {
+      const entry2 = lock[key];
+      if (entry2?.registryDependencies) {
+        for (const dep of entry2.registryDependencies) {
+          allRemovedDeps.add(dep);
+        }
+      }
+    }
+    for (const key of selectedKeys) {
+      await removeSingleComponent(key, lock, config, cwd);
+    }
+    await offerOrphanRemoval(allRemovedDeps, lock, config, cwd);
+    await writeLock(cwd, lock);
+    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 entry = lock[installedKey];
+  if (!entry) {
+    p6.log.error(`Component '${ref.name}' is not installed.`);
+    process.exit(1);
+  }
+  const shouldRemove = await p6.confirm({
+    message: `Remove ${ref.name}? This will delete ${entry.files.length} file(s).`,
+    initialValue: false
+  });
+  if (p6.isCancel(shouldRemove) || !shouldRemove) {
+    p6.cancel("Remove cancelled.");
+    process.exit(0);
+  }
+  const removedDeps = new Set(entry.registryDependencies ?? []);
+  await removeSingleComponent(installedKey, lock, config, cwd);
+  await offerOrphanRemoval(removedDeps, lock, config, cwd);
+  await writeLock(cwd, lock);
+}
 var init_remove = __esm({
   "src/commands/remove.ts"() {
     "use strict";
@@ -1703,12 +1965,12 @@ async function updateCommand(components) {
       p7.log.error("No kitn.json found. Run `kitn init` first.");
       process.exit(1);
     }
-    const installed = config.installed;
-    if (!installed || Object.keys(installed).length === 0) {
+    const lock = await readLock(cwd);
+    if (Object.keys(lock).length === 0) {
       p7.log.info("No installed components to update.");
       return;
     }
-    components = Object.keys(installed);
+    components = Object.keys(lock);
   }
   await addCommand(components, { overwrite: true });
 }
@@ -1984,7 +2246,8 @@ async function infoCommand(component) {
   if (fileCount > maxShown) {
     console.log(`    ${pc8.dim(`... and ${fileCount - maxShown} more`)}`);
   }
-  const installed = config.installed?.[item.name];
+  const lock = await readLock(cwd);
+  const installed = lock[item.name];
   if (installed) {
     console.log();
     console.log(
@@ -2013,6 +2276,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) {
@@ -2028,7 +2292,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"));
   }
@@ -2037,6 +2316,7 @@ async function checkCommand(currentVersion) {
 var init_check = __esm({
   "src/commands/check.ts"() {
     "use strict";
+    init_detect();
     init_update_check();
   }
 });
@@ -2090,12 +2370,11 @@ async function registryRemoveCommand(namespace, opts = {}) {
   if (namespace === "@kitn" && !opts.force) {
     throw new Error("Cannot remove the default @kitn registry. Use --force to override.");
   }
+  const lock = await readLock(cwd);
   const affectedComponents = [];
-  if (config.installed) {
-    for (const [name, entry] of Object.entries(config.installed)) {
-      if (entry.registry === namespace) {
-        affectedComponents.push(name);
-      }
+  for (const [name, entry] of Object.entries(lock)) {
+    if (entry.registry === namespace) {
+      affectedComponents.push(name);
     }
   }
   delete config.registries[namespace];
@@ -2140,14 +2419,14 @@ var init_registry = __esm({
 // src/index.ts
 init_update_check();
 import { Command } from "commander";
-var VERSION = true ? "0.1.23" : "0.0.0-dev";
+var VERSION = true ? "0.1.25" : "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("-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);
 });
@@ -2159,7 +2438,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);
 });