@kitnai/cli 0.1.16 → 0.1.18

package/dist/index.js

@@ -9,6 +9,86 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/update-check.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+import pc from "picocolors";
+async function readCache() {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeCache(entry) {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(entry));
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch("https://registry.npmjs.org/@kitnai/cli/latest", {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(latest, current) {
+  const [lMaj, lMin, lPat] = latest.split(".").map(Number);
+  const [cMaj, cMin, cPat] = current.split(".").map(Number);
+  if (lMaj !== cMaj) return lMaj > cMaj;
+  if (lMin !== cMin) return lMin > cMin;
+  return lPat > cPat;
+}
+function startUpdateCheck(currentVersion) {
+  let message = "";
+  const check = (async () => {
+    const cache = await readCache();
+    let latest = null;
+    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL) {
+      latest = cache.latest;
+    } else {
+      latest = await fetchLatestVersion();
+      if (latest) {
+        await writeCache({ latest, checkedAt: Date.now() });
+      }
+    }
+    if (latest && isNewer(latest, currentVersion)) {
+      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")}`),
+        ""
+      ].join("\n");
+    }
+  })();
+  check.catch(() => {
+  });
+  return () => {
+    if (message) process.stderr.write(message);
+  };
+}
+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");
+    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";
@@ -565,6 +645,41 @@ var init_parse_ref = __esm({
   }
 });
 
+// src/utils/type-aliases.ts
+function resolveTypeAlias(input) {
+  return TYPE_ALIASES[input.toLowerCase()];
+}
+function toComponentType(shortType) {
+  const ct = SHORT_TO_COMPONENT[shortType];
+  if (!ct) throw new Error(`Unknown component type: ${shortType}`);
+  return ct;
+}
+var TYPE_ALIASES, SHORT_TO_COMPONENT;
+var init_type_aliases = __esm({
+  "src/utils/type-aliases.ts"() {
+    "use strict";
+    TYPE_ALIASES = {
+      agent: "agent",
+      agents: "agent",
+      tool: "tool",
+      tools: "tool",
+      skill: "skill",
+      skills: "skill",
+      storage: "storage",
+      storages: "storage",
+      package: "package",
+      packages: "package"
+    };
+    SHORT_TO_COMPONENT = {
+      agent: "kitn:agent",
+      tool: "kitn:tool",
+      skill: "kitn:skill",
+      storage: "kitn:storage",
+      package: "kitn:package"
+    };
+  }
+});
+
 // src/registry/schema.ts
 import { z as z2 } from "zod";
 var componentType2, registryFileSchema, changelogEntrySchema, envVarConfigSchema, componentConfigSchema, registryItemSchema, registryIndexItemSchema, registryIndexSchema, typeToDir;
@@ -674,6 +789,29 @@ async function addCommand(components, opts) {
     p2.log.error("Please specify at least one component to add.");
     process.exit(1);
   }
+  let typeFilter;
+  const firstAlias = resolveTypeAlias(components[0]);
+  if (firstAlias) {
+    if (components.length === 1) {
+      p2.log.error(
+        `${pc3.bold(components[0])} looks like a type, not a component name. Usage: ${pc3.cyan(`kitn add ${components[0]} <name>`)}`
+      );
+      process.exit(1);
+    }
+    typeFilter = firstAlias;
+    components = components.slice(1);
+  }
+  if (opts.type) {
+    const flagAlias = resolveTypeAlias(opts.type);
+    if (!flagAlias) {
+      p2.log.error(`Unknown type ${pc3.bold(opts.type)}. Valid types: agent, tool, skill, storage, package`);
+      process.exit(1);
+    }
+    if (typeFilter && typeFilter !== flagAlias) {
+      p2.log.warn(`Positional type ${pc3.bold(typeFilter)} overridden by --type ${pc3.bold(flagAlias)}`);
+    }
+    typeFilter = flagAlias;
+  }
   const resolvedComponents = components.map((c) => {
     if (c === "routes") {
       const fw2 = config.framework ?? "hono";
@@ -685,12 +823,79 @@ async function addCommand(components, opts) {
   const fetcher = new RegistryFetcher(config.registries);
   const s = p2.spinner();
   s.start("Resolving dependencies...");
+  const preResolvedTypes = /* @__PURE__ */ new Map();
+  let expandedNames = [...resolvedComponents];
+  try {
+    const namespacesToFetch = Object.keys(config.registries);
+    const allIndexItems = [];
+    for (const namespace of namespacesToFetch) {
+      try {
+        const index = await fetcher.fetchIndex(namespace);
+        for (const item of index.items) {
+          allIndexItems.push({ name: item.name, type: item.type, namespace });
+        }
+      } catch {
+      }
+    }
+    const newExpandedNames = [];
+    for (const name of resolvedComponents) {
+      const ref = refs.find((r) => r.name === name) ?? { namespace: "@kitn", name, version: void 0 };
+      let matches = allIndexItems.filter((i) => i.name === name && (ref.namespace === "@kitn" || i.namespace === ref.namespace));
+      if (typeFilter) {
+        const filteredType = toComponentType(typeFilter);
+        matches = matches.filter((m) => m.type === filteredType);
+      }
+      if (matches.length === 0) {
+        newExpandedNames.push(name);
+      } else if (matches.length === 1) {
+        preResolvedTypes.set(name, matches[0].type);
+        newExpandedNames.push(name);
+      } else {
+        const uniqueTypes = [...new Set(matches.map((m) => m.type))];
+        if (uniqueTypes.length === 1) {
+          preResolvedTypes.set(name, uniqueTypes[0]);
+          newExpandedNames.push(name);
+        } else {
+          s.stop("Disambiguation needed");
+          if (!process.stdin.isTTY) {
+            const typeNames = uniqueTypes.map((t) => t.replace("kitn:", "")).join(", ");
+            p2.log.error(
+              `Multiple components named ${pc3.bold(name)} found (${typeNames}). Specify the type: ${pc3.cyan(`kitn add ${uniqueTypes[0].replace("kitn:", "")} ${name}`)}`
+            );
+            process.exit(1);
+          }
+          const selected = await p2.multiselect({
+            message: `Multiple types found for ${pc3.bold(name)}. Which do you want to install?`,
+            options: uniqueTypes.map((t) => ({
+              value: t,
+              label: `${name} ${pc3.dim(`(${t.replace("kitn:", "")})`)}`
+            }))
+          });
+          if (p2.isCancel(selected)) {
+            p2.cancel("Cancelled.");
+            process.exit(0);
+          }
+          for (const type of selected) {
+            preResolvedTypes.set(name, type);
+            newExpandedNames.push(name);
+          }
+          s.start("Resolving dependencies...");
+        }
+      }
+    }
+    expandedNames = newExpandedNames;
+  } catch (err) {
+    s.stop(pc3.red("Failed to resolve dependencies"));
+    p2.log.error(err.message);
+    process.exit(1);
+  }
   let resolved;
   try {
-    resolved = await resolveDependencies(resolvedComponents, async (name) => {
+    resolved = await resolveDependencies(expandedNames, async (name) => {
       const ref = refs.find((r) => r.name === name) ?? { namespace: "@kitn", name, version: void 0 };
       const index = await fetcher.fetchIndex(ref.namespace);
-      const indexItem = index.items.find((i) => i.name === name);
+      const preResolved = preResolvedTypes.get(name);
+      const indexItem = preResolved ? index.items.find((i) => i.name === name && i.type === preResolved) : index.items.find((i) => i.name === name);
       if (!indexItem) throw new Error(`Component '${name}' not found in ${ref.namespace} registry`);
       const dir = typeToDir[indexItem.type];
       return fetcher.fetchItem(name, dir, ref.namespace, ref.version);
@@ -702,7 +907,7 @@ async function addCommand(components, opts) {
   }
   s.stop(`Resolved ${resolved.length} component(s)`);
   p2.log.info("Components to install:\n" + resolved.map((item) => {
-    const isExplicit = resolvedComponents.includes(item.name) || components.includes(item.name);
+    const isExplicit = expandedNames.includes(item.name) || components.includes(item.name);
     const label = isExplicit ? item.name : `${item.name} ${pc3.dim("(dependency)")}`;
     return `  ${pc3.cyan(label)}`;
   }).join("\n"));
@@ -714,6 +919,13 @@ 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];
+    if (existingInstall && item.type === "kitn:package") {
+      const allContent = item.files.map((f) => f.content).join("\n");
+      if (contentHash(allContent) === existingInstall.hash) {
+        continue;
+      }
+    }
     if (item.type === "kitn:package") {
       const baseDir2 = config.aliases.base ?? "src/ai";
       for (const file of item.files) {
@@ -899,7 +1111,7 @@ async function addCommand(components, opts) {
     }
   }
   if (created.length > 0) {
-    p2.log.success(`Created ${created.length} file(s):
+    p2.log.success(`Added ${created.length} file(s):
 ` + created.map((f) => `  ${pc3.green("+")} ${f}`).join("\n"));
   }
   if (updated.length > 0) {
@@ -917,13 +1129,14 @@ async function addCommand(components, opts) {
       p2.log.info(`${pc3.bold(item.name)}: ${item.docs}`);
     }
   }
-  const installedNames = new Set(resolved.map((r) => r.name));
+  const resolvedNames = new Set(resolved.map((r) => r.name));
+  const projectInstalled = new Set(Object.keys(config.installed ?? {}));
   const hints = [];
-  if (installedNames.has("core") && !installedNames.has(config.framework ?? "hono")) {
+  const fw = config.framework ?? "hono";
+  if (resolvedNames.has("core") && !resolvedNames.has(fw) && !projectInstalled.has(fw)) {
     hints.push(`Run ${pc3.cyan(`kitn add routes`)} to install the HTTP adapter.`);
   }
-  const fw = config.framework ?? "hono";
-  if (installedNames.has(fw) || installedNames.has("core") && installedNames.has(fw)) {
+  if (resolvedNames.has(fw)) {
     hints.push(`Configure your AI provider in ${pc3.bold(baseDir + "/plugin.ts")}, then add to your server:`);
     hints.push("");
     hints.push(pc3.dim(`  import { ai } from "./${baseDir.replace(/^src\//, "")}/plugin";`));
@@ -951,6 +1164,7 @@ var init_add = __esm({
     init_barrel_manager();
     init_hash();
     init_parse_ref();
+    init_type_aliases();
     init_schema();
   }
 });
@@ -964,43 +1178,66 @@ 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";
-async function initCommand() {
+async function initCommand(opts = {}) {
   p3.intro(pc4.bgCyan(pc4.black(" kitn init ")));
   const cwd = process.cwd();
   const existing = await readConfig(cwd);
   if (existing) {
-    p3.log.warn("kitn.json already exists in this directory.");
-    const shouldContinue = await p3.confirm({
-      message: "Overwrite existing configuration?",
-      initialValue: false
+    if (opts.yes) {
+      p3.log.warn("kitn.json already exists \u2014 overwriting (--yes).");
+    } else {
+      p3.log.warn("kitn.json already exists in this directory.");
+      const shouldContinue = await p3.confirm({
+        message: "Overwrite existing configuration?",
+        initialValue: false
+      });
+      if (p3.isCancel(shouldContinue) || !shouldContinue) {
+        p3.cancel("Init cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  let runtime;
+  if (opts.runtime) {
+    if (!["bun", "node", "deno"].includes(opts.runtime)) {
+      p3.log.error(`Invalid runtime: ${opts.runtime}. Must be bun, node, or deno.`);
+      process.exit(1);
+    }
+    runtime = opts.runtime;
+  } else if (opts.yes) {
+    runtime = "bun";
+  } else {
+    const selected = await p3.select({
+      message: "Which runtime do you use?",
+      options: [
+        { value: "bun", label: "Bun", hint: "recommended" },
+        { value: "node", label: "Node.js" },
+        { value: "deno", label: "Deno" }
+      ]
     });
-    if (p3.isCancel(shouldContinue) || !shouldContinue) {
+    if (p3.isCancel(selected)) {
       p3.cancel("Init cancelled.");
       process.exit(0);
     }
+    runtime = selected;
   }
-  const runtime = await p3.select({
-    message: "Which runtime do you use?",
-    options: [
-      { value: "bun", label: "Bun", hint: "recommended" },
-      { value: "node", label: "Node.js" },
-      { value: "deno", label: "Deno" }
-    ]
-  });
-  if (p3.isCancel(runtime)) {
-    p3.cancel("Init cancelled.");
-    process.exit(0);
-  }
-  const base = await p3.text({
-    message: "Where should kitn components be installed?",
-    initialValue: "src/ai",
-    placeholder: "src/ai"
-  });
-  if (p3.isCancel(base)) {
-    p3.cancel("Init cancelled.");
-    process.exit(0);
+  let baseDir;
+  if (opts.base) {
+    baseDir = opts.base;
+  } else if (opts.yes) {
+    baseDir = "src/ai";
+  } else {
+    const base = await p3.text({
+      message: "Where should kitn components be installed?",
+      initialValue: "src/ai",
+      placeholder: "src/ai"
+    });
+    if (p3.isCancel(base)) {
+      p3.cancel("Init cancelled.");
+      process.exit(0);
+    }
+    baseDir = base;
   }
-  const baseDir = base;
   const config = {
     runtime,
     framework: "hono",
@@ -1047,6 +1284,15 @@ async function initCommand() {
     ].join("\n"),
     "Add this to your server entry point:"
   );
+  p3.log.message(
+    [
+      pc4.bold("Add your first agent:"),
+      `  ${pc4.cyan("kitn add weather-agent")}`,
+      "",
+      pc4.bold("Browse all components:"),
+      `  ${pc4.cyan("kitn list")}`
+    ].join("\n")
+  );
   p3.outro("Done!");
 }
 var PLUGIN_TEMPLATE;
@@ -1094,7 +1340,7 @@ async function listCommand(typeFilter, opts) {
     process.exit(1);
   }
   const rawType = typeFilter ?? opts.type;
-  const resolvedType = rawType ? TYPE_ALIASES[rawType.toLowerCase()] : void 0;
+  const resolvedType = rawType ? resolveTypeAlias(rawType) : void 0;
   if (rawType && !resolvedType) {
     p4.log.error(`Unknown type ${pc5.bold(rawType)}. Valid types: agent, tool, skill, storage, package`);
     process.exit(1);
@@ -1196,24 +1442,12 @@ async function listCommand(typeFilter, opts) {
   ${pc5.dim(parts.join("  \xB7  "))}
 `);
 }
-var TYPE_ALIASES;
 var init_list = __esm({
   "src/commands/list.ts"() {
     "use strict";
     init_config();
+    init_type_aliases();
     init_fetcher();
-    TYPE_ALIASES = {
-      agent: "agent",
-      agents: "agent",
-      tool: "tool",
-      tools: "tool",
-      skill: "skill",
-      skills: "skill",
-      storage: "storage",
-      storages: "storage",
-      package: "package",
-      packages: "package"
-    };
   }
 });
 
@@ -1458,8 +1692,8 @@ async function scanForComponents(cwd, paths) {
   const resolvedCwd = resolve(cwd);
   if (paths && paths.length > 0) {
     const results = [];
-    for (const p12 of paths) {
-      const absPath = resolve(resolvedCwd, p12);
+    for (const p13 of paths) {
+      const absPath = resolve(resolvedCwd, p13);
       if (await fileExists(join11(absPath, "registry.json"))) {
         results.push(absPath);
         continue;
@@ -2099,6 +2333,39 @@ var init_info = __esm({
   }
 });
 
+// src/commands/check.ts
+var check_exports = {};
+__export(check_exports, {
+  checkCommand: () => checkCommand
+});
+import * as p11 from "@clack/prompts";
+import pc10 from "picocolors";
+async function checkCommand(currentVersion) {
+  p11.intro(pc10.bgCyan(pc10.black(" kitn check ")));
+  p11.log.info(`kitn v${currentVersion}`);
+  const s = p11.spinner();
+  s.start("Checking for updates...");
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    s.stop(pc10.yellow("Could not reach the npm registry"));
+    p11.outro("Try again later.");
+    return;
+  }
+  if (isNewer(latest, currentVersion)) {
+    s.stop(pc10.yellow(`Update available: ${currentVersion} \u2192 ${latest}`));
+    p11.log.message(`  Run: ${pc10.cyan("npm i -g @kitnai/cli")}`);
+  } else {
+    s.stop(pc10.green("You're on the latest version"));
+  }
+  p11.outro("");
+}
+var init_check = __esm({
+  "src/commands/check.ts"() {
+    "use strict";
+    init_update_check();
+  }
+});
+
 // src/commands/registry.ts
 var registry_exports = {};
 __export(registry_exports, {
@@ -2106,8 +2373,8 @@ __export(registry_exports, {
   registryListCommand: () => registryListCommand,
   registryRemoveCommand: () => registryRemoveCommand
 });
-import * as p11 from "@clack/prompts";
-import pc10 from "picocolors";
+import * as p12 from "@clack/prompts";
+import pc11 from "picocolors";
 async function registryAddCommand(namespace, url, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const config = await readConfig(cwd);
@@ -2133,10 +2400,10 @@ async function registryAddCommand(namespace, url, opts = {}) {
     config.registries[namespace] = url;
   }
   await writeConfig(cwd, config);
-  p11.log.success(`Added registry ${pc10.bold(namespace)}`);
-  p11.log.message(pc10.dim(`  ${url}`));
-  if (opts.homepage) p11.log.message(pc10.dim(`  Homepage: ${opts.homepage}`));
-  if (opts.description) p11.log.message(pc10.dim(`  ${opts.description}`));
+  p12.log.success(`Added registry ${pc11.bold(namespace)}`);
+  p12.log.message(pc11.dim(`  ${url}`));
+  if (opts.homepage) p12.log.message(pc11.dim(`  Homepage: ${opts.homepage}`));
+  if (opts.description) p12.log.message(pc11.dim(`  ${opts.description}`));
 }
 async function registryRemoveCommand(namespace, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -2158,10 +2425,10 @@ async function registryRemoveCommand(namespace, opts = {}) {
   }
   delete config.registries[namespace];
   await writeConfig(cwd, config);
-  p11.log.success(`Removed registry ${pc10.bold(namespace)}`);
+  p12.log.success(`Removed registry ${pc11.bold(namespace)}`);
   if (affectedComponents.length > 0) {
-    p11.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
-` + affectedComponents.map((name) => `  ${pc10.yellow("!")} ${name}`).join("\n"));
+    p12.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
+` + affectedComponents.map((name) => `  ${pc11.yellow("!")} ${name}`).join("\n"));
   }
   return { affectedComponents };
 }
@@ -2176,15 +2443,15 @@ async function registryListCommand(opts = {}) {
     return { namespace, url, homepage, description };
   });
   if (entries.length === 0) {
-    p11.log.message(pc10.dim("  No registries configured."));
+    p12.log.message(pc11.dim("  No registries configured."));
   } else {
     const lines = [];
     for (const { namespace, url, homepage, description } of entries) {
-      lines.push(`  ${pc10.bold(namespace.padEnd(16))} ${pc10.dim(url)}`);
+      lines.push(`  ${pc11.bold(namespace.padEnd(16))} ${pc11.dim(url)}`);
       if (description) lines.push(`  ${" ".repeat(16)} ${description}`);
-      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc10.dim(homepage)}`);
+      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc11.dim(homepage)}`);
     }
-    p11.log.message(lines.join("\n"));
+    p12.log.message(lines.join("\n"));
   }
   return entries;
 }
@@ -2196,91 +2463,16 @@ var init_registry = __esm({
 });
 
 // src/index.ts
+init_update_check();
 import { Command } from "commander";
-
-// src/utils/update-check.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-import pc from "picocolors";
-var CACHE_DIR = join(homedir(), ".kitn");
-var CACHE_FILE = join(CACHE_DIR, "update-check.json");
-var CHECK_INTERVAL = 60 * 60 * 1e3;
-async function readCache() {
-  try {
-    const raw = await readFile(CACHE_FILE, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-async function writeCache(entry) {
-  try {
-    await mkdir(CACHE_DIR, { recursive: true });
-    await writeFile(CACHE_FILE, JSON.stringify(entry));
-  } catch {
-  }
-}
-async function fetchLatestVersion() {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3e3);
-    const res = await fetch("https://registry.npmjs.org/@kitnai/cli/latest", {
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data.version ?? null;
-  } catch {
-    return null;
-  }
-}
-function isNewer(latest, current) {
-  const [lMaj, lMin, lPat] = latest.split(".").map(Number);
-  const [cMaj, cMin, cPat] = current.split(".").map(Number);
-  if (lMaj !== cMaj) return lMaj > cMaj;
-  if (lMin !== cMin) return lMin > cMin;
-  return lPat > cPat;
-}
-function startUpdateCheck(currentVersion) {
-  let message = "";
-  const check = (async () => {
-    const cache = await readCache();
-    let latest = null;
-    if (cache && Date.now() - cache.checkedAt < CHECK_INTERVAL) {
-      latest = cache.latest;
-    } else {
-      latest = await fetchLatestVersion();
-      if (latest) {
-        await writeCache({ latest, checkedAt: Date.now() });
-      }
-    }
-    if (latest && isNewer(latest, currentVersion)) {
-      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")}`),
-        ""
-      ].join("\n");
-    }
-  })();
-  check.catch(() => {
-  });
-  return () => {
-    if (message) process.stderr.write(message);
-  };
-}
-
-// src/index.ts
-var VERSION = true ? "0.1.16" : "0.0.0-dev";
+var VERSION = true ? "0.1.18" : "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").action(async () => {
+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) => {
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  await initCommand2();
+  await initCommand2(opts);
 });
-program.command("add").description("Add components from the kitn registry").argument("[components...]", "component names to install").option("-o, --overwrite", "overwrite existing files without prompting").option("-t, --type <type>", "filter by component type").action(async (components, 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) => {
   const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
   await addCommand2(components, opts);
 });
@@ -2312,6 +2504,10 @@ program.command("info").description("Show details about a component").argument("
   const { infoCommand: infoCommand2 } = await Promise.resolve().then(() => (init_info(), info_exports));
   await infoCommand2(component);
 });
+program.command("check").description("Check for CLI updates").action(async () => {
+  const { checkCommand: checkCommand2 } = await Promise.resolve().then(() => (init_check(), check_exports));
+  await checkCommand2(VERSION);
+});
 var registry = program.command("registry").description("Manage component registries");
 registry.command("add").description("Add a component registry").argument("<namespace>", "registry namespace (e.g. @myteam)").argument("<url>", "URL template with {type} and {name} placeholders").option("-o, --overwrite", "overwrite if namespace already exists").option("--homepage <url>", "registry homepage URL").option("--description <text>", "short description of the registry").action(async (namespace, url, opts) => {
   const { registryAddCommand: registryAddCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));