@kitnai/cli 0.1.10 → 0.1.12

package/dist/index.js

@@ -13,6 +13,9 @@ var __export = (target, all) => {
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { join as join2 } from "path";
 import { z } from "zod";
+function getRegistryUrl(entry) {
+  return typeof entry === "string" ? entry : entry.url;
+}
 async function readConfig(projectDir) {
   try {
     const raw = await readFile2(join2(projectDir, CONFIG_FILE), "utf-8");
@@ -25,7 +28,16 @@ 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");
 }
-var componentType, installedComponentSchema, configSchema, CONFIG_FILE;
+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 join2(base, fileName);
+}
+var componentType, installedComponentSchema, registryEntrySchema, registryValueSchema, configSchema, CONFIG_FILE, typeToAliasKey;
 var init_config = __esm({
   "src/utils/config.ts"() {
     "use strict";
@@ -37,6 +49,12 @@ var init_config = __esm({
       files: z.array(z.string()),
       hash: z.string()
     });
+    registryEntrySchema = z.object({
+      url: z.string(),
+      homepage: z.string().optional(),
+      description: z.string().optional()
+    });
+    registryValueSchema = z.union([z.string(), registryEntrySchema]);
     configSchema = z.object({
       $schema: z.string().optional(),
       runtime: z.enum(["bun", "node", "deno"]),
@@ -48,105 +66,103 @@ var init_config = __esm({
         skills: z.string(),
         storage: z.string()
       }),
-      registries: z.record(z.string(), z.string()),
+      registries: z.record(z.string(), registryValueSchema),
       installed: z.record(z.string(), installedComponentSchema).optional()
     });
     CONFIG_FILE = "kitn.json";
+    typeToAliasKey = {
+      "kitn:agent": "agents",
+      "kitn:tool": "tools",
+      "kitn:skill": "skills",
+      "kitn:storage": "storage"
+    };
   }
 });
 
-// src/commands/init.ts
-var init_exports = {};
-__export(init_exports, {
-  initCommand: () => initCommand
-});
-import * as p from "@clack/prompts";
-import pc2 from "picocolors";
-async function initCommand() {
-  p.intro(pc2.bgCyan(pc2.black(" kitn ")));
-  const cwd = process.cwd();
-  const existing = await readConfig(cwd);
-  if (existing) {
-    p.log.warn("kitn.json already exists in this directory.");
-    const shouldContinue = await p.confirm({
-      message: "Overwrite existing configuration?",
-      initialValue: false
-    });
-    if (p.isCancel(shouldContinue) || !shouldContinue) {
-      p.cancel("Init cancelled.");
-      process.exit(0);
+// src/installers/tsconfig-patcher.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join3 } from "path";
+function stripJsonc(text3) {
+  return text3.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
+}
+function patchTsconfig(tsconfigContent, paths, removePrefixes) {
+  const config = JSON.parse(stripJsonc(tsconfigContent));
+  if (!config.compilerOptions) {
+    config.compilerOptions = {};
+  }
+  if (!config.compilerOptions.paths) {
+    config.compilerOptions.paths = {};
+  }
+  if (removePrefixes) {
+    for (const key of Object.keys(config.compilerOptions.paths)) {
+      if (removePrefixes.some((prefix) => key.startsWith(prefix))) {
+        delete config.compilerOptions.paths[key];
+      }
     }
   }
-  const runtime = await p.select({
-    message: "Which runtime do you use?",
-    options: [
-      { value: "bun", label: "Bun", hint: "recommended" },
-      { value: "node", label: "Node.js" },
-      { value: "deno", label: "Deno" }
-    ]
-  });
-  if (p.isCancel(runtime)) {
-    p.cancel("Init cancelled.");
-    process.exit(0);
+  for (const [key, value] of Object.entries(paths)) {
+    config.compilerOptions.paths[key] = value;
   }
-  const framework = await p.select({
-    message: "Which framework are you using?",
-    options: [
-      { value: "hono", label: "Hono", hint: "recommended" },
-      { value: "cloudflare", label: "Cloudflare Workers", hint: "coming soon" },
-      { value: "elysia", label: "Elysia", hint: "coming soon" },
-      { value: "fastify", label: "Fastify", hint: "coming soon" },
-      { value: "express", label: "Express", hint: "coming soon" }
-    ]
-  });
-  if (p.isCancel(framework)) {
-    p.cancel("Init cancelled.");
-    process.exit(0);
+  return JSON.stringify(config, null, 2) + "\n";
+}
+async function patchProjectTsconfig(projectDir, paths, removePrefixes) {
+  const tsconfigPath = join3(projectDir, "tsconfig.json");
+  let content;
+  try {
+    content = await readFile3(tsconfigPath, "utf-8");
+  } catch {
+    content = "{}";
   }
-  const base = await p.text({
-    message: "Where should kitn packages be installed?",
-    initialValue: "src/ai",
-    placeholder: "src/ai"
-  });
-  if (p.isCancel(base)) {
-    p.cancel("Init cancelled.");
-    process.exit(0);
+  const patched = patchTsconfig(content, paths, removePrefixes);
+  await writeFile3(tsconfigPath, patched);
+}
+var init_tsconfig_patcher = __esm({
+  "src/installers/tsconfig-patcher.ts"() {
+    "use strict";
   }
-  const baseDir = base;
-  const config = {
-    runtime,
-    framework,
-    aliases: {
-      base: baseDir,
-      agents: `${baseDir}/agents`,
-      tools: `${baseDir}/tools`,
-      skills: `${baseDir}/skills`,
-      storage: `${baseDir}/storage`
-    },
-    registries: {
-      "@kitn": "https://kitn-ai.github.io/registry/r/{type}/{name}.json"
-    }
-  };
-  const s = p.spinner();
-  s.start("Writing kitn.json");
-  await writeConfig(cwd, config);
-  s.stop("Created kitn.json");
-  p.outro(pc2.green("Done! Run `kitn add core` to install the engine, then `kitn add routes` for HTTP routes."));
+});
+
+// src/installers/barrel-manager.ts
+function createBarrelFile() {
+  return `${BARREL_COMMENT}
+${EXPORT_LINE}
+`;
 }
-var init_init = __esm({
-  "src/commands/init.ts"() {
+function addImportToBarrel(content, importPath) {
+  const importLine = `import "${importPath}";`;
+  if (content.includes(importLine)) return content;
+  const exportIndex = content.indexOf(EXPORT_LINE);
+  if (exportIndex === -1) {
+    return `${content.trimEnd()}
+${importLine}
+${EXPORT_LINE}
+`;
+  }
+  const before = content.slice(0, exportIndex);
+  const after = content.slice(exportIndex);
+  return `${before}${importLine}
+${after}`;
+}
+function removeImportFromBarrel(content, importPath) {
+  const importLine = `import "${importPath}";`;
+  return content.split("\n").filter((line) => line.trim() !== importLine).join("\n");
+}
+var EXPORT_LINE, BARREL_COMMENT;
+var init_barrel_manager = __esm({
+  "src/installers/barrel-manager.ts"() {
     "use strict";
-    init_config();
+    EXPORT_LINE = 'export { registerWithPlugin } from "@kitn/core";';
+    BARREL_COMMENT = "// Managed by kitn CLI \u2014 components auto-imported below";
   }
 });
 
 // src/utils/detect.ts
 import { access } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 async function detectPackageManager(dir) {
   for (const [lockfile, pm] of LOCKFILE_MAP) {
     try {
-      await access(join3(dir, lockfile));
+      await access(join4(dir, lockfile));
       return pm;
     } catch {
     }
@@ -168,6 +184,9 @@ var init_detect = __esm({
 });
 
 // src/registry/fetcher.ts
+function urlOf(entry) {
+  return typeof entry === "string" ? entry : entry.url;
+}
 var RegistryFetcher;
 var init_fetcher = __esm({
   "src/registry/fetcher.ts"() {
@@ -181,8 +200,9 @@ var init_fetcher = __esm({
         this.fetchFn = fetchFn ?? this.defaultFetch;
       }
       resolveUrl(name, typeDir, namespace = "@kitn", version) {
-        const template = this.registries[namespace];
-        if (!template) throw new Error(`No registry configured for ${namespace}`);
+        const entry = this.registries[namespace];
+        if (!entry) throw new Error(`No registry configured for ${namespace}`);
+        const template = urlOf(entry);
         const fileName = version ? `${name}@${version}` : name;
         return template.replace("{name}", fileName).replace("{type}", typeDir);
       }
@@ -194,8 +214,9 @@ var init_fetcher = __esm({
         return this.cache.get(url);
       }
       async fetchIndex(namespace = "@kitn") {
-        const template = this.registries[namespace];
-        if (!template) throw new Error(`No registry configured for ${namespace}`);
+        const entry = this.registries[namespace];
+        if (!entry) throw new Error(`No registry configured for ${namespace}`);
+        const template = urlOf(entry);
         const baseUrl = template.replace("{type}/{name}.json", "registry.json");
         const res = await fetch(baseUrl);
         if (!res.ok) throw new Error(`Failed to fetch registry index: ${res.statusText}`);
@@ -269,7 +290,7 @@ var init_resolver = __esm({
 });
 
 // src/installers/file-writer.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2, access as access2 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir2, access as access2 } from "fs/promises";
 import { dirname } from "path";
 import { createPatch } from "diff";
 async function checkFileStatus(filePath, newContent) {
@@ -278,7 +299,7 @@ async function checkFileStatus(filePath, newContent) {
   } catch {
     return "new" /* New */;
   }
-  const existing = await readFile3(filePath, "utf-8");
+  const existing = await readFile4(filePath, "utf-8");
   return existing === newContent ? "identical" /* Identical */ : "different" /* Different */;
 }
 function generateDiff(filePath, oldContent, newContent) {
@@ -286,14 +307,14 @@ function generateDiff(filePath, oldContent, newContent) {
 }
 async function readExistingFile(filePath) {
   try {
-    return await readFile3(filePath, "utf-8");
+    return await readFile4(filePath, "utf-8");
   } catch {
     return null;
   }
 }
 async function writeComponentFile(filePath, content) {
   await mkdir2(dirname(filePath), { recursive: true });
-  await writeFile3(filePath, content);
+  await writeFile4(filePath, content);
 }
 var init_file_writer = __esm({
   "src/installers/file-writer.ts"() {
@@ -327,10 +348,10 @@ var init_dep_installer = __esm({
 });
 
 // src/installers/env-writer.ts
-import * as p2 from "@clack/prompts";
-import pc3 from "picocolors";
-import { readFile as readFile4, writeFile as writeFile4, access as access3 } from "fs/promises";
-import { join as join4 } from "path";
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+import { readFile as readFile5, writeFile as writeFile5, access as access3 } from "fs/promises";
+import { join as join5 } from "path";
 function parseEnvKeys(content) {
   const keys = /* @__PURE__ */ new Set();
   for (const line of content.split("\n")) {
@@ -345,7 +366,7 @@ function parseEnvKeys(content) {
 }
 async function readEnvFile(path) {
   try {
-    return await readFile4(path, "utf-8");
+    return await readFile5(path, "utf-8");
   } catch {
     return "";
   }
@@ -362,8 +383,8 @@ function collectEnvVars(items) {
 async function handleEnvVars(cwd, envVars) {
   const keys = Object.keys(envVars);
   if (keys.length === 0) return;
-  const envPath = join4(cwd, ".env");
-  const examplePath = join4(cwd, ".env.example");
+  const envPath = join5(cwd, ".env");
+  const examplePath = join5(cwd, ".env.example");
   const envContent = await readEnvFile(envPath);
   const exampleContent = await readEnvFile(examplePath);
   const envKeys = parseEnvKeys(envContent);
@@ -378,25 +399,25 @@ async function handleEnvVars(cwd, envVars) {
       lines.push(`# ${config.description}${config.url ? ` (${config.url})` : ""}`);
       lines.push(`${key}=`);
     }
-    await writeFile4(examplePath, exampleContent + lines.join("\n") + "\n");
-    p2.log.info(`Updated ${pc3.cyan(".env.example")} with ${missingFromExample.length} variable(s)`);
+    await writeFile5(examplePath, exampleContent + lines.join("\n") + "\n");
+    p.log.info(`Updated ${pc2.cyan(".env.example")} with ${missingFromExample.length} variable(s)`);
   }
   if (missingFromEnv.length === 0) return;
-  p2.log.message("");
-  p2.log.warn(
+  p.log.message("");
+  p.log.warn(
     `${missingFromEnv.length} environment variable(s) needed:`
   );
   for (const key of missingFromEnv) {
     const config = envVars[key];
-    const req = config.required !== false ? pc3.red("*") : "";
-    p2.log.message(`  ${pc3.yellow(key)}${req}: ${config.description}${config.url ? pc3.dim(` -> ${config.url}`) : ""}`);
+    const req = config.required !== false ? pc2.red("*") : "";
+    p.log.message(`  ${pc2.yellow(key)}${req}: ${config.description}${config.url ? pc2.dim(` -> ${config.url}`) : ""}`);
   }
-  const shouldPrompt = await p2.confirm({
+  const shouldPrompt = await p.confirm({
     message: "Would you like to enter values now?",
     initialValue: true
   });
-  if (p2.isCancel(shouldPrompt) || !shouldPrompt) {
-    p2.log.info(`Add them to ${pc3.cyan(".env")} when ready.`);
+  if (p.isCancel(shouldPrompt) || !shouldPrompt) {
+    p.log.info(`Add them to ${pc2.cyan(".env")} when ready.`);
     return;
   }
   const newEntries = [];
@@ -405,17 +426,17 @@ async function handleEnvVars(cwd, envVars) {
     const isSecret = config.secret !== false;
     let value;
     if (isSecret) {
-      value = await p2.password({
+      value = await p.password({
         message: `${key}:`
       });
     } else {
-      value = await p2.text({
+      value = await p.text({
         message: `${key}:`,
         placeholder: config.description
       });
     }
-    if (p2.isCancel(value)) {
-      p2.log.info(`Skipped remaining variables. Add them to ${pc3.cyan(".env")} when ready.`);
+    if (p.isCancel(value)) {
+      p.log.info(`Skipped remaining variables. Add them to ${pc2.cyan(".env")} when ready.`);
       break;
     }
     if (value) {
@@ -427,8 +448,8 @@ async function handleEnvVars(cwd, envVars) {
     const lines = [];
     if (existingEnv && !existingEnv.endsWith("\n")) lines.push("");
     lines.push(...newEntries);
-    await writeFile4(envPath, existingEnv + lines.join("\n") + "\n");
-    p2.log.success(`Wrote ${newEntries.length} variable(s) to ${pc3.cyan(".env")}`);
+    await writeFile5(envPath, existingEnv + lines.join("\n") + "\n");
+    p.log.success(`Wrote ${newEntries.length} variable(s) to ${pc2.cyan(".env")}`);
   }
 }
 var init_env_writer = __esm({
@@ -438,7 +459,7 @@ var init_env_writer = __esm({
 });
 
 // src/installers/import-rewriter.ts
-import { relative, join as join5 } from "path";
+import { relative, join as join6 } from "path";
 function rewriteKitnImports(content, fileType, fileName, aliases) {
   const sourceAliasKey = TYPE_TO_ALIAS_KEY[fileType];
   if (!sourceAliasKey) return content;
@@ -450,7 +471,7 @@ function rewriteKitnImports(content, fileType, fileName, aliases) {
         return `${prefix}@kitn/${type}/${targetPath}${quote}`;
       }
       const targetDir = aliases[type];
-      const targetFile = join5(targetDir, targetPath);
+      const targetFile = join6(targetDir, targetPath);
       let rel = relative(sourceDir, targetFile);
       rel = rel.split("\\").join("/");
       if (!rel.startsWith(".")) {
@@ -474,76 +495,6 @@ var init_import_rewriter = __esm({
   }
 });
 
-// src/installers/tsconfig-patcher.ts
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { join as join6 } from "path";
-function stripJsonc(text3) {
-  return text3.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
-}
-function patchTsconfig(tsconfigContent, paths) {
-  const config = JSON.parse(stripJsonc(tsconfigContent));
-  if (!config.compilerOptions) {
-    config.compilerOptions = {};
-  }
-  if (!config.compilerOptions.paths) {
-    config.compilerOptions.paths = {};
-  }
-  for (const [key, value] of Object.entries(paths)) {
-    config.compilerOptions.paths[key] = value;
-  }
-  return JSON.stringify(config, null, 2) + "\n";
-}
-async function patchProjectTsconfig(projectDir, paths) {
-  const tsconfigPath = join6(projectDir, "tsconfig.json");
-  let content;
-  try {
-    content = await readFile5(tsconfigPath, "utf-8");
-  } catch {
-    content = "{}";
-  }
-  const patched = patchTsconfig(content, paths);
-  await writeFile5(tsconfigPath, patched);
-}
-var init_tsconfig_patcher = __esm({
-  "src/installers/tsconfig-patcher.ts"() {
-    "use strict";
-  }
-});
-
-// src/installers/barrel-manager.ts
-function createBarrelFile() {
-  return `${BARREL_COMMENT}
-${EXPORT_LINE}
-`;
-}
-function addImportToBarrel(content, importPath) {
-  const importLine = `import "${importPath}";`;
-  if (content.includes(importLine)) return content;
-  const exportIndex = content.indexOf(EXPORT_LINE);
-  if (exportIndex === -1) {
-    return `${content.trimEnd()}
-${importLine}
-${EXPORT_LINE}
-`;
-  }
-  const before = content.slice(0, exportIndex);
-  const after = content.slice(exportIndex);
-  return `${before}${importLine}
-${after}`;
-}
-function removeImportFromBarrel(content, importPath) {
-  const importLine = `import "${importPath}";`;
-  return content.split("\n").filter((line) => line.trim() !== importLine).join("\n");
-}
-var EXPORT_LINE, BARREL_COMMENT;
-var init_barrel_manager = __esm({
-  "src/installers/barrel-manager.ts"() {
-    "use strict";
-    EXPORT_LINE = 'export { registerWithPlugin } from "@kitnai/core";';
-    BARREL_COMMENT = "// Managed by kitn CLI \u2014 components auto-imported below";
-  }
-});
-
 // src/utils/hash.ts
 import { createHash } from "crypto";
 function contentHash(content) {
@@ -674,22 +625,22 @@ var add_exports = {};
 __export(add_exports, {
   addCommand: () => addCommand
 });
-import * as p3 from "@clack/prompts";
-import pc4 from "picocolors";
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
 import { join as join7 } from "path";
 import { existsSync } from "fs";
 import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir3 } from "fs/promises";
 import { relative as relative2 } from "path";
 async function addCommand(components, opts) {
-  p3.intro(pc4.bgCyan(pc4.black(" kitn add ")));
+  p2.intro(pc3.bgCyan(pc3.black(" kitn add ")));
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p3.log.error("No kitn.json found. Run `kitn init` first.");
+    p2.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   if (components.length === 0) {
-    p3.log.error("Please specify at least one component to add.");
+    p2.log.error("Please specify at least one component to add.");
     process.exit(1);
   }
   const resolvedComponents = components.map((c) => {
@@ -701,7 +652,7 @@ async function addCommand(components, opts) {
   });
   const refs = resolvedComponents.map(parseComponentRef);
   const fetcher = new RegistryFetcher(config.registries);
-  const s = p3.spinner();
+  const s = p2.spinner();
   s.start("Resolving dependencies...");
   let resolved;
   try {
@@ -714,16 +665,16 @@ async function addCommand(components, opts) {
       return fetcher.fetchItem(name, dir, ref.namespace, ref.version);
     });
   } catch (err) {
-    s.stop(pc4.red("Failed to resolve dependencies"));
-    p3.log.error(err.message);
+    s.stop(pc3.red("Failed to resolve dependencies"));
+    p2.log.error(err.message);
     process.exit(1);
   }
   s.stop(`Resolved ${resolved.length} component(s)`);
-  p3.log.info("Components to install:");
+  p2.log.info("Components to install:");
   for (const item of resolved) {
     const isExplicit = resolvedComponents.includes(item.name) || components.includes(item.name);
-    const label = isExplicit ? item.name : `${item.name} ${pc4.dim("(dependency)")}`;
-    p3.log.message(`  ${pc4.cyan(label)}`);
+    const label = isExplicit ? item.name : `${item.name} ${pc3.dim("(dependency)")}`;
+    p2.log.message(`  ${pc3.cyan(label)}`);
   }
   const created = [];
   const updated = [];
@@ -752,15 +703,15 @@ async function addCommand(components, opts) {
             } else {
               const existing = await readExistingFile(targetPath);
               const diff = generateDiff(relativePath, existing ?? "", file.content);
-              p3.log.message(pc4.dim(diff));
-              const action = await p3.select({
+              p2.log.message(pc3.dim(diff));
+              const action = await p2.select({
                 message: `${relativePath} already exists and differs. What to do?`,
                 options: [
                   { value: "skip", label: "Keep local version" },
                   { value: "overwrite", label: "Overwrite with registry version" }
                 ]
               });
-              if (!p3.isCancel(action) && action === "overwrite") {
+              if (!p2.isCancel(action) && action === "overwrite") {
                 await writeComponentFile(targetPath, file.content);
                 updated.push(relativePath);
               } else {
@@ -770,15 +721,6 @@ async function addCommand(components, opts) {
             break;
         }
       }
-      if (item.tsconfig) {
-        const resolvedPaths = {};
-        const installDir = item.installDir ?? item.name;
-        for (const [key, values] of Object.entries(item.tsconfig)) {
-          resolvedPaths[key] = values.map((v) => `./${join7(baseDir2, installDir, v)}`);
-        }
-        await patchProjectTsconfig(cwd, resolvedPaths);
-        p3.log.info(`Patched tsconfig.json with paths: ${Object.keys(resolvedPaths).join(", ")}`);
-      }
       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 };
@@ -792,6 +734,8 @@ async function addCommand(components, opts) {
       };
       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;
       for (const file of item.files) {
         const aliasKey = (() => {
           switch (item.type) {
@@ -806,8 +750,9 @@ async function addCommand(components, opts) {
           }
         })();
         const fileName = file.path.split("/").pop();
-        const targetPath = join7(cwd, config.aliases[aliasKey], fileName);
-        const relativePath = join7(config.aliases[aliasKey], fileName);
+        const installPath = getInstallPath(config, item.type, fileName, ns);
+        const targetPath = join7(cwd, installPath);
+        const relativePath = installPath;
         const content = rewriteKitnImports(file.content, item.type, fileName, config.aliases);
         const status = await checkFileStatus(targetPath, content);
         switch (status) {
@@ -825,15 +770,15 @@ async function addCommand(components, opts) {
             } else {
               const existing = await readExistingFile(targetPath);
               const diff = generateDiff(relativePath, existing ?? "", content);
-              p3.log.message(pc4.dim(diff));
-              const action = await p3.select({
+              p2.log.message(pc3.dim(diff));
+              const action = await p2.select({
                 message: `${relativePath} already exists and differs. What to do?`,
                 options: [
                   { value: "skip", label: "Keep local version" },
                   { value: "overwrite", label: "Overwrite with registry version" }
                 ]
               });
-              if (!p3.isCancel(action) && action === "overwrite") {
+              if (!p2.isCancel(action) && action === "overwrite") {
                 await writeComponentFile(targetPath, content);
                 updated.push(relativePath);
               } else {
@@ -848,27 +793,14 @@ async function addCommand(components, opts) {
         const fn = f.path.split("/").pop();
         return rewriteKitnImports(f.content, item.type, fn, config.aliases);
       }).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}`;
+      const installedKey = ns === "@kitn" ? item.name : `${ns}/${item.name}`;
       installed[installedKey] = {
-        registry: ref.namespace,
+        registry: ns,
         version: item.version ?? "1.0.0",
         installedAt: (/* @__PURE__ */ new Date()).toISOString(),
         files: item.files.map((f) => {
-          const aliasKey = (() => {
-            switch (item.type) {
-              case "kitn:agent":
-                return "agents";
-              case "kitn:tool":
-                return "tools";
-              case "kitn:skill":
-                return "skills";
-              case "kitn:storage":
-                return "storage";
-            }
-          })();
           const fileName = f.path.split("/").pop();
-          return join7(config.aliases[aliasKey], fileName);
+          return getInstallPath(config, item.type, fileName, ns);
         }),
         hash: contentHash(allContent)
       };
@@ -882,19 +814,11 @@ async function addCommand(components, opts) {
   const barrelImports = [];
   for (const item of resolved) {
     if (!BARREL_ELIGIBLE.has(item.type)) continue;
+    const ref = refs.find((r) => r.name === item.name) ?? { namespace: "@kitn", name: item.name, version: void 0 };
     for (const file of item.files) {
-      const aliasKey = (() => {
-        switch (item.type) {
-          case "kitn:agent":
-            return "agents";
-          case "kitn:tool":
-            return "tools";
-          case "kitn:skill":
-            return "skills";
-        }
-      })();
       const fileName = file.path.split("/").pop();
-      const filePath = join7(cwd, config.aliases[aliasKey], fileName);
+      const installPath = getInstallPath(config, item.type, fileName, ref.namespace);
+      const filePath = join7(cwd, installPath);
       const importPath = "./" + relative2(barrelDir, filePath).replace(/\\/g, "/");
       barrelImports.push(importPath);
     }
@@ -912,21 +836,16 @@ async function addCommand(components, opts) {
       barrelContent = addImportToBarrel(barrelContent, importPath);
     }
     await writeFile6(barrelPath, barrelContent);
-    p3.log.info(`Updated barrel file: ${join7(baseDir, "index.ts")}`);
+    p2.log.info(`Updated barrel file: ${join7(baseDir, "index.ts")}`);
     if (!barrelExisted) {
-      p3.note(
+      p2.note(
         [
-          `import { createAIPlugin } from "@kitnai/hono";`,
-          `import { registerWithPlugin } from "./ai";`,
-          ``,
-          `const plugin = createAIPlugin({`,
-          `  model: (model) => yourProvider(model ?? "default-model"),`,
-          `});`,
+          `import { ai } from "./${baseDir}/plugin.js";`,
           ``,
-          `registerWithPlugin(plugin);`,
-          `app.route("/api", plugin.app);`
+          `app.route("/api", ai.router);`,
+          `await ai.initialize();`
         ].join("\n"),
-        "Add this to your app setup"
+        "Add this to your server entry point"
       );
     }
   }
@@ -940,58 +859,49 @@ async function addCommand(components, opts) {
         installDependencies(pm, uniqueDeps, cwd);
         s.stop("Dependencies installed");
       } catch {
-        s.stop(pc4.yellow("Some dependencies failed to install"));
+        s.stop(pc3.yellow("Some dependencies failed to install"));
       }
     }
   }
   if (created.length > 0) {
-    p3.log.success(`Created ${created.length} file(s):`);
-    for (const f of created) p3.log.message(`  ${pc4.green("+")} ${f}`);
+    p2.log.success(`Created ${created.length} file(s):`);
+    for (const f of created) p2.log.message(`  ${pc3.green("+")} ${f}`);
   }
   if (updated.length > 0) {
-    p3.log.success(`Updated ${updated.length} file(s):`);
-    for (const f of updated) p3.log.message(`  ${pc4.yellow("~")} ${f}`);
+    p2.log.success(`Updated ${updated.length} file(s):`);
+    for (const f of updated) p2.log.message(`  ${pc3.yellow("~")} ${f}`);
   }
   if (skipped.length > 0) {
-    p3.log.info(`Skipped ${skipped.length} file(s):`);
-    for (const f of skipped) p3.log.message(`  ${pc4.dim("-")} ${f}`);
+    p2.log.info(`Skipped ${skipped.length} file(s):`);
+    for (const f of skipped) p2.log.message(`  ${pc3.dim("-")} ${f}`);
   }
   const allEnvVars = collectEnvVars(resolved);
   await handleEnvVars(cwd, allEnvVars);
   for (const item of resolved) {
     if (item.docs) {
-      p3.log.info(`${pc4.bold(item.name)}: ${item.docs}`);
+      p2.log.info(`${pc3.bold(item.name)}: ${item.docs}`);
     }
   }
   const installedNames = new Set(resolved.map((r) => r.name));
   const hints = [];
   if (installedNames.has("core") && !installedNames.has(config.framework ?? "hono")) {
-    hints.push(`Run ${pc4.cyan(`kitn add routes`)} to install the HTTP adapter.`);
+    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)) {
-    hints.push(`Add this to your server entry point:`);
-    if (fw === "hono") {
-      hints.push("");
-      hints.push(pc4.dim(`  import { Hono } from "hono";`));
-      hints.push(pc4.dim(`  import { createAIPlugin } from "@kitnai/hono";`));
-      hints.push(pc4.dim(`  import { yourProvider } from "your-ai-provider";`));
-      hints.push(pc4.dim(``));
-      hints.push(pc4.dim(`  const plugin = createAIPlugin({`));
-      hints.push(pc4.dim(`    model: (model) => yourProvider(model ?? "default-model"),`));
-      hints.push(pc4.dim(`  });`));
-      hints.push(pc4.dim(``));
-      hints.push(pc4.dim(`  const app = new Hono();`));
-      hints.push(pc4.dim(`  app.route("/api", plugin.app);`));
-      hints.push(pc4.dim(`  await plugin.initialize();`));
-      hints.push("");
-    }
+    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}/plugin.js";`));
+    hints.push(pc3.dim(``));
+    hints.push(pc3.dim(`  app.route("/api", ai.router);`));
+    hints.push(pc3.dim(`  await ai.initialize();`));
+    hints.push("");
   }
   if (hints.length > 0) {
-    p3.log.message(pc4.bold("\nNext steps:"));
-    for (const hint of hints) p3.log.message(hint);
+    p2.log.message(pc3.bold("\nNext steps:"));
+    for (const hint of hints) p2.log.message(hint);
   }
-  p3.outro(pc4.green("Done!"));
+  p2.outro(pc3.green("Done!"));
 }
 var init_add = __esm({
   "src/commands/add.ts"() {
@@ -1004,7 +914,6 @@ var init_add = __esm({
     init_dep_installer();
     init_env_writer();
     init_import_rewriter();
-    init_tsconfig_patcher();
     init_barrel_manager();
     init_hash();
     init_parse_ref();
@@ -1012,6 +921,130 @@ var init_add = __esm({
   }
 });
 
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+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() {
+  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 (p3.isCancel(shouldContinue) || !shouldContinue) {
+      p3.cancel("Init cancelled.");
+      process.exit(0);
+    }
+  }
+  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);
+  }
+  const baseDir = base;
+  const config = {
+    runtime,
+    framework: "hono",
+    aliases: {
+      base: baseDir,
+      agents: `${baseDir}/agents`,
+      tools: `${baseDir}/tools`,
+      skills: `${baseDir}/skills`,
+      storage: `${baseDir}/storage`
+    },
+    registries: {
+      "@kitn": {
+        url: "https://kitn-ai.github.io/registry/r/{type}/{name}.json",
+        homepage: "https://kitn.ai",
+        description: "Official kitn AI agent components"
+      }
+    }
+  };
+  const s = p3.spinner();
+  s.start("Writing kitn.json");
+  await writeConfig(cwd, config);
+  s.stop("Created kitn.json");
+  await patchProjectTsconfig(
+    cwd,
+    { "@kitn/*": [`./${baseDir}/*`] },
+    ["@kitn", "@kitnai"]
+  );
+  p3.log.info(`Patched tsconfig.json with path: ${pc4.bold("@kitn/*")}`);
+  p3.log.info("Installing core engine and routes...");
+  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);
+  p3.log.success(`Created ${pc4.bold(baseDir + "/plugin.ts")} \u2014 configure your AI provider there`);
+  p3.note(
+    [
+      `import { ai } from "./${baseDir}/plugin.js";`,
+      ``,
+      `app.route("/api", ai.router);`,
+      `await ai.initialize();`
+    ].join("\n"),
+    "Add this to your server entry point:"
+  );
+  p3.outro("Done!");
+}
+var PLUGIN_TEMPLATE;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_config();
+    init_tsconfig_patcher();
+    init_barrel_manager();
+    init_add();
+    PLUGIN_TEMPLATE = `import { createAIPlugin } from "@kitn/hono-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);
+`;
+  }
+});
+
 // src/commands/list.ts
 var list_exports = {};
 __export(list_exports, {
@@ -1066,6 +1099,7 @@ async function listCommand(typeFilter, opts) {
   for (const item of allItems) {
     const group = item.type.replace("kitn:", "");
     if (resolvedType && group !== resolvedType) continue;
+    if (!resolvedType && group === "package") continue;
     if (!typeGroups.has(group)) typeGroups.set(group, []);
     typeGroups.get(group).push(item);
   }
@@ -1121,7 +1155,8 @@ async function listCommand(typeFilter, opts) {
     console.log(pc5.dim(`
   No ${resolvedType} components found.`));
   }
-  const parts = [`${installedCount} installed`, `${allItems.length - installedCount} available`];
+  const totalShown = [...typeGroups.values()].reduce((sum, items) => sum + items.length, 0);
+  const parts = [`${installedCount} installed`, `${totalShown - installedCount} available`];
   if (updateCount > 0) parts.push(pc5.yellow(`${updateCount} update${updateCount === 1 ? "" : "s"}`));
   console.log(`
   ${pc5.dim(parts.join("  \xB7  "))}
@@ -1154,7 +1189,7 @@ __export(diff_exports, {
   diffCommand: () => diffCommand
 });
 import * as p5 from "@clack/prompts";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 async function diffCommand(componentName) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
@@ -1184,8 +1219,8 @@ async function diffCommand(componentName) {
   for (const file of registryItem.files) {
     if (indexItem.type === "kitn:package") {
       const baseDir = config.aliases.base ?? "src/ai";
-      const localPath = join8(cwd, baseDir, file.path);
-      const relativePath = join8(baseDir, file.path);
+      const localPath = join9(cwd, baseDir, file.path);
+      const relativePath = join9(baseDir, file.path);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
         p5.log.warn(`${relativePath}: file missing locally`);
@@ -1209,7 +1244,7 @@ async function diffCommand(componentName) {
             return "storage";
         }
       })();
-      const localPath = join8(cwd, config.aliases[aliasKey], fileName);
+      const localPath = join9(cwd, config.aliases[aliasKey], fileName);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
         p5.log.warn(`${fileName}: file missing locally`);
@@ -1243,8 +1278,8 @@ __export(remove_exports, {
 });
 import * as p6 from "@clack/prompts";
 import pc6 from "picocolors";
-import { join as join9, relative as relative3, dirname as dirname3 } from "path";
-import { unlink, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { join as join10, relative as relative3, dirname as dirname3 } from "path";
+import { unlink, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 async function removeCommand(componentName) {
   const cwd = process.cwd();
@@ -1272,15 +1307,15 @@ async function removeCommand(componentName) {
   const deleted = [];
   for (const filePath of installed.files) {
     try {
-      await unlink(join9(cwd, filePath));
+      await unlink(join10(cwd, filePath));
       deleted.push(filePath);
     } catch {
       p6.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
     }
   }
   const baseDir = config.aliases.base ?? "src/ai";
-  const barrelPath = join9(cwd, baseDir, "index.ts");
-  const barrelDir = join9(cwd, baseDir);
+  const barrelPath = join10(cwd, baseDir, "index.ts");
+  const barrelDir = join10(cwd, baseDir);
   const barrelEligibleDirs = /* @__PURE__ */ new Set([
     config.aliases.agents,
     config.aliases.tools,
@@ -1292,7 +1327,7 @@ async function removeCommand(componentName) {
     for (const filePath of deleted) {
       const fileDir = dirname3(filePath);
       if (!barrelEligibleDirs.has(fileDir)) continue;
-      const importPath = "./" + relative3(barrelDir, join9(cwd, filePath)).replace(/\\/g, "/");
+      const importPath = "./" + relative3(barrelDir, join10(cwd, filePath)).replace(/\\/g, "/");
       const updated = removeImportFromBarrel(barrelContent, importPath);
       if (updated !== barrelContent) {
         barrelContent = updated;
@@ -1300,8 +1335,8 @@ async function removeCommand(componentName) {
       }
     }
     if (barrelChanged) {
-      await writeFile7(barrelPath, barrelContent);
-      p6.log.info(`Updated barrel file: ${join9(baseDir, "index.ts")}`);
+      await writeFile8(barrelPath, barrelContent);
+      p6.log.info(`Updated barrel file: ${join10(baseDir, "index.ts")}`);
     }
   }
   delete config.installed[installedKey];
@@ -1355,8 +1390,8 @@ var init_update = __esm({
 });
 
 // src/registry/build-output.ts
-import { readdir, writeFile as writeFile8, mkdir as mkdir4, access as access4 } from "fs/promises";
-import { join as join10, resolve } from "path";
+import { readdir, writeFile as writeFile9, mkdir as mkdir5, access as access4 } from "fs/promises";
+import { join as join11, resolve } from "path";
 async function fileExists(path) {
   try {
     await access4(path);
@@ -1373,13 +1408,13 @@ async function walkForRegistryJson(dir) {
   } catch {
     return results;
   }
-  if (await fileExists(join10(dir, "registry.json"))) {
+  if (await fileExists(join11(dir, "registry.json"))) {
     results.push(dir);
     return results;
   }
   for (const entry of entries) {
     if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
-      const subResults = await walkForRegistryJson(join10(dir, entry.name));
+      const subResults = await walkForRegistryJson(join11(dir, entry.name));
       results.push(...subResults);
     }
   }
@@ -1391,7 +1426,7 @@ async function scanForComponents(cwd, paths) {
     const results = [];
     for (const p12 of paths) {
       const absPath = resolve(resolvedCwd, p12);
-      if (await fileExists(join10(absPath, "registry.json"))) {
+      if (await fileExists(join11(absPath, "registry.json"))) {
         results.push(absPath);
         continue;
       }
@@ -1403,8 +1438,8 @@ async function scanForComponents(cwd, paths) {
       }
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const subDir = join10(absPath, entry.name);
-          if (await fileExists(join10(subDir, "registry.json"))) {
+          const subDir = join11(absPath, entry.name);
+          if (await fileExists(join11(subDir, "registry.json"))) {
             results.push(subDir);
           }
         }
@@ -1429,21 +1464,21 @@ async function writeRegistryOutput(outputDir, items) {
   const indexItems = [];
   for (const item of items) {
     const dir = typeToDir[item.type];
-    const typeDir = join10(resolvedOutput, dir);
-    await mkdir4(typeDir, { recursive: true });
+    const typeDir = join11(resolvedOutput, dir);
+    await mkdir5(typeDir, { recursive: true });
     const itemJson = JSON.stringify(item, null, 2);
-    const latestPath = join10(typeDir, `${item.name}.json`);
+    const latestPath = join11(typeDir, `${item.name}.json`);
     const latestRelative = `${dir}/${item.name}.json`;
-    await writeFile8(latestPath, itemJson, "utf-8");
+    await writeFile9(latestPath, itemJson, "utf-8");
     written.push(latestRelative);
     if (item.version) {
       const versionedFilename = `${item.name}@${item.version}.json`;
-      const versionedPath = join10(typeDir, versionedFilename);
+      const versionedPath = join11(typeDir, versionedFilename);
       const versionedRelative = `${dir}/${versionedFilename}`;
       if (await fileExists(versionedPath)) {
         skipped.push(versionedRelative);
       } else {
-        await writeFile8(versionedPath, itemJson, "utf-8");
+        await writeFile9(versionedPath, itemJson, "utf-8");
         written.push(versionedRelative);
       }
     }
@@ -1478,8 +1513,8 @@ async function writeRegistryOutput(outputDir, items) {
     version: "1",
     items: indexItems
   };
-  const indexPath = join10(resolvedOutput, "registry.json");
-  await writeFile8(indexPath, JSON.stringify(index, null, 2), "utf-8");
+  const indexPath = join11(resolvedOutput, "registry.json");
+  await writeFile9(indexPath, JSON.stringify(index, null, 2), "utf-8");
   written.push("registry.json");
   return { written, skipped };
 }
@@ -1502,7 +1537,7 @@ var init_build_output = __esm({
 
 // src/registry/builder.ts
 import { readFile as readFile9, readdir as readdir2 } from "fs/promises";
-import { join as join11, relative as relative5 } from "path";
+import { join as join12, relative as relative5 } from "path";
 function isExcludedDevDep(name) {
   return EXCLUDED_DEV_DEPS.has(name) || name.startsWith("@types/");
 }
@@ -1514,7 +1549,7 @@ async function readTsFiles(dir, baseDir, exclude) {
   const results = [];
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join11(dir, entry.name);
+    const fullPath = join12(dir, entry.name);
     const relPath = relative5(baseDir, fullPath);
     if (entry.isDirectory()) {
       const nested = await readTsFiles(fullPath, baseDir, exclude);
@@ -1532,7 +1567,7 @@ async function readTsFiles(dir, baseDir, exclude) {
 async function buildComponent(componentDir) {
   let rawConfig;
   try {
-    rawConfig = await readFile9(join11(componentDir, "registry.json"), "utf-8");
+    rawConfig = await readFile9(join12(componentDir, "registry.json"), "utf-8");
   } catch {
     throw new Error(
       `No registry.json found in ${componentDir}. Every component must have a registry.json file.`
@@ -1548,7 +1583,7 @@ async function buildComponent(componentDir) {
   }
   let pkg = null;
   try {
-    const rawPkg = await readFile9(join11(componentDir, "package.json"), "utf-8");
+    const rawPkg = await readFile9(join12(componentDir, "package.json"), "utf-8");
     pkg = JSON.parse(rawPkg);
   } catch {
   }
@@ -1605,7 +1640,7 @@ async function buildComponent(componentDir) {
   let files;
   if (isPackage) {
     const sourceDir = config.sourceDir ?? "src";
-    const sourcePath = join11(componentDir, sourceDir);
+    const sourcePath = join12(componentDir, sourceDir);
     const exclude = config.exclude ?? [];
     let tsFiles;
     try {
@@ -1628,7 +1663,7 @@ async function buildComponent(componentDir) {
     }
     files = await Promise.all(
       config.files.map(async (filePath) => {
-        const fullPath = join11(componentDir, filePath);
+        const fullPath = join12(componentDir, filePath);
         let content;
         try {
           content = await readFile9(fullPath, "utf-8");
@@ -1764,8 +1799,8 @@ __export(create_exports, {
 });
 import * as p9 from "@clack/prompts";
 import pc8 from "picocolors";
-import { join as join12 } from "path";
-import { mkdir as mkdir5, writeFile as writeFile9 } from "fs/promises";
+import { join as join13 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
 function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
@@ -1791,7 +1826,7 @@ function generateRegistryJson(type, name, sourceFile) {
 }
 function generateAgentSource(name) {
   const camel = toCamelCase(name);
-  return `import { registerAgent } from "@kitnai/core";
+  return `import { registerAgent } from "@kitn/core";
 
 const SYSTEM_PROMPT = "You are a helpful assistant.";
 
@@ -1805,7 +1840,7 @@ registerAgent({
 }
 function generateToolSource(name) {
   const camel = toCamelCase(name);
-  return `import { registerTool } from "@kitnai/core";
+  return `import { registerTool } from "@kitn/core";
 import { tool } from "ai";
 import { z } from "zod";
 
@@ -1842,7 +1877,7 @@ Describe what this skill does and how to use it.
 }
 function generateStorageSource(name) {
   const camel = toCamelCase("create-" + name);
-  return `import type { StorageProvider } from "@kitnai/core";
+  return `import type { StorageProvider } from "@kitn/core";
 
 export function ${camel}(config?: Record<string, unknown>): StorageProvider {
   // TODO: implement storage provider
@@ -1866,16 +1901,16 @@ async function createComponent(type, name, opts) {
     );
   }
   const cwd = opts?.cwd ?? process.cwd();
-  const dir = join12(cwd, name);
+  const dir = join13(cwd, name);
   if (await dirExists(dir)) {
     throw new Error(`Directory "${name}" already exists`);
   }
-  await mkdir5(dir, { recursive: true });
+  await mkdir6(dir, { recursive: true });
   const validType = type;
   const sourceFile = validType === "skill" ? "README.md" : `${name}.ts`;
   const registryJson = generateRegistryJson(validType, name, sourceFile);
-  await writeFile9(
-    join12(dir, "registry.json"),
+  await writeFile10(
+    join13(dir, "registry.json"),
     JSON.stringify(registryJson, null, 2) + "\n"
   );
   let source;
@@ -1893,7 +1928,7 @@ async function createComponent(type, name, opts) {
       source = generateStorageSource(name);
       break;
   }
-  await writeFile9(join12(dir, sourceFile), source);
+  await writeFile10(join13(dir, sourceFile), source);
   return { dir, files: ["registry.json", sourceFile] };
 }
 async function createCommand(type, name) {
@@ -2063,10 +2098,19 @@ async function registryAddCommand(namespace, url, opts = {}) {
   if (config.registries[namespace] && !opts.overwrite) {
     throw new Error(`Registry '${namespace}' is already configured. Use --overwrite to replace.`);
   }
-  config.registries[namespace] = url;
+  if (opts.homepage || opts.description) {
+    const entry = { url };
+    if (opts.homepage) entry.homepage = opts.homepage;
+    if (opts.description) entry.description = opts.description;
+    config.registries[namespace] = entry;
+  } else {
+    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}`));
 }
 async function registryRemoveCommand(namespace, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -2101,12 +2145,19 @@ async function registryListCommand(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const config = await readConfig(cwd);
   if (!config) throw new Error("No kitn.json found. Run `kitn init` first.");
-  const entries = Object.entries(config.registries).map(([namespace, url]) => ({ namespace, url }));
+  const entries = Object.entries(config.registries).map(([namespace, value]) => {
+    const url = getRegistryUrl(value);
+    const homepage = typeof value === "object" ? value.homepage : void 0;
+    const description = typeof value === "object" ? value.description : void 0;
+    return { namespace, url, homepage, description };
+  });
   if (entries.length === 0) {
     p11.log.message(pc10.dim("  No registries configured."));
   } else {
-    for (const { namespace, url } of entries) {
+    for (const { namespace, url, homepage, description } of entries) {
       p11.log.message(`  ${pc10.bold(namespace.padEnd(16))} ${pc10.dim(url)}`);
+      if (description) p11.log.message(`  ${" ".repeat(16)} ${description}`);
+      if (homepage) p11.log.message(`  ${" ".repeat(16)} ${pc10.dim(homepage)}`);
     }
   }
   return entries;
@@ -2196,7 +2247,7 @@ function startUpdateCheck(currentVersion) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.1.10" : "0.0.0-dev";
+var VERSION = true ? "0.1.12" : "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 () => {
@@ -2236,7 +2287,7 @@ program.command("info").description("Show details about a component").argument("
   await infoCommand2(component);
 });
 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").action(async (namespace, url, opts) => {
+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));
   await registryAddCommand2(namespace, url, opts);
 });