@kitnai/cli 0.1.18 → 0.1.20

package/dist/index.js

@@ -330,7 +330,7 @@ async function resolveDependencies(names, fetchItem) {
   const visited = /* @__PURE__ */ new Set();
   const items = /* @__PURE__ */ new Map();
   const edges = [];
-  async function resolve3(name) {
+  async function resolve(name) {
     if (visited.has(name)) return;
     visited.add(name);
     const item = await fetchItem(name);
@@ -338,11 +338,11 @@ async function resolveDependencies(names, fetchItem) {
     const deps = item.registryDependencies ?? [];
     for (const dep of deps) {
       edges.push([dep, name]);
-      await resolve3(dep);
+      await resolve(dep);
     }
   }
   for (const name of names) {
-    await resolve3(name);
+    await resolve(name);
   }
   return topologicalSort(items, edges);
 }
@@ -1086,8 +1086,7 @@ async function addCommand(components, opts) {
         [
           `import { ai } from "./${baseDir.replace(/^src\//, "")}/plugin";`,
           ``,
-          `app.route("/api", ai.router);`,
-          `await ai.initialize();`
+          `app.route("/api", ai.router);`
         ].join("\n"),
         "Add this to your server entry point"
       );
@@ -1142,7 +1141,6 @@ async function addCommand(components, opts) {
     hints.push(pc3.dim(`  import { ai } from "./${baseDir.replace(/^src\//, "")}/plugin";`));
     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) {
@@ -1279,8 +1277,7 @@ async function initCommand(opts = {}) {
     [
       `import { ai } from "./${baseDir.replace(/^src\//, "")}/plugin";`,
       ``,
-      `app.route("/api", ai.router);`,
-      `await ai.initialize();`
+      `app.route("/api", ai.router);`
     ].join("\n"),
     "Add this to your server entry point:"
   );
@@ -1303,7 +1300,7 @@ var init_init = __esm({
     init_tsconfig_patcher();
     init_barrel_manager();
     init_add();
-    PLUGIN_TEMPLATE = `import { createAIPlugin } from "@kitn/hono-routes";
+    PLUGIN_TEMPLATE = `import { createAIPlugin } from "@kitn/routes";
 import { registerWithPlugin } from "./index.js";
 
 export const ai = createAIPlugin({
@@ -1657,433 +1654,23 @@ var init_update = __esm({
   }
 });
 
-// src/registry/build-output.ts
-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);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function walkForRegistryJson(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-  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(join11(dir, entry.name));
-      results.push(...subResults);
-    }
-  }
-  return results;
-}
-async function scanForComponents(cwd, paths) {
-  const resolvedCwd = resolve(cwd);
-  if (paths && paths.length > 0) {
-    const results = [];
-    for (const p13 of paths) {
-      const absPath = resolve(resolvedCwd, p13);
-      if (await fileExists(join11(absPath, "registry.json"))) {
-        results.push(absPath);
-        continue;
-      }
-      let entries;
-      try {
-        entries = await readdir(absPath, { withFileTypes: true });
-      } catch {
-        continue;
-      }
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const subDir = join11(absPath, entry.name);
-          if (await fileExists(join11(subDir, "registry.json"))) {
-            results.push(subDir);
-          }
-        }
-      }
-    }
-    return results;
-  }
-  return walkForRegistryJson(resolvedCwd);
-}
-function parseVersionFromFilename(name, componentName) {
-  const prefix = `${componentName}@`;
-  const suffix = ".json";
-  if (name.startsWith(prefix) && name.endsWith(suffix)) {
-    return name.slice(prefix.length, -suffix.length);
-  }
-  return null;
-}
-async function writeRegistryOutput(outputDir, items) {
-  const written = [];
-  const skipped = [];
-  const resolvedOutput = resolve(outputDir);
-  const indexItems = [];
-  for (const item of items) {
-    const dir = typeToDir[item.type];
-    const typeDir = join11(resolvedOutput, dir);
-    await mkdir5(typeDir, { recursive: true });
-    const itemJson = JSON.stringify(item, null, 2);
-    const latestPath = join11(typeDir, `${item.name}.json`);
-    const latestRelative = `${dir}/${item.name}.json`;
-    await writeFile9(latestPath, itemJson, "utf-8");
-    written.push(latestRelative);
-    if (item.version) {
-      const versionedFilename = `${item.name}@${item.version}.json`;
-      const versionedPath = join11(typeDir, versionedFilename);
-      const versionedRelative = `${dir}/${versionedFilename}`;
-      if (await fileExists(versionedPath)) {
-        skipped.push(versionedRelative);
-      } else {
-        await writeFile9(versionedPath, itemJson, "utf-8");
-        written.push(versionedRelative);
-      }
-    }
-    const versions = [];
-    let entries;
-    try {
-      entries = await readdir(typeDir);
-    } catch {
-      entries = [];
-    }
-    for (const filename of entries) {
-      const ver = parseVersionFromFilename(filename, item.name);
-      if (ver) {
-        versions.push(ver);
-      }
-    }
-    versions.sort();
-    indexItems.push({
-      name: item.name,
-      type: item.type,
-      description: item.description,
-      ...item.registryDependencies && item.registryDependencies.length > 0 && {
-        registryDependencies: item.registryDependencies
-      },
-      ...item.categories && item.categories.length > 0 && { categories: item.categories },
-      ...item.version && { version: item.version },
-      ...versions.length > 0 && { versions },
-      ...item.updatedAt && { updatedAt: item.updatedAt }
-    });
-  }
-  const index = {
-    version: "1",
-    items: indexItems
-  };
-  const indexPath = join11(resolvedOutput, "registry.json");
-  await writeFile9(indexPath, JSON.stringify(index, null, 2), "utf-8");
-  written.push("registry.json");
-  return { written, skipped };
-}
-var SKIP_DIRS;
-var init_build_output = __esm({
-  "src/registry/build-output.ts"() {
-    "use strict";
-    init_schema();
-    SKIP_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      "dist",
-      ".git",
-      "r",
-      "test",
-      "tests",
-      ".claude"
-    ]);
-  }
-});
-
-// src/registry/builder.ts
-import { readFile as readFile9, readdir as readdir2 } from "fs/promises";
-import { join as join12, relative as relative5 } from "path";
-function isExcludedDevDep(name) {
-  return EXCLUDED_DEV_DEPS.has(name) || name.startsWith("@types/");
-}
-function stripScope(name) {
-  const match = name.match(/^@[^/]+\/(.+)$/);
-  return match ? match[1] : name;
-}
-async function readTsFiles(dir, baseDir, exclude) {
-  const results = [];
-  const entries = await readdir2(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join12(dir, entry.name);
-    const relPath = relative5(baseDir, fullPath);
-    if (entry.isDirectory()) {
-      const nested = await readTsFiles(fullPath, baseDir, exclude);
-      results.push(...nested);
-    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-      if (exclude.includes(relPath)) {
-        continue;
-      }
-      const content = await readFile9(fullPath, "utf-8");
-      results.push({ relativePath: relPath, content });
-    }
-  }
-  return results;
-}
-async function buildComponent(componentDir) {
-  let rawConfig;
-  try {
-    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.`
-    );
-  }
-  let config;
-  try {
-    config = componentConfigSchema.parse(JSON.parse(rawConfig));
-  } catch (err) {
-    throw new Error(
-      `Invalid registry.json in ${componentDir}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  let pkg = null;
-  try {
-    const rawPkg = await readFile9(join12(componentDir, "package.json"), "utf-8");
-    pkg = JSON.parse(rawPkg);
-  } catch {
-  }
-  const name = config.name ?? (pkg?.name ? stripScope(pkg.name) : void 0);
-  const version = config.version ?? pkg?.version;
-  const description = config.description ?? pkg?.description;
-  if (!name) {
-    throw new Error(
-      `Component in ${componentDir} is missing a name. Provide "name" in registry.json or have a package.json with a "name" field.`
-    );
-  }
-  if (!description) {
-    throw new Error(
-      `Component in ${componentDir} is missing a description. Provide "description" in registry.json or have a package.json with a "description" field.`
-    );
-  }
-  let dependencies = config.dependencies;
-  let devDependencies = config.devDependencies;
-  if (pkg && !config.dependencies) {
-    const deps = [];
-    if (pkg.dependencies) {
-      for (const [depName, depVersion] of Object.entries(pkg.dependencies)) {
-        if (depVersion !== "workspace:*") {
-          deps.push(depName);
-        }
-      }
-    }
-    if (pkg.peerDependencies) {
-      for (const [depName, depVersion] of Object.entries(pkg.peerDependencies)) {
-        if (depVersion !== "workspace:*") {
-          deps.push(depName);
-        }
-      }
-    }
-    if (deps.length > 0) {
-      dependencies = deps;
-    }
-  }
-  if (pkg && !config.devDependencies) {
-    const devDeps = [];
-    if (pkg.devDependencies) {
-      for (const depName of Object.keys(pkg.devDependencies)) {
-        if (!isExcludedDevDep(depName)) {
-          devDeps.push(depName);
-        }
-      }
-    }
-    if (devDeps.length > 0) {
-      devDependencies = devDeps;
-    }
-  }
-  const isPackage = config.type === "kitn:package";
-  const dirPrefix = config.installDir ?? typeToDir[config.type];
-  let files;
-  if (isPackage) {
-    const sourceDir = config.sourceDir ?? "src";
-    const sourcePath = join12(componentDir, sourceDir);
-    const exclude = config.exclude ?? [];
-    let tsFiles;
-    try {
-      tsFiles = await readTsFiles(sourcePath, sourcePath, exclude);
-    } catch {
-      throw new Error(
-        `Cannot read source directory "${sourceDir}" in ${componentDir}. Make sure it exists.`
-      );
-    }
-    files = tsFiles.map((f) => ({
-      path: `${dirPrefix}/${f.relativePath}`,
-      content: f.content,
-      type: config.type
-    }));
-  } else {
-    if (!config.files || config.files.length === 0) {
-      throw new Error(
-        `Component "${name}" (type: ${config.type}) has no "files" array in registry.json. Standalone components must list their source files.`
-      );
-    }
-    files = await Promise.all(
-      config.files.map(async (filePath) => {
-        const fullPath = join12(componentDir, filePath);
-        let content;
-        try {
-          content = await readFile9(fullPath, "utf-8");
-        } catch {
-          throw new Error(
-            `Cannot read file "${filePath}" referenced in registry.json for component "${name}". Make sure the file exists at ${fullPath}.`
-          );
-        }
-        return {
-          path: `${dirPrefix}/${filePath}`,
-          content,
-          type: config.type
-        };
-      })
-    );
-  }
-  const item = {
-    name,
-    type: config.type,
-    description,
-    files
-  };
-  if (version) item.version = version;
-  if (dependencies && dependencies.length > 0) item.dependencies = dependencies;
-  if (devDependencies && devDependencies.length > 0) item.devDependencies = devDependencies;
-  if (config.registryDependencies && config.registryDependencies.length > 0) {
-    item.registryDependencies = config.registryDependencies;
-  }
-  if (config.envVars) item.envVars = config.envVars;
-  if (config.tsconfig) item.tsconfig = config.tsconfig;
-  if (config.docs) item.docs = config.docs;
-  if (config.categories && config.categories.length > 0) item.categories = config.categories;
-  if (config.changelog && config.changelog.length > 0) item.changelog = config.changelog;
-  if (isPackage && config.installDir) item.installDir = config.installDir;
-  try {
-    return registryItemSchema.parse(item);
-  } catch (err) {
-    throw new Error(
-      `Built component "${name}" failed validation: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-var EXCLUDED_DEV_DEPS;
-var init_builder = __esm({
-  "src/registry/builder.ts"() {
-    "use strict";
-    init_schema();
-    EXCLUDED_DEV_DEPS = /* @__PURE__ */ new Set([
-      "typescript",
-      "@types/bun",
-      "@types/node",
-      "tsup",
-      "vitest",
-      "jest",
-      "@types/jest"
-    ]);
-  }
-});
-
-// src/commands/build.ts
-var build_exports = {};
-__export(build_exports, {
-  buildCommand: () => buildCommand
-});
-import * as p8 from "@clack/prompts";
-import pc7 from "picocolors";
-import { resolve as resolve2, relative as relative6 } from "path";
-async function buildCommand(paths, opts) {
-  p8.intro(pc7.bgCyan(pc7.black(" kitn build ")));
-  const cwd = process.cwd();
-  const outputDir = resolve2(cwd, opts.output ?? "dist/r");
-  const s = p8.spinner();
-  s.start("Scanning for components...");
-  const componentDirs = await scanForComponents(cwd, paths.length > 0 ? paths : void 0);
-  if (componentDirs.length === 0) {
-    s.stop("No components found");
-    p8.log.info(
-      `No directories with ${pc7.bold("registry.json")} found. Run ${pc7.bold("kitn create")} to scaffold a component.`
-    );
-    return;
-  }
-  s.stop(`Found ${componentDirs.length} component(s)`);
-  p8.log.message(componentDirs.map((dir) => `  ${pc7.dim(relative6(cwd, dir))}`).join("\n"));
-  s.start("Building components...");
-  const items = [];
-  const errors = [];
-  for (const dir of componentDirs) {
-    try {
-      const item = await buildComponent(dir);
-      items.push(item);
-    } catch (err) {
-      errors.push({ dir: relative6(cwd, dir), error: err.message });
-    }
-  }
-  if (errors.length > 0) {
-    s.stop(pc7.red(`Build failed with ${errors.length} error(s)`));
-    p8.log.error(errors.map(({ dir, error }) => `${pc7.bold(dir)}: ${error}`).join("\n"));
-    process.exit(1);
-  }
-  const { written, skipped } = await writeRegistryOutput(outputDir, items);
-  s.stop(pc7.green(`Built ${items.length} component(s)`));
-  if (written.length > 0) {
-    p8.log.success(`Wrote ${written.length} file(s):
-` + written.map((f) => `  ${pc7.green("+")} ${f}`).join("\n"));
-  }
-  if (skipped.length > 0) {
-    p8.log.info(`Skipped ${skipped.length} file(s) (already exist):
-` + skipped.map((f) => `  ${pc7.dim("-")} ${f}`).join("\n"));
-  }
-  p8.outro(`Output: ${pc7.cyan(relative6(cwd, outputDir) || ".")}`);
-}
-var init_build = __esm({
-  "src/commands/build.ts"() {
-    "use strict";
-    init_build_output();
-    init_builder();
-  }
-});
-
 // src/commands/create.ts
 var create_exports = {};
 __export(create_exports, {
   createCommand: () => createCommand,
-  createComponent: () => createComponent
+  createComponentInProject: () => createComponentInProject
 });
-import * as p9 from "@clack/prompts";
-import pc8 from "picocolors";
-import { join as join13 } from "path";
-import { mkdir as mkdir6, writeFile as writeFile10 } from "fs/promises";
+import * as p8 from "@clack/prompts";
+import pc7 from "picocolors";
+import { join as join11, relative as relative4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir5 } from "fs/promises";
 function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
 function toTitleCase(str) {
   return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
-function generateRegistryJson(type, name, sourceFile) {
-  const base = {
-    $schema: "https://kitn.dev/schema/registry.json",
-    name,
-    type: `kitn:${type}`,
-    version: "0.1.0",
-    description: "",
-    files: [sourceFile],
-    categories: []
-  };
-  if (type === "tool") {
-    base.dependencies = ["ai", "zod"];
-  } else if (type === "agent" || type === "storage") {
-    base.dependencies = [];
-  }
-  return base;
-}
 function generateAgentSource(name) {
   const camel = toCamelCase(name);
   return `import { registerAgent } from "@kitn/core";
@@ -2106,7 +1693,7 @@ import { z } from "zod";
 
 export const ${camel} = tool({
   description: "",
-  parameters: z.object({
+  inputSchema: z.object({
     input: z.string().describe("Input parameter"),
   }),
   execute: async ({ input }) => {
@@ -2145,34 +1732,28 @@ export function ${camel}(config?: Record<string, unknown>): StorageProvider {
 }
 `;
 }
-async function dirExists(path) {
-  try {
-    const { stat: stat2 } = await import("fs/promises");
-    const s = await stat2(path);
-    return s.isDirectory();
-  } catch {
-    return false;
-  }
-}
-async function createComponent(type, name, opts) {
+async function createComponentInProject(type, name, opts) {
   if (!VALID_TYPES.includes(type)) {
     throw new Error(
       `Invalid component type: "${type}". Valid types: ${VALID_TYPES.join(", ")}`
     );
   }
   const cwd = opts?.cwd ?? process.cwd();
-  const dir = join13(cwd, name);
-  if (await dirExists(dir)) {
-    throw new Error(`Directory "${name}" already exists`);
+  const config = await readConfig(cwd);
+  if (!config) {
+    throw new Error(
+      `No kitn.json found in ${cwd}. Run ${pc7.bold("kitn init")} first.`
+    );
   }
-  await mkdir6(dir, { recursive: true });
   const validType = type;
-  const sourceFile = validType === "skill" ? "README.md" : `${name}.ts`;
-  const registryJson = generateRegistryJson(validType, name, sourceFile);
-  await writeFile10(
-    join13(dir, "registry.json"),
-    JSON.stringify(registryJson, null, 2) + "\n"
-  );
+  const kitnType = typeToKitnType[validType];
+  const fileName = validType === "skill" ? `${name}.md` : `${name}.ts`;
+  const filePath = join11(cwd, getInstallPath(config, kitnType, fileName));
+  const dummyContent = "";
+  const status = await checkFileStatus(filePath, dummyContent);
+  if (status !== "new" /* New */) {
+    throw new Error(`File already exists: ${filePath}`);
+  }
   let source;
   switch (validType) {
     case "agent":
@@ -2188,31 +1769,59 @@ async function createComponent(type, name, opts) {
       source = generateStorageSource(name);
       break;
   }
-  await writeFile10(join13(dir, sourceFile), source);
-  return { dir, files: ["registry.json", sourceFile] };
+  await writeComponentFile(filePath, source);
+  let barrelUpdated = false;
+  if (BARREL_TYPES.includes(validType)) {
+    const baseDir = config.aliases.base ?? "src/ai";
+    const barrelPath = join11(cwd, baseDir, "index.ts");
+    let barrelContent;
+    if (existsSync3(barrelPath)) {
+      barrelContent = await readFile8(barrelPath, "utf-8");
+    } else {
+      barrelContent = createBarrelFile();
+      await mkdir5(join11(cwd, baseDir), { recursive: true });
+    }
+    const importPath = "./" + relative4(join11(cwd, baseDir), filePath).replace(/\.ts$/, ".js");
+    const updatedBarrel = addImportToBarrel(barrelContent, importPath);
+    if (updatedBarrel !== barrelContent) {
+      await writeFile9(barrelPath, updatedBarrel);
+      barrelUpdated = true;
+    }
+  }
+  return { filePath, barrelUpdated };
 }
 async function createCommand(type, name) {
-  p9.intro(pc8.bgCyan(pc8.black(" kitn create ")));
+  p8.intro(pc7.bgCyan(pc7.black(" kitn create ")));
   try {
-    const { dir, files } = await createComponent(type, name);
-    p9.log.success(`Created ${pc8.bold(type)} component ${pc8.cyan(name)}`);
-    for (const file of files) {
-      p9.log.message(`  ${pc8.green("+")} ${file}`);
+    const { filePath, barrelUpdated } = await createComponentInProject(type, name);
+    p8.log.success(`Created ${pc7.bold(type)} component ${pc7.cyan(name)}`);
+    p8.log.message(`  ${pc7.green("+")} ${filePath}`);
+    if (barrelUpdated) {
+      p8.log.message(`  ${pc7.green("+")} barrel file updated`);
     }
-    const editFile = files.find((f) => f !== "registry.json") ?? files[0];
-    p9.outro(
-      `Edit ${pc8.cyan(`${name}/${editFile}`)}, then run ${pc8.bold("kitn build")}`
+    p8.outro(
+      `Edit ${pc7.cyan(filePath)} to customize your ${type}.`
     );
   } catch (err) {
-    p9.log.error(err.message);
+    p8.log.error(err.message);
     process.exit(1);
   }
 }
-var VALID_TYPES;
+var VALID_TYPES, typeToKitnType, BARREL_TYPES;
 var init_create = __esm({
   "src/commands/create.ts"() {
     "use strict";
+    init_config();
+    init_file_writer();
+    init_barrel_manager();
     VALID_TYPES = ["agent", "tool", "skill", "storage"];
+    typeToKitnType = {
+      agent: "kitn:agent",
+      tool: "kitn:tool",
+      skill: "kitn:skill",
+      storage: "kitn:storage"
+    };
+    BARREL_TYPES = ["agent", "tool", "skill"];
   }
 });
 
@@ -2221,31 +1830,31 @@ var info_exports = {};
 __export(info_exports, {
   infoCommand: () => infoCommand
 });
-import * as p10 from "@clack/prompts";
-import pc9 from "picocolors";
+import * as p9 from "@clack/prompts";
+import pc8 from "picocolors";
 async function infoCommand(component) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p10.log.error("No kitn.json found. Run `kitn init` first.");
+    p9.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   const ref = parseComponentRef(component);
   const fetcher = new RegistryFetcher(config.registries);
-  const s = p10.spinner();
+  const s = p9.spinner();
   s.start("Fetching component info...");
   let index;
   try {
     index = await fetcher.fetchIndex(ref.namespace);
   } catch (err) {
-    s.stop(pc9.red("Failed to fetch registry"));
-    p10.log.error(err.message);
+    s.stop(pc8.red("Failed to fetch registry"));
+    p9.log.error(err.message);
     process.exit(1);
   }
   const indexItem = index.items.find((i) => i.name === ref.name);
   if (!indexItem) {
-    s.stop(pc9.red("Component not found"));
-    p10.log.error(`Component '${ref.name}' not found in registry.`);
+    s.stop(pc8.red("Component not found"));
+    p9.log.error(`Component '${ref.name}' not found in registry.`);
     process.exit(1);
   }
   const dir = typeToDir[indexItem.type];
@@ -2253,8 +1862,8 @@ async function infoCommand(component) {
   try {
     item = await fetcher.fetchItem(ref.name, dir, ref.namespace, ref.version);
   } catch (err) {
-    s.stop(pc9.red("Failed to fetch component"));
-    p10.log.error(err.message);
+    s.stop(pc8.red("Failed to fetch component"));
+    p9.log.error(err.message);
     process.exit(1);
   }
   s.stop("Component found");
@@ -2262,62 +1871,62 @@ async function infoCommand(component) {
   const typeName = indexItem.type.replace("kitn:", "");
   console.log();
   console.log(
-    `  ${pc9.bold(item.name)} ${pc9.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc9.dim(ref.namespace)}`
+    `  ${pc8.bold(item.name)} ${pc8.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc8.dim(ref.namespace)}`
   );
-  console.log(`  ${pc9.dim(item.description)}`);
+  console.log(`  ${pc8.dim(item.description)}`);
   console.log();
-  console.log(`  ${pc9.dim("Type:")}           ${typeName}`);
+  console.log(`  ${pc8.dim("Type:")}           ${typeName}`);
   if (item.dependencies?.length) {
     console.log(
-      `  ${pc9.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
+      `  ${pc8.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
     );
   }
   if (item.registryDependencies?.length) {
     console.log(
-      `  ${pc9.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
+      `  ${pc8.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
     );
   }
   if (item.categories?.length) {
     console.log(
-      `  ${pc9.dim("Categories:")}     ${item.categories.join(", ")}`
+      `  ${pc8.dim("Categories:")}     ${item.categories.join(", ")}`
     );
   }
   if (item.updatedAt) {
-    console.log(`  ${pc9.dim("Updated:")}        ${item.updatedAt}`);
+    console.log(`  ${pc8.dim("Updated:")}        ${item.updatedAt}`);
   }
   const versions = indexItem.versions;
   if (versions?.length) {
-    console.log(`  ${pc9.dim("Versions:")}       ${versions.join(", ")}`);
+    console.log(`  ${pc8.dim("Versions:")}       ${versions.join(", ")}`);
   }
   if (item.changelog?.length) {
     console.log();
-    console.log(`  ${pc9.bold("Changelog:")}`);
+    console.log(`  ${pc8.bold("Changelog:")}`);
     for (const entry of item.changelog) {
-      const tag = entry.type === "feature" ? pc9.green(entry.type) : entry.type === "fix" ? pc9.yellow(entry.type) : entry.type === "breaking" ? pc9.red(entry.type) : pc9.dim(entry.type);
+      const tag = entry.type === "feature" ? pc8.green(entry.type) : entry.type === "fix" ? pc8.yellow(entry.type) : entry.type === "breaking" ? pc8.red(entry.type) : pc8.dim(entry.type);
       console.log(
-        `    ${pc9.cyan(entry.version)}  ${pc9.dim(entry.date)}  ${tag}  ${entry.note}`
+        `    ${pc8.cyan(entry.version)}  ${pc8.dim(entry.date)}  ${tag}  ${entry.note}`
       );
     }
   }
   console.log();
   const fileCount = item.files.length;
-  console.log(`  ${pc9.bold(`Files:`)} ${pc9.dim(`(${fileCount})`)}`);
+  console.log(`  ${pc8.bold(`Files:`)} ${pc8.dim(`(${fileCount})`)}`);
   const maxShown = 10;
   for (const file of item.files.slice(0, maxShown)) {
-    console.log(`    ${pc9.dim(file.path)}`);
+    console.log(`    ${pc8.dim(file.path)}`);
   }
   if (fileCount > maxShown) {
-    console.log(`    ${pc9.dim(`... and ${fileCount - maxShown} more`)}`);
+    console.log(`    ${pc8.dim(`... and ${fileCount - maxShown} more`)}`);
   }
   const installed = config.installed?.[item.name];
   if (installed) {
     console.log();
     console.log(
-      `  ${pc9.green("Installed")} ${pc9.dim(`v${installed.version}`)}`
+      `  ${pc8.green("Installed")} ${pc8.dim(`v${installed.version}`)}`
     );
     if (version !== installed.version) {
       console.log(
-        `  ${pc9.yellow("Update available:")} ${pc9.dim(`v${installed.version}`)} \u2192 ${pc9.cyan(`v${version}`)}`
+        `  ${pc8.yellow("Update available:")} ${pc8.dim(`v${installed.version}`)} \u2192 ${pc8.cyan(`v${version}`)}`
       );
     }
   }
@@ -2338,26 +1947,26 @@ var check_exports = {};
 __export(check_exports, {
   checkCommand: () => checkCommand
 });
-import * as p11 from "@clack/prompts";
-import pc10 from "picocolors";
+import * as p10 from "@clack/prompts";
+import pc9 from "picocolors";
 async function checkCommand(currentVersion) {
-  p11.intro(pc10.bgCyan(pc10.black(" kitn check ")));
-  p11.log.info(`kitn v${currentVersion}`);
-  const s = p11.spinner();
+  p10.intro(pc9.bgCyan(pc9.black(" kitn check ")));
+  p10.log.info(`kitn v${currentVersion}`);
+  const s = p10.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.");
+    s.stop(pc9.yellow("Could not reach the npm registry"));
+    p10.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")}`);
+    s.stop(pc9.yellow(`Update available: ${currentVersion} \u2192 ${latest}`));
+    p10.log.message(`  Run: ${pc9.cyan("npm i -g @kitnai/cli")}`);
   } else {
-    s.stop(pc10.green("You're on the latest version"));
+    s.stop(pc9.green("You're on the latest version"));
   }
-  p11.outro("");
+  p10.outro("");
 }
 var init_check = __esm({
   "src/commands/check.ts"() {
@@ -2373,8 +1982,8 @@ __export(registry_exports, {
   registryListCommand: () => registryListCommand,
   registryRemoveCommand: () => registryRemoveCommand
 });
-import * as p12 from "@clack/prompts";
-import pc11 from "picocolors";
+import * as p11 from "@clack/prompts";
+import pc10 from "picocolors";
 async function registryAddCommand(namespace, url, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const config = await readConfig(cwd);
@@ -2400,10 +2009,10 @@ async function registryAddCommand(namespace, url, opts = {}) {
     config.registries[namespace] = url;
   }
   await writeConfig(cwd, config);
-  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}`));
+  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();
@@ -2425,10 +2034,10 @@ async function registryRemoveCommand(namespace, opts = {}) {
   }
   delete config.registries[namespace];
   await writeConfig(cwd, config);
-  p12.log.success(`Removed registry ${pc11.bold(namespace)}`);
+  p11.log.success(`Removed registry ${pc10.bold(namespace)}`);
   if (affectedComponents.length > 0) {
-    p12.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
-` + affectedComponents.map((name) => `  ${pc11.yellow("!")} ${name}`).join("\n"));
+    p11.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
+` + affectedComponents.map((name) => `  ${pc10.yellow("!")} ${name}`).join("\n"));
   }
   return { affectedComponents };
 }
@@ -2443,15 +2052,15 @@ async function registryListCommand(opts = {}) {
     return { namespace, url, homepage, description };
   });
   if (entries.length === 0) {
-    p12.log.message(pc11.dim("  No registries configured."));
+    p11.log.message(pc10.dim("  No registries configured."));
   } else {
     const lines = [];
     for (const { namespace, url, homepage, description } of entries) {
-      lines.push(`  ${pc11.bold(namespace.padEnd(16))} ${pc11.dim(url)}`);
+      lines.push(`  ${pc10.bold(namespace.padEnd(16))} ${pc10.dim(url)}`);
       if (description) lines.push(`  ${" ".repeat(16)} ${description}`);
-      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc11.dim(homepage)}`);
+      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc10.dim(homepage)}`);
     }
-    p12.log.message(lines.join("\n"));
+    p11.log.message(lines.join("\n"));
   }
   return entries;
 }
@@ -2465,7 +2074,7 @@ var init_registry = __esm({
 // src/index.ts
 init_update_check();
 import { Command } from "commander";
-var VERSION = true ? "0.1.18" : "0.0.0-dev";
+var VERSION = true ? "0.1.20" : "0.0.0-dev";
 var printUpdateNotice = startUpdateCheck(VERSION);
 var program = new Command().name("kitn").description("Install AI agent components from the kitn registry").version(VERSION);
 program.command("init").description("Initialize kitn in your project").option("-r, --runtime <runtime>", "runtime to use (bun, node, deno)").option("-b, --base <path>", "base directory for components (default: src/ai)").option("-y, --yes", "accept all defaults without prompting").action(async (opts) => {
@@ -2492,10 +2101,6 @@ program.command("update").description("Update installed components to latest reg
   const { updateCommand: updateCommand2 } = await Promise.resolve().then(() => (init_update(), update_exports));
   await updateCommand2(components);
 });
-program.command("build").description("Build registry JSON from components with registry.json files").argument("[paths...]", "directories to build (default: scan from cwd)").option("-o, --output <dir>", "output directory", "dist/r").action(async (paths, opts) => {
-  const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-  await buildCommand2(paths, opts);
-});
 program.command("create").description("Scaffold a new kitn component").argument("<type>", "component type (agent, tool, skill, storage)").argument("<name>", "component name").action(async (type, name) => {
   const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
   await createCommand2(type, name);