@kitnai/cli 0.1.6 → 0.1.8

package/dist/index.js

@@ -215,7 +215,7 @@ async function resolveDependencies(names, fetchItem) {
   const visited = /* @__PURE__ */ new Set();
   const items = /* @__PURE__ */ new Map();
   const edges = [];
-  async function resolve(name) {
+  async function resolve3(name) {
     if (visited.has(name)) return;
     visited.add(name);
     const item = await fetchItem(name);
@@ -223,11 +223,11 @@ async function resolveDependencies(names, fetchItem) {
     const deps = item.registryDependencies ?? [];
     for (const dep of deps) {
       edges.push([dep, name]);
-      await resolve(dep);
+      await resolve3(dep);
     }
   }
   for (const name of names) {
-    await resolve(name);
+    await resolve3(name);
   }
   return topologicalSort(items, edges);
 }
@@ -326,25 +326,119 @@ var init_dep_installer = __esm({
   }
 });
 
-// src/installers/env-checker.ts
+// src/installers/env-writer.ts
+import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
-function checkEnvVars(envVars) {
-  const missing = [];
-  for (const [key, description] of Object.entries(envVars)) {
-    if (!process.env[key]) {
-      missing.push(`  ${pc3.yellow(key)}: ${description}`);
+import { readFile as readFile4, writeFile as writeFile4, access as access3 } from "fs/promises";
+import { join as join4 } from "path";
+function parseEnvKeys(content) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex > 0) {
+      keys.add(trimmed.slice(0, eqIndex).trim());
     }
   }
-  return missing;
+  return keys;
+}
+async function readEnvFile(path) {
+  try {
+    return await readFile4(path, "utf-8");
+  } catch {
+    return "";
+  }
 }
-var init_env_checker = __esm({
-  "src/installers/env-checker.ts"() {
+function collectEnvVars(items) {
+  const merged = {};
+  for (const item of items) {
+    if (item.envVars) {
+      Object.assign(merged, item.envVars);
+    }
+  }
+  return merged;
+}
+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 envContent = await readEnvFile(envPath);
+  const exampleContent = await readEnvFile(examplePath);
+  const envKeys = parseEnvKeys(envContent);
+  const exampleKeys = parseEnvKeys(exampleContent);
+  const missingFromExample = keys.filter((k) => !exampleKeys.has(k));
+  const missingFromEnv = keys.filter((k) => !envKeys.has(k) && !process.env[k]);
+  if (missingFromExample.length > 0) {
+    const lines = [];
+    if (exampleContent && !exampleContent.endsWith("\n")) lines.push("");
+    for (const key of missingFromExample) {
+      const config = envVars[key];
+      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)`);
+  }
+  if (missingFromEnv.length === 0) return;
+  p2.log.message("");
+  p2.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 shouldPrompt = await p2.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.`);
+    return;
+  }
+  const newEntries = [];
+  for (const key of missingFromEnv) {
+    const config = envVars[key];
+    const isSecret = config.secret !== false;
+    let value;
+    if (isSecret) {
+      value = await p2.password({
+        message: `${key}:`
+      });
+    } else {
+      value = await p2.text({
+        message: `${key}:`,
+        placeholder: config.description
+      });
+    }
+    if (p2.isCancel(value)) {
+      p2.log.info(`Skipped remaining variables. Add them to ${pc3.cyan(".env")} when ready.`);
+      break;
+    }
+    if (value) {
+      newEntries.push(`${key}=${value}`);
+    }
+  }
+  if (newEntries.length > 0) {
+    const existingEnv = await readEnvFile(envPath);
+    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")}`);
+  }
+}
+var init_env_writer = __esm({
+  "src/installers/env-writer.ts"() {
     "use strict";
   }
 });
 
 // src/installers/import-rewriter.ts
-import { relative, join as join4 } from "path";
+import { relative, join as join5 } from "path";
 function rewriteKitnImports(content, fileType, fileName, aliases) {
   const sourceAliasKey = TYPE_TO_ALIAS_KEY[fileType];
   if (!sourceAliasKey) return content;
@@ -356,7 +450,7 @@ function rewriteKitnImports(content, fileType, fileName, aliases) {
         return `${prefix}@kitn/${type}/${targetPath}${quote}`;
       }
       const targetDir = aliases[type];
-      const targetFile = join4(targetDir, targetPath);
+      const targetFile = join5(targetDir, targetPath);
       let rel = relative(sourceDir, targetFile);
       rel = rel.split("\\").join("/");
       if (!rel.startsWith(".")) {
@@ -381,10 +475,10 @@ var init_import_rewriter = __esm({
 });
 
 // src/installers/tsconfig-patcher.ts
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
-function stripJsonc(text2) {
-  return text2.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
+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));
@@ -400,15 +494,15 @@ function patchTsconfig(tsconfigContent, paths) {
   return JSON.stringify(config, null, 2) + "\n";
 }
 async function patchProjectTsconfig(projectDir, paths) {
-  const tsconfigPath = join5(projectDir, "tsconfig.json");
+  const tsconfigPath = join6(projectDir, "tsconfig.json");
   let content;
   try {
-    content = await readFile4(tsconfigPath, "utf-8");
+    content = await readFile5(tsconfigPath, "utf-8");
   } catch {
     content = "{}";
   }
   const patched = patchTsconfig(content, paths);
-  await writeFile4(tsconfigPath, patched);
+  await writeFile5(tsconfigPath, patched);
 }
 var init_tsconfig_patcher = __esm({
   "src/installers/tsconfig-patcher.ts"() {
@@ -457,7 +551,7 @@ var init_parse_ref = __esm({
 
 // src/registry/schema.ts
 import { z as z2 } from "zod";
-var componentType2, registryFileSchema, changelogEntrySchema, registryItemSchema, registryIndexItemSchema, registryIndexSchema, typeToDir;
+var componentType2, registryFileSchema, changelogEntrySchema, envVarConfigSchema, componentConfigSchema, registryItemSchema, registryIndexItemSchema, registryIndexSchema, typeToDir;
 var init_schema = __esm({
   "src/registry/schema.ts"() {
     "use strict";
@@ -473,6 +567,31 @@ var init_schema = __esm({
       type: z2.enum(["feature", "fix", "breaking", "initial"]),
       note: z2.string()
     });
+    envVarConfigSchema = z2.object({
+      description: z2.string(),
+      required: z2.boolean().optional(),
+      secret: z2.boolean().optional(),
+      url: z2.string().optional()
+    });
+    componentConfigSchema = z2.object({
+      $schema: z2.string().optional(),
+      type: componentType2,
+      name: z2.string().optional(),
+      version: z2.string().optional(),
+      description: z2.string().optional(),
+      dependencies: z2.array(z2.string()).optional(),
+      devDependencies: z2.array(z2.string()).optional(),
+      registryDependencies: z2.array(z2.string()).optional(),
+      files: z2.array(z2.string()).optional(),
+      sourceDir: z2.string().optional(),
+      exclude: z2.array(z2.string()).optional(),
+      installDir: z2.string().optional(),
+      tsconfig: z2.record(z2.string(), z2.array(z2.string())).optional(),
+      envVars: z2.record(z2.string(), envVarConfigSchema).optional(),
+      categories: z2.array(z2.string()).optional(),
+      docs: z2.string().optional(),
+      changelog: z2.array(changelogEntrySchema).optional()
+    });
     registryItemSchema = z2.object({
       $schema: z2.string().optional(),
       name: z2.string(),
@@ -481,7 +600,7 @@ var init_schema = __esm({
       dependencies: z2.array(z2.string()).optional(),
       devDependencies: z2.array(z2.string()).optional(),
       registryDependencies: z2.array(z2.string()).optional(),
-      envVars: z2.record(z2.string(), z2.string()).optional(),
+      envVars: z2.record(z2.string(), envVarConfigSchema).optional(),
       files: z2.array(registryFileSchema),
       installDir: z2.string().optional(),
       tsconfig: z2.record(z2.string(), z2.array(z2.string())).optional(),
@@ -521,19 +640,19 @@ var add_exports = {};
 __export(add_exports, {
   addCommand: () => addCommand
 });
-import * as p2 from "@clack/prompts";
+import * as p3 from "@clack/prompts";
 import pc4 from "picocolors";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function addCommand(components, opts) {
-  p2.intro(pc4.bgCyan(pc4.black(" kitn add ")));
+  p3.intro(pc4.bgCyan(pc4.black(" kitn add ")));
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p2.log.error("No kitn.json found. Run `kitn init` first.");
+    p3.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   if (components.length === 0) {
-    p2.log.error("Please specify at least one component to add.");
+    p3.log.error("Please specify at least one component to add.");
     process.exit(1);
   }
   const resolvedComponents = components.map((c) => {
@@ -545,7 +664,7 @@ async function addCommand(components, opts) {
   });
   const refs = resolvedComponents.map(parseComponentRef);
   const fetcher = new RegistryFetcher(config.registries);
-  const s = p2.spinner();
+  const s = p3.spinner();
   s.start("Resolving dependencies...");
   let resolved;
   try {
@@ -559,31 +678,27 @@ async function addCommand(components, opts) {
     });
   } catch (err) {
     s.stop(pc4.red("Failed to resolve dependencies"));
-    p2.log.error(err.message);
+    p3.log.error(err.message);
     process.exit(1);
   }
   s.stop(`Resolved ${resolved.length} component(s)`);
-  p2.log.info("Components to install:");
+  p3.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)")}`;
-    p2.log.message(`  ${pc4.cyan(label)}`);
+    p3.log.message(`  ${pc4.cyan(label)}`);
   }
   const created = [];
   const updated = [];
   const skipped = [];
   const allDeps = [];
-  const allEnvWarnings = [];
   for (const item of resolved) {
     if (item.dependencies) allDeps.push(...item.dependencies);
-    if (item.envVars) {
-      allEnvWarnings.push(...checkEnvVars(item.envVars));
-    }
     if (item.type === "kitn:package") {
       const baseDir = config.aliases.base ?? "src/ai";
       for (const file of item.files) {
-        const targetPath = join6(cwd, baseDir, file.path);
-        const relativePath = join6(baseDir, file.path);
+        const targetPath = join7(cwd, baseDir, file.path);
+        const relativePath = join7(baseDir, file.path);
         const status = await checkFileStatus(targetPath, file.content);
         switch (status) {
           case "new" /* New */:
@@ -600,15 +715,15 @@ async function addCommand(components, opts) {
             } else {
               const existing = await readExistingFile(targetPath);
               const diff = generateDiff(relativePath, existing ?? "", file.content);
-              p2.log.message(pc4.dim(diff));
-              const action = await p2.select({
+              p3.log.message(pc4.dim(diff));
+              const action = await p3.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 (!p2.isCancel(action) && action === "overwrite") {
+              if (!p3.isCancel(action) && action === "overwrite") {
                 await writeComponentFile(targetPath, file.content);
                 updated.push(relativePath);
               } else {
@@ -622,10 +737,10 @@ async function addCommand(components, opts) {
         const resolvedPaths = {};
         const installDir = item.installDir ?? item.name;
         for (const [key, values] of Object.entries(item.tsconfig)) {
-          resolvedPaths[key] = values.map((v) => `./${join6(baseDir, installDir, v)}`);
+          resolvedPaths[key] = values.map((v) => `./${join7(baseDir, installDir, v)}`);
         }
         await patchProjectTsconfig(cwd, resolvedPaths);
-        p2.log.info(`Patched tsconfig.json with paths: ${Object.keys(resolvedPaths).join(", ")}`);
+        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");
@@ -635,7 +750,7 @@ async function addCommand(components, opts) {
         registry: ref.namespace,
         version: item.version ?? "1.0.0",
         installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        files: item.files.map((f) => join6(baseDir, f.path)),
+        files: item.files.map((f) => join7(baseDir, f.path)),
         hash: contentHash(allContent)
       };
       config.installed = installed;
@@ -654,8 +769,8 @@ async function addCommand(components, opts) {
           }
         })();
         const fileName = file.path.split("/").pop();
-        const targetPath = join6(cwd, config.aliases[aliasKey], fileName);
-        const relativePath = join6(config.aliases[aliasKey], fileName);
+        const targetPath = join7(cwd, config.aliases[aliasKey], fileName);
+        const relativePath = join7(config.aliases[aliasKey], fileName);
         const content = rewriteKitnImports(file.content, item.type, fileName, config.aliases);
         const status = await checkFileStatus(targetPath, content);
         switch (status) {
@@ -673,15 +788,15 @@ async function addCommand(components, opts) {
             } else {
               const existing = await readExistingFile(targetPath);
               const diff = generateDiff(relativePath, existing ?? "", content);
-              p2.log.message(pc4.dim(diff));
-              const action = await p2.select({
+              p3.log.message(pc4.dim(diff));
+              const action = await p3.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 (!p2.isCancel(action) && action === "overwrite") {
+              if (!p3.isCancel(action) && action === "overwrite") {
                 await writeComponentFile(targetPath, content);
                 updated.push(relativePath);
               } else {
@@ -716,7 +831,7 @@ async function addCommand(components, opts) {
             }
           })();
           const fileName = f.path.split("/").pop();
-          return join6(config.aliases[aliasKey], fileName);
+          return join7(config.aliases[aliasKey], fileName);
         }),
         hash: contentHash(allContent)
       };
@@ -738,24 +853,22 @@ async function addCommand(components, opts) {
     }
   }
   if (created.length > 0) {
-    p2.log.success(`Created ${created.length} file(s):`);
-    for (const f of created) p2.log.message(`  ${pc4.green("+")} ${f}`);
+    p3.log.success(`Created ${created.length} file(s):`);
+    for (const f of created) p3.log.message(`  ${pc4.green("+")} ${f}`);
   }
   if (updated.length > 0) {
-    p2.log.success(`Updated ${updated.length} file(s):`);
-    for (const f of updated) p2.log.message(`  ${pc4.yellow("~")} ${f}`);
+    p3.log.success(`Updated ${updated.length} file(s):`);
+    for (const f of updated) p3.log.message(`  ${pc4.yellow("~")} ${f}`);
   }
   if (skipped.length > 0) {
-    p2.log.info(`Skipped ${skipped.length} file(s):`);
-    for (const f of skipped) p2.log.message(`  ${pc4.dim("-")} ${f}`);
-  }
-  if (allEnvWarnings.length > 0) {
-    p2.log.warn("Missing environment variables:");
-    for (const w of allEnvWarnings) p2.log.message(w);
+    p3.log.info(`Skipped ${skipped.length} file(s):`);
+    for (const f of skipped) p3.log.message(`  ${pc4.dim("-")} ${f}`);
   }
+  const allEnvVars = collectEnvVars(resolved);
+  await handleEnvVars(cwd, allEnvVars);
   for (const item of resolved) {
     if (item.docs) {
-      p2.log.info(`${pc4.bold(item.name)}: ${item.docs}`);
+      p3.log.info(`${pc4.bold(item.name)}: ${item.docs}`);
     }
   }
   const installedNames = new Set(resolved.map((r) => r.name));
@@ -783,10 +896,10 @@ async function addCommand(components, opts) {
     }
   }
   if (hints.length > 0) {
-    p2.log.message(pc4.bold("\nNext steps:"));
-    for (const hint of hints) p2.log.message(hint);
+    p3.log.message(pc4.bold("\nNext steps:"));
+    for (const hint of hints) p3.log.message(hint);
   }
-  p2.outro(pc4.green("Done!"));
+  p3.outro(pc4.green("Done!"));
 }
 var init_add = __esm({
   "src/commands/add.ts"() {
@@ -797,7 +910,7 @@ var init_add = __esm({
     init_resolver();
     init_file_writer();
     init_dep_installer();
-    init_env_checker();
+    init_env_writer();
     init_import_rewriter();
     init_tsconfig_patcher();
     init_hash();
@@ -811,22 +924,22 @@ var list_exports = {};
 __export(list_exports, {
   listCommand: () => listCommand
 });
-import * as p3 from "@clack/prompts";
+import * as p4 from "@clack/prompts";
 import pc5 from "picocolors";
 async function listCommand(opts) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p3.log.error("No kitn.json found. Run `kitn init` first.");
+    p4.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   const fetcher = new RegistryFetcher(config.registries);
   const namespacesToFetch = opts.registry ? [opts.registry] : Object.keys(config.registries);
   if (opts.registry && !config.registries[opts.registry]) {
-    p3.log.error(`Registry ${pc5.bold(opts.registry)} is not configured. Run ${pc5.bold("kitn registry list")} to see configured registries.`);
+    p4.log.error(`Registry ${pc5.bold(opts.registry)} is not configured. Run ${pc5.bold("kitn registry list")} to see configured registries.`);
     process.exit(1);
   }
-  const s = p3.spinner();
+  const s = p4.spinner();
   s.start("Fetching registry index...");
   const allItems = [];
   const errors = [];
@@ -842,12 +955,12 @@ async function listCommand(opts) {
   }
   if (allItems.length === 0 && errors.length > 0) {
     s.stop(pc5.red("Failed to fetch registries"));
-    for (const e of errors) p3.log.error(e);
+    for (const e of errors) p4.log.error(e);
     process.exit(1);
   }
   s.stop(`Found ${allItems.length} components across ${namespacesToFetch.length - errors.length} ${namespacesToFetch.length - errors.length === 1 ? "registry" : "registries"}`);
   for (const e of errors) {
-    p3.log.warn(`${pc5.yellow("\u26A0")} Failed to fetch ${e}`);
+    p4.log.warn(`${pc5.yellow("\u26A0")} Failed to fetch ${e}`);
   }
   const installed = config.installed ?? {};
   const typeGroups = /* @__PURE__ */ new Map();
@@ -860,7 +973,7 @@ async function listCommand(opts) {
   let installedCount = 0;
   let updateCount = 0;
   for (const [group, items] of typeGroups) {
-    p3.log.message(pc5.bold(`
+    p4.log.message(pc5.bold(`
 ${group.charAt(0).toUpperCase() + group.slice(1)}s:`));
     for (const item of items) {
       const displayName = item.namespace === "@kitn" ? item.name : `${item.namespace}/${item.name}`;
@@ -873,18 +986,18 @@ ${group.charAt(0).toUpperCase() + group.slice(1)}s:`));
         const hasUpdate = item.version && inst.version !== item.version;
         const updateTag = hasUpdate ? pc5.yellow(` \u2B06 v${item.version} available`) : "";
         if (hasUpdate) updateCount++;
-        p3.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc5.dim(item.description)}${updateTag}`);
+        p4.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc5.dim(item.description)}${updateTag}`);
       } else {
         const status = pc5.dim("\u25CB");
-        p3.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc5.dim(item.description)}`);
+        p4.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc5.dim(item.description)}`);
       }
     }
   }
   const availableCount = allItems.length - installedCount;
   const parts = [`${installedCount} installed`, `${availableCount} available`];
   if (updateCount > 0) parts.push(`${updateCount} update${updateCount === 1 ? "" : "s"} available`);
-  p3.log.message("");
-  p3.log.message(pc5.dim(`  ${parts.join(", ")}`));
+  p4.log.message("");
+  p4.log.message(pc5.dim(`  ${parts.join(", ")}`));
 }
 var init_list = __esm({
   "src/commands/list.ts"() {
@@ -899,13 +1012,13 @@ var diff_exports = {};
 __export(diff_exports, {
   diffCommand: () => diffCommand
 });
-import * as p4 from "@clack/prompts";
-import { join as join7 } from "path";
+import * as p5 from "@clack/prompts";
+import { join as join8 } from "path";
 async function diffCommand(componentName) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p4.log.error("No kitn.json found. Run `kitn init` first.");
+    p5.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   const input = componentName === "routes" ? config.framework ?? "hono" : componentName;
@@ -913,7 +1026,7 @@ async function diffCommand(componentName) {
   const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
   const installed = config.installed?.[installedKey];
   if (!installed) {
-    p4.log.error(`Component '${ref.name}' is not installed.`);
+    p5.log.error(`Component '${ref.name}' is not installed.`);
     process.exit(1);
   }
   const namespace = installed.registry ?? ref.namespace;
@@ -921,7 +1034,7 @@ async function diffCommand(componentName) {
   const index = await fetcher.fetchIndex(namespace);
   const indexItem = index.items.find((i) => i.name === ref.name);
   if (!indexItem) {
-    p4.log.error(`Component '${ref.name}' not found in ${namespace} registry.`);
+    p5.log.error(`Component '${ref.name}' not found in ${namespace} registry.`);
     process.exit(1);
   }
   const dir = typeToDir[indexItem.type];
@@ -930,11 +1043,11 @@ async function diffCommand(componentName) {
   for (const file of registryItem.files) {
     if (indexItem.type === "kitn:package") {
       const baseDir = config.aliases.base ?? "src/ai";
-      const localPath = join7(cwd, baseDir, file.path);
-      const relativePath = join7(baseDir, file.path);
+      const localPath = join8(cwd, baseDir, file.path);
+      const relativePath = join8(baseDir, file.path);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
-        p4.log.warn(`${relativePath}: file missing locally`);
+        p5.log.warn(`${relativePath}: file missing locally`);
         hasDiff = true;
       } else if (localContent !== file.content) {
         const diff = generateDiff(relativePath, localContent, file.content);
@@ -955,10 +1068,10 @@ async function diffCommand(componentName) {
             return "storage";
         }
       })();
-      const localPath = join7(cwd, config.aliases[aliasKey], fileName);
+      const localPath = join8(cwd, config.aliases[aliasKey], fileName);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
-        p4.log.warn(`${fileName}: file missing locally`);
+        p5.log.warn(`${fileName}: file missing locally`);
         hasDiff = true;
       } else if (localContent !== file.content) {
         const diff = generateDiff(fileName, localContent, file.content);
@@ -968,7 +1081,7 @@ async function diffCommand(componentName) {
     }
   }
   if (!hasDiff) {
-    p4.log.success(`${ref.name}: up to date, no differences.`);
+    p5.log.success(`${ref.name}: up to date, no differences.`);
   }
 }
 var init_diff = __esm({
@@ -987,15 +1100,15 @@ var remove_exports = {};
 __export(remove_exports, {
   removeCommand: () => removeCommand
 });
-import * as p5 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import pc6 from "picocolors";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { unlink } from "fs/promises";
 async function removeCommand(componentName) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p5.log.error("No kitn.json found. Run `kitn init` first.");
+    p6.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
   const input = componentName === "routes" ? config.framework ?? "hono" : componentName;
@@ -1003,24 +1116,24 @@ async function removeCommand(componentName) {
   const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
   const installed = config.installed?.[installedKey];
   if (!installed) {
-    p5.log.error(`Component '${ref.name}' is not installed.`);
+    p6.log.error(`Component '${ref.name}' is not installed.`);
     process.exit(1);
   }
-  const shouldRemove = await p5.confirm({
+  const shouldRemove = await p6.confirm({
     message: `Remove ${ref.name}? This will delete ${installed.files.length} file(s).`,
     initialValue: false
   });
-  if (p5.isCancel(shouldRemove) || !shouldRemove) {
-    p5.cancel("Remove cancelled.");
+  if (p6.isCancel(shouldRemove) || !shouldRemove) {
+    p6.cancel("Remove cancelled.");
     process.exit(0);
   }
   const deleted = [];
   for (const filePath of installed.files) {
     try {
-      await unlink(join8(cwd, filePath));
+      await unlink(join9(cwd, filePath));
       deleted.push(filePath);
     } catch {
-      p5.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
+      p6.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
     }
   }
   delete config.installed[installedKey];
@@ -1029,8 +1142,8 @@ async function removeCommand(componentName) {
   }
   await writeConfig(cwd, config);
   if (deleted.length > 0) {
-    p5.log.success(`Removed ${ref.name}:`);
-    for (const f of deleted) p5.log.message(`  ${pc6.red("-")} ${f}`);
+    p6.log.success(`Removed ${ref.name}:`);
+    for (const f of deleted) p6.log.message(`  ${pc6.red("-")} ${f}`);
   }
 }
 var init_remove = __esm({
@@ -1046,18 +1159,18 @@ var update_exports = {};
 __export(update_exports, {
   updateCommand: () => updateCommand
 });
-import * as p6 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 async function updateCommand(components) {
   if (components.length === 0) {
     const cwd = process.cwd();
     const config = await readConfig(cwd);
     if (!config) {
-      p6.log.error("No kitn.json found. Run `kitn init` first.");
+      p7.log.error("No kitn.json found. Run `kitn init` first.");
       process.exit(1);
     }
     const installed = config.installed;
     if (!installed || Object.keys(installed).length === 0) {
-      p6.log.info("No installed components to update.");
+      p7.log.info("No installed components to update.");
       return;
     }
     components = Object.keys(installed);
@@ -1072,36 +1185,593 @@ var init_update = __esm({
   }
 });
 
+// src/registry/build-output.ts
+import { readdir, writeFile as writeFile6, mkdir as mkdir3, access as access4 } from "fs/promises";
+import { join as join10, 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(join10(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));
+      results.push(...subResults);
+    }
+  }
+  return results;
+}
+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);
+      if (await fileExists(join10(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 = join10(absPath, entry.name);
+          if (await fileExists(join10(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 = join10(resolvedOutput, dir);
+    await mkdir3(typeDir, { recursive: true });
+    const itemJson = JSON.stringify(item, null, 2);
+    const latestPath = join10(typeDir, `${item.name}.json`);
+    const latestRelative = `${dir}/${item.name}.json`;
+    await writeFile6(latestPath, itemJson, "utf-8");
+    written.push(latestRelative);
+    if (item.version) {
+      const versionedFilename = `${item.name}@${item.version}.json`;
+      const versionedPath = join10(typeDir, versionedFilename);
+      const versionedRelative = `${dir}/${versionedFilename}`;
+      if (await fileExists(versionedPath)) {
+        skipped.push(versionedRelative);
+      } else {
+        await writeFile6(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 = join10(resolvedOutput, "registry.json");
+  await writeFile6(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 readFile7, readdir as readdir2 } from "fs/promises";
+import { join as join11, relative as relative3 } 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 = join11(dir, entry.name);
+    const relPath = relative3(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 readFile7(fullPath, "utf-8");
+      results.push({ relativePath: relPath, content });
+    }
+  }
+  return results;
+}
+async function buildComponent(componentDir) {
+  let rawConfig;
+  try {
+    rawConfig = await readFile7(join11(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 readFile7(join11(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 = join11(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 = join11(componentDir, filePath);
+        let content;
+        try {
+          content = await readFile7(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 relative4 } 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)`);
+  for (const dir of componentDirs) {
+    p8.log.message(`  ${pc7.dim(relative4(cwd, dir))}`);
+  }
+  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: relative4(cwd, dir), error: err.message });
+    }
+  }
+  if (errors.length > 0) {
+    s.stop(pc7.red(`Build failed with ${errors.length} error(s)`));
+    for (const { dir, error } of errors) {
+      p8.log.error(`${pc7.bold(dir)}: ${error}`);
+    }
+    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):`);
+    for (const f of written) {
+      p8.log.message(`  ${pc7.green("+")} ${f}`);
+    }
+  }
+  if (skipped.length > 0) {
+    p8.log.info(`Skipped ${skipped.length} file(s) (already exist):`);
+    for (const f of skipped) {
+      p8.log.message(`  ${pc7.dim("-")} ${f}`);
+    }
+  }
+  p8.outro(`Output: ${pc7.cyan(relative4(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
+});
+import * as p9 from "@clack/prompts";
+import pc8 from "picocolors";
+import { join as join12 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile7 } 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 type { AgentConfig } from "@kitnai/core";
+
+export const ${camel}Config: AgentConfig = {
+  name: "${name}",
+  description: "",
+  system: "You are a helpful assistant.",
+  tools: [],
+};
+`;
+}
+function generateToolSource(name) {
+  const camel = toCamelCase(name);
+  return `import { tool } from "ai";
+import { z } from "zod";
+
+export const ${camel} = tool({
+  description: "",
+  inputSchema: z.object({
+    input: z.string().describe("Input parameter"),
+  }),
+  execute: async ({ input }) => {
+    // TODO: implement
+    return { result: input };
+  },
+});
+`;
+}
+function generateSkillSource(name) {
+  const title = toTitleCase(name);
+  return `---
+name: ${name}
+description: ""
+---
+
+# ${title}
+
+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";
+
+export function ${camel}(config?: Record<string, unknown>): StorageProvider {
+  // TODO: implement storage provider
+  throw new Error("Not implemented");
+}
+`;
+}
+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) {
+  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 = join12(cwd, name);
+  if (await dirExists(dir)) {
+    throw new Error(`Directory "${name}" already exists`);
+  }
+  await mkdir4(dir, { recursive: true });
+  const validType = type;
+  const sourceFile = validType === "skill" ? "README.md" : `${name}.ts`;
+  const registryJson = generateRegistryJson(validType, name, sourceFile);
+  await writeFile7(
+    join12(dir, "registry.json"),
+    JSON.stringify(registryJson, null, 2) + "\n"
+  );
+  let source;
+  switch (validType) {
+    case "agent":
+      source = generateAgentSource(name);
+      break;
+    case "tool":
+      source = generateToolSource(name);
+      break;
+    case "skill":
+      source = generateSkillSource(name);
+      break;
+    case "storage":
+      source = generateStorageSource(name);
+      break;
+  }
+  await writeFile7(join12(dir, sourceFile), source);
+  return { dir, files: ["registry.json", sourceFile] };
+}
+async function createCommand(type, name) {
+  p9.intro(pc8.bgCyan(pc8.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 editFile = files.find((f) => f !== "registry.json") ?? files[0];
+    p9.outro(
+      `Edit ${pc8.cyan(`${name}/${editFile}`)}, then run ${pc8.bold("kitn build")}`
+    );
+  } catch (err) {
+    p9.log.error(err.message);
+    process.exit(1);
+  }
+}
+var VALID_TYPES;
+var init_create = __esm({
+  "src/commands/create.ts"() {
+    "use strict";
+    VALID_TYPES = ["agent", "tool", "skill", "storage"];
+  }
+});
+
 // src/commands/info.ts
 var info_exports = {};
 __export(info_exports, {
   infoCommand: () => infoCommand
 });
-import * as p7 from "@clack/prompts";
-import pc7 from "picocolors";
+import * as p10 from "@clack/prompts";
+import pc9 from "picocolors";
 async function infoCommand(component) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p7.log.error("No kitn.json found. Run `kitn init` first.");
+    p10.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 = p7.spinner();
+  const s = p10.spinner();
   s.start("Fetching component info...");
   let index;
   try {
     index = await fetcher.fetchIndex(ref.namespace);
   } catch (err) {
-    s.stop(pc7.red("Failed to fetch registry"));
-    p7.log.error(err.message);
+    s.stop(pc9.red("Failed to fetch registry"));
+    p10.log.error(err.message);
     process.exit(1);
   }
   const indexItem = index.items.find((i) => i.name === ref.name);
   if (!indexItem) {
-    s.stop(pc7.red("Component not found"));
-    p7.log.error(`Component '${ref.name}' not found in registry.`);
+    s.stop(pc9.red("Component not found"));
+    p10.log.error(`Component '${ref.name}' not found in registry.`);
     process.exit(1);
   }
   const dir = typeToDir[indexItem.type];
@@ -1109,8 +1779,8 @@ async function infoCommand(component) {
   try {
     item = await fetcher.fetchItem(ref.name, dir, ref.namespace, ref.version);
   } catch (err) {
-    s.stop(pc7.red("Failed to fetch component"));
-    p7.log.error(err.message);
+    s.stop(pc9.red("Failed to fetch component"));
+    p10.log.error(err.message);
     process.exit(1);
   }
   s.stop("Component found");
@@ -1118,62 +1788,62 @@ async function infoCommand(component) {
   const typeName = indexItem.type.replace("kitn:", "");
   console.log();
   console.log(
-    `  ${pc7.bold(item.name)} ${pc7.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc7.dim(ref.namespace)}`
+    `  ${pc9.bold(item.name)} ${pc9.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc9.dim(ref.namespace)}`
   );
-  console.log(`  ${pc7.dim(item.description)}`);
+  console.log(`  ${pc9.dim(item.description)}`);
   console.log();
-  console.log(`  ${pc7.dim("Type:")}           ${typeName}`);
+  console.log(`  ${pc9.dim("Type:")}           ${typeName}`);
   if (item.dependencies?.length) {
     console.log(
-      `  ${pc7.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
+      `  ${pc9.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
     );
   }
   if (item.registryDependencies?.length) {
     console.log(
-      `  ${pc7.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
+      `  ${pc9.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
     );
   }
   if (item.categories?.length) {
     console.log(
-      `  ${pc7.dim("Categories:")}     ${item.categories.join(", ")}`
+      `  ${pc9.dim("Categories:")}     ${item.categories.join(", ")}`
     );
   }
   if (item.updatedAt) {
-    console.log(`  ${pc7.dim("Updated:")}        ${item.updatedAt}`);
+    console.log(`  ${pc9.dim("Updated:")}        ${item.updatedAt}`);
   }
   const versions = indexItem.versions;
   if (versions?.length) {
-    console.log(`  ${pc7.dim("Versions:")}       ${versions.join(", ")}`);
+    console.log(`  ${pc9.dim("Versions:")}       ${versions.join(", ")}`);
   }
   if (item.changelog?.length) {
     console.log();
-    console.log(`  ${pc7.bold("Changelog:")}`);
+    console.log(`  ${pc9.bold("Changelog:")}`);
     for (const entry of item.changelog) {
-      const tag = entry.type === "feature" ? pc7.green(entry.type) : entry.type === "fix" ? pc7.yellow(entry.type) : entry.type === "breaking" ? pc7.red(entry.type) : pc7.dim(entry.type);
+      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);
       console.log(
-        `    ${pc7.cyan(entry.version)}  ${pc7.dim(entry.date)}  ${tag}  ${entry.note}`
+        `    ${pc9.cyan(entry.version)}  ${pc9.dim(entry.date)}  ${tag}  ${entry.note}`
       );
     }
   }
   console.log();
   const fileCount = item.files.length;
-  console.log(`  ${pc7.bold(`Files:`)} ${pc7.dim(`(${fileCount})`)}`);
+  console.log(`  ${pc9.bold(`Files:`)} ${pc9.dim(`(${fileCount})`)}`);
   const maxShown = 10;
   for (const file of item.files.slice(0, maxShown)) {
-    console.log(`    ${pc7.dim(file.path)}`);
+    console.log(`    ${pc9.dim(file.path)}`);
   }
   if (fileCount > maxShown) {
-    console.log(`    ${pc7.dim(`... and ${fileCount - maxShown} more`)}`);
+    console.log(`    ${pc9.dim(`... and ${fileCount - maxShown} more`)}`);
   }
   const installed = config.installed?.[item.name];
   if (installed) {
     console.log();
     console.log(
-      `  ${pc7.green("Installed")} ${pc7.dim(`v${installed.version}`)}`
+      `  ${pc9.green("Installed")} ${pc9.dim(`v${installed.version}`)}`
     );
     if (version !== installed.version) {
       console.log(
-        `  ${pc7.yellow("Update available:")} ${pc7.dim(`v${installed.version}`)} \u2192 ${pc7.cyan(`v${version}`)}`
+        `  ${pc9.yellow("Update available:")} ${pc9.dim(`v${installed.version}`)} \u2192 ${pc9.cyan(`v${version}`)}`
       );
     }
   }
@@ -1196,8 +1866,8 @@ __export(registry_exports, {
   registryListCommand: () => registryListCommand,
   registryRemoveCommand: () => registryRemoveCommand
 });
-import * as p8 from "@clack/prompts";
-import pc8 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);
@@ -1216,8 +1886,8 @@ async function registryAddCommand(namespace, url, opts = {}) {
   }
   config.registries[namespace] = url;
   await writeConfig(cwd, config);
-  p8.log.success(`Added registry ${pc8.bold(namespace)}`);
-  p8.log.message(pc8.dim(`  ${url}`));
+  p11.log.success(`Added registry ${pc10.bold(namespace)}`);
+  p11.log.message(pc10.dim(`  ${url}`));
 }
 async function registryRemoveCommand(namespace, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -1239,11 +1909,11 @@ async function registryRemoveCommand(namespace, opts = {}) {
   }
   delete config.registries[namespace];
   await writeConfig(cwd, config);
-  p8.log.success(`Removed registry ${pc8.bold(namespace)}`);
+  p11.log.success(`Removed registry ${pc10.bold(namespace)}`);
   if (affectedComponents.length > 0) {
-    p8.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:`);
+    p11.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:`);
     for (const name of affectedComponents) {
-      p8.log.message(`  ${pc8.yellow("!")} ${name}`);
+      p11.log.message(`  ${pc10.yellow("!")} ${name}`);
     }
   }
   return { affectedComponents };
@@ -1254,10 +1924,10 @@ async function registryListCommand(opts = {}) {
   if (!config) throw new Error("No kitn.json found. Run `kitn init` first.");
   const entries = Object.entries(config.registries).map(([namespace, url]) => ({ namespace, url }));
   if (entries.length === 0) {
-    p8.log.message(pc8.dim("  No registries configured."));
+    p11.log.message(pc10.dim("  No registries configured."));
   } else {
     for (const { namespace, url } of entries) {
-      p8.log.message(`  ${pc8.bold(namespace.padEnd(16))} ${pc8.dim(url)}`);
+      p11.log.message(`  ${pc10.bold(namespace.padEnd(16))} ${pc10.dim(url)}`);
     }
   }
   return entries;
@@ -1347,7 +2017,7 @@ function startUpdateCheck(currentVersion) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.1.6" : "0.0.0-dev";
+var VERSION = true ? "0.1.8" : "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 () => {
@@ -1374,6 +2044,14 @@ 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);
+});
 program.command("info").description("Show details about a component").argument("<component>", "component name (e.g. weather-agent, @acme/tool@1.0.0)").action(async (component) => {
   const { infoCommand: infoCommand2 } = await Promise.resolve().then(() => (init_info(), info_exports));
   await infoCommand2(component);