@kitnai/cli 0.1.0 → 0.1.3

package/dist/index.js

@@ -29,8 +29,9 @@ var componentType, installedComponentSchema, configSchema, CONFIG_FILE;
 var init_config = __esm({
   "src/utils/config.ts"() {
     "use strict";
-    componentType = z.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage"]);
+    componentType = z.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage", "kitn:package"]);
     installedComponentSchema = z.object({
+      registry: z.string().optional(),
       version: z.string(),
       installedAt: z.string(),
       files: z.array(z.string()),
@@ -39,71 +40,21 @@ var init_config = __esm({
     configSchema = z.object({
       $schema: z.string().optional(),
       runtime: z.enum(["bun", "node", "deno"]),
+      framework: z.enum(["hono", "cloudflare", "elysia", "fastify", "express"]).optional(),
       aliases: z.object({
+        base: z.string().optional(),
         agents: z.string(),
         tools: z.string(),
         skills: z.string(),
         storage: z.string()
       }),
       registries: z.record(z.string(), z.string()),
-      _installed: z.record(z.string(), installedComponentSchema).optional()
+      installed: z.record(z.string(), installedComponentSchema).optional()
     });
     CONFIG_FILE = "kitn.json";
   }
 });
 
-// src/utils/detect.ts
-import { access } from "fs/promises";
-import { join as join2 } from "path";
-async function detectPackageManager(dir) {
-  for (const [lockfile, pm] of LOCKFILE_MAP) {
-    try {
-      await access(join2(dir, lockfile));
-      return pm;
-    } catch {
-    }
-  }
-  return null;
-}
-var LOCKFILE_MAP;
-var init_detect = __esm({
-  "src/utils/detect.ts"() {
-    "use strict";
-    LOCKFILE_MAP = [
-      ["bun.lock", "bun"],
-      ["bun.lockb", "bun"],
-      ["pnpm-lock.yaml", "pnpm"],
-      ["yarn.lock", "yarn"],
-      ["package-lock.json", "npm"]
-    ];
-  }
-});
-
-// src/installers/dep-installer.ts
-import { execSync } from "child_process";
-function installDependencies(pm, deps, projectDir) {
-  if (deps.length === 0) return;
-  const pkgs = deps.join(" ");
-  const cmd = (() => {
-    switch (pm) {
-      case "bun":
-        return `bun add ${pkgs}`;
-      case "pnpm":
-        return `pnpm add ${pkgs}`;
-      case "yarn":
-        return `yarn add ${pkgs}`;
-      case "npm":
-        return `npm install ${pkgs}`;
-    }
-  })();
-  execSync(cmd, { cwd: projectDir, stdio: "pipe" });
-}
-var init_dep_installer = __esm({
-  "src/installers/dep-installer.ts"() {
-    "use strict";
-  }
-});
-
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -138,74 +89,81 @@ async function initCommand() {
     p.cancel("Init cancelled.");
     process.exit(0);
   }
-  const aliases = await p.group({
-    agents: () => p.text({
-      message: "Where should agents be installed?",
-      initialValue: "src/agents",
-      placeholder: "src/agents"
-    }),
-    tools: () => p.text({
-      message: "Where should tools be installed?",
-      initialValue: "src/tools",
-      placeholder: "src/tools"
-    }),
-    skills: () => p.text({
-      message: "Where should skills be installed?",
-      initialValue: "src/skills",
-      placeholder: "src/skills"
-    }),
-    storage: () => p.text({
-      message: "Where should storage adapters be installed?",
-      initialValue: "src/storage",
-      placeholder: "src/storage"
-    })
+  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);
+  }
+  const base = await p.text({
+    message: "Where should kitn packages be installed?",
+    initialValue: "src/ai",
+    placeholder: "src/ai"
   });
-  if (p.isCancel(aliases)) {
+  if (p.isCancel(base)) {
     p.cancel("Init cancelled.");
     process.exit(0);
   }
+  const baseDir = base;
   const config = {
     runtime,
+    framework,
     aliases: {
-      agents: aliases.agents,
-      tools: aliases.tools,
-      skills: aliases.skills,
-      storage: aliases.storage
+      base: baseDir,
+      agents: `${baseDir}/agents`,
+      tools: `${baseDir}/tools`,
+      skills: `${baseDir}/skills`,
+      storage: `${baseDir}/storage`
     },
     registries: {
-      "@kitn": "https://kitn-ai.github.io/kitn/r/{type}/{name}.json"
+      "@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");
-  const pm = await detectPackageManager(cwd);
-  if (pm) {
-    const shouldInstall = await p.confirm({
-      message: `Install @kitnai/server using ${pm}?`,
-      initialValue: true
-    });
-    if (!p.isCancel(shouldInstall) && shouldInstall) {
-      s.start("Installing @kitnai/server...");
-      try {
-        installDependencies(pm, ["@kitnai/server"], cwd);
-        s.stop("Installed @kitnai/server");
-      } catch {
-        s.stop(pc.yellow("Failed to install @kitnai/server \u2014 you can install it manually"));
-      }
-    }
-  } else {
-    p.log.info("No package manager detected. Install @kitnai/server manually.");
-  }
-  p.outro(pc.green("Done! Run `kitn add <component>` to add your first component."));
+  p.outro(pc.green("Done! Run `kitn add core` to install the engine, then `kitn add routes` for HTTP routes."));
 }
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
     init_config();
-    init_detect();
-    init_dep_installer();
+  }
+});
+
+// src/utils/detect.ts
+import { access } from "fs/promises";
+import { join as join2 } from "path";
+async function detectPackageManager(dir) {
+  for (const [lockfile, pm] of LOCKFILE_MAP) {
+    try {
+      await access(join2(dir, lockfile));
+      return pm;
+    } catch {
+    }
+  }
+  return null;
+}
+var LOCKFILE_MAP;
+var init_detect = __esm({
+  "src/utils/detect.ts"() {
+    "use strict";
+    LOCKFILE_MAP = [
+      ["bun.lock", "bun"],
+      ["bun.lockb", "bun"],
+      ["pnpm-lock.yaml", "pnpm"],
+      ["yarn.lock", "yarn"],
+      ["package-lock.json", "npm"]
+    ];
   }
 });
 
@@ -222,21 +180,22 @@ var init_fetcher = __esm({
         this.registries = registries;
         this.fetchFn = fetchFn ?? this.defaultFetch;
       }
-      resolveUrl(name, typeDir) {
-        const template = this.registries["@kitn"];
-        if (!template) throw new Error("No @kitn registry configured");
-        return template.replace("{name}", name).replace("{type}", typeDir);
+      resolveUrl(name, typeDir, namespace = "@kitn", version) {
+        const template = this.registries[namespace];
+        if (!template) throw new Error(`No registry configured for ${namespace}`);
+        const fileName = version ? `${name}@${version}` : name;
+        return template.replace("{name}", fileName).replace("{type}", typeDir);
       }
-      async fetchItem(name, typeDir) {
-        const url = this.resolveUrl(name, typeDir);
+      async fetchItem(name, typeDir, namespace = "@kitn", version) {
+        const url = this.resolveUrl(name, typeDir, namespace, version);
         if (!this.cache.has(url)) {
           this.cache.set(url, this.fetchFn(url));
         }
         return this.cache.get(url);
       }
-      async fetchIndex() {
-        const template = this.registries["@kitn"];
-        if (!template) throw new Error("No @kitn registry configured");
+      async fetchIndex(namespace = "@kitn") {
+        const template = this.registries[namespace];
+        if (!template) throw new Error(`No registry configured for ${namespace}`);
         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}`);
@@ -342,6 +301,31 @@ var init_file_writer = __esm({
   }
 });
 
+// src/installers/dep-installer.ts
+import { execSync } from "child_process";
+function installDependencies(pm, deps, projectDir) {
+  if (deps.length === 0) return;
+  const pkgs = deps.join(" ");
+  const cmd = (() => {
+    switch (pm) {
+      case "bun":
+        return `bun add ${pkgs}`;
+      case "pnpm":
+        return `pnpm add ${pkgs}`;
+      case "yarn":
+        return `yarn add ${pkgs}`;
+      case "npm":
+        return `npm install ${pkgs}`;
+    }
+  })();
+  execSync(cmd, { cwd: projectDir, stdio: "pipe" });
+}
+var init_dep_installer = __esm({
+  "src/installers/dep-installer.ts"() {
+    "use strict";
+  }
+});
+
 // src/installers/env-checker.ts
 import pc2 from "picocolors";
 function checkEnvVars(envVars) {
@@ -359,6 +343,79 @@ var init_env_checker = __esm({
   }
 });
 
+// src/installers/import-rewriter.ts
+import { relative, join as join3 } from "path";
+function rewriteKitnImports(content, fileType, fileName, aliases) {
+  const sourceAliasKey = TYPE_TO_ALIAS_KEY[fileType];
+  if (!sourceAliasKey) return content;
+  const sourceDir = aliases[sourceAliasKey];
+  return content.replace(
+    /((?:import|export)\s+.*?\s+from\s+["'])@kitn\/([\w-]+)\/([^"']+)(["'])/g,
+    (_match, prefix, type, targetPath, quote) => {
+      if (!KNOWN_TYPES.includes(type)) {
+        return `${prefix}@kitn/${type}/${targetPath}${quote}`;
+      }
+      const targetDir = aliases[type];
+      const targetFile = join3(targetDir, targetPath);
+      let rel = relative(sourceDir, targetFile);
+      rel = rel.split("\\").join("/");
+      if (!rel.startsWith(".")) {
+        rel = `./${rel}`;
+      }
+      return `${prefix}${rel}${quote}`;
+    }
+  );
+}
+var KNOWN_TYPES, TYPE_TO_ALIAS_KEY;
+var init_import_rewriter = __esm({
+  "src/installers/import-rewriter.ts"() {
+    "use strict";
+    KNOWN_TYPES = ["agents", "tools", "skills", "storage"];
+    TYPE_TO_ALIAS_KEY = {
+      "kitn:agent": "agents",
+      "kitn:tool": "tools",
+      "kitn:skill": "skills",
+      "kitn:storage": "storage"
+    };
+  }
+});
+
+// src/installers/tsconfig-patcher.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+function stripJsonc(text2) {
+  return text2.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 = join4(projectDir, "tsconfig.json");
+  let content;
+  try {
+    content = await readFile3(tsconfigPath, "utf-8");
+  } catch {
+    content = "{}";
+  }
+  const patched = patchTsconfig(content, paths);
+  await writeFile3(tsconfigPath, patched);
+}
+var init_tsconfig_patcher = __esm({
+  "src/installers/tsconfig-patcher.ts"() {
+    "use strict";
+  }
+});
+
 // src/utils/hash.ts
 import { createHash } from "crypto";
 function contentHash(content) {
@@ -370,18 +427,52 @@ var init_hash = __esm({
   }
 });
 
+// src/utils/parse-ref.ts
+function parseComponentRef(input) {
+  let namespace = "@kitn";
+  let rest = input;
+  if (rest.startsWith("@")) {
+    const slashIdx = rest.indexOf("/");
+    if (slashIdx === -1) {
+      throw new Error(`Invalid component reference: ${input}. Expected @namespace/name`);
+    }
+    namespace = rest.slice(0, slashIdx);
+    rest = rest.slice(slashIdx + 1);
+  }
+  const atIdx = rest.indexOf("@");
+  if (atIdx === -1) {
+    return { namespace, name: rest, version: void 0 };
+  }
+  return {
+    namespace,
+    name: rest.slice(0, atIdx),
+    version: rest.slice(atIdx + 1)
+  };
+}
+var init_parse_ref = __esm({
+  "src/utils/parse-ref.ts"() {
+    "use strict";
+  }
+});
+
 // src/registry/schema.ts
 import { z as z2 } from "zod";
-var componentType2, registryFileSchema, registryItemSchema, registryIndexItemSchema, registryIndexSchema, typeToDir;
+var componentType2, registryFileSchema, changelogEntrySchema, registryItemSchema, registryIndexItemSchema, registryIndexSchema, typeToDir;
 var init_schema = __esm({
   "src/registry/schema.ts"() {
     "use strict";
-    componentType2 = z2.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage"]);
+    componentType2 = z2.enum(["kitn:agent", "kitn:tool", "kitn:skill", "kitn:storage", "kitn:package"]);
     registryFileSchema = z2.object({
       path: z2.string(),
       content: z2.string(),
       type: componentType2
     });
+    changelogEntrySchema = z2.object({
+      version: z2.string(),
+      date: z2.string(),
+      type: z2.enum(["feature", "fix", "breaking", "initial"]),
+      note: z2.string()
+    });
     registryItemSchema = z2.object({
       $schema: z2.string().optional(),
       name: z2.string(),
@@ -392,9 +483,13 @@ var init_schema = __esm({
       registryDependencies: z2.array(z2.string()).optional(),
       envVars: z2.record(z2.string(), z2.string()).optional(),
       files: z2.array(registryFileSchema),
+      installDir: z2.string().optional(),
+      tsconfig: z2.record(z2.string(), z2.array(z2.string())).optional(),
       docs: z2.string().optional(),
       categories: z2.array(z2.string()).optional(),
-      version: z2.string().optional()
+      version: z2.string().optional(),
+      updatedAt: z2.string().optional(),
+      changelog: z2.array(changelogEntrySchema).optional()
     });
     registryIndexItemSchema = z2.object({
       name: z2.string(),
@@ -402,7 +497,9 @@ var init_schema = __esm({
       description: z2.string(),
       registryDependencies: z2.array(z2.string()).optional(),
       categories: z2.array(z2.string()).optional(),
-      version: z2.string().optional()
+      version: z2.string().optional(),
+      versions: z2.array(z2.string()).optional(),
+      updatedAt: z2.string().optional()
     });
     registryIndexSchema = z2.object({
       $schema: z2.string().optional(),
@@ -413,7 +510,8 @@ var init_schema = __esm({
       "kitn:agent": "agents",
       "kitn:tool": "tools",
       "kitn:skill": "skills",
-      "kitn:storage": "storage"
+      "kitn:storage": "storage",
+      "kitn:package": "package"
     };
   }
 });
@@ -425,7 +523,7 @@ __export(add_exports, {
 });
 import * as p2 from "@clack/prompts";
 import pc3 from "picocolors";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 async function addCommand(components, opts) {
   p2.intro(pc3.bgCyan(pc3.black(" kitn add ")));
   const cwd = process.cwd();
@@ -438,17 +536,26 @@ async function addCommand(components, opts) {
     p2.log.error("Please specify at least one component to add.");
     process.exit(1);
   }
+  const resolvedComponents = components.map((c) => {
+    if (c === "routes") {
+      const fw = config.framework ?? "hono";
+      return fw;
+    }
+    return c;
+  });
+  const refs = resolvedComponents.map(parseComponentRef);
   const fetcher = new RegistryFetcher(config.registries);
   const s = p2.spinner();
   s.start("Resolving dependencies...");
   let resolved;
   try {
-    resolved = await resolveDependencies(components, async (name) => {
-      const index = await fetcher.fetchIndex();
+    resolved = await resolveDependencies(resolvedComponents, async (name) => {
+      const ref = refs.find((r) => r.name === name) ?? { namespace: "@kitn", name, version: void 0 };
+      const index = await fetcher.fetchIndex(ref.namespace);
       const indexItem = index.items.find((i) => i.name === name);
-      if (!indexItem) throw new Error(`Component '${name}' not found in registry`);
+      if (!indexItem) throw new Error(`Component '${name}' not found in ${ref.namespace} registry`);
       const dir = typeToDir[indexItem.type];
-      return fetcher.fetchItem(name, dir);
+      return fetcher.fetchItem(name, dir, ref.namespace, ref.version);
     });
   } catch (err) {
     s.stop(pc3.red("Failed to resolve dependencies"));
@@ -458,7 +565,7 @@ async function addCommand(components, opts) {
   s.stop(`Resolved ${resolved.length} component(s)`);
   p2.log.info("Components to install:");
   for (const item of resolved) {
-    const isExplicit = components.includes(item.name);
+    const isExplicit = resolvedComponents.includes(item.name) || components.includes(item.name);
     const label = isExplicit ? item.name : `${item.name} ${pc3.dim("(dependency)")}`;
     p2.log.message(`  ${pc3.cyan(label)}`);
   }
@@ -472,62 +579,68 @@ async function addCommand(components, opts) {
     if (item.envVars) {
       allEnvWarnings.push(...checkEnvVars(item.envVars));
     }
-    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";
-          case "kitn:storage":
-            return "storage";
-        }
-      })();
-      const fileName = file.path.split("/").pop();
-      const targetPath = join3(cwd, config.aliases[aliasKey], fileName);
-      const relativePath = join3(config.aliases[aliasKey], fileName);
-      const status = await checkFileStatus(targetPath, file.content);
-      switch (status) {
-        case "new" /* New */:
-          await writeComponentFile(targetPath, file.content);
-          created.push(relativePath);
-          break;
-        case "identical" /* Identical */:
-          skipped.push(relativePath);
-          break;
-        case "different" /* Different */:
-          if (opts.overwrite) {
+    if (item.type === "kitn:package") {
+      const baseDir = config.aliases.base ?? "src/ai";
+      for (const file of item.files) {
+        const targetPath = join5(cwd, baseDir, file.path);
+        const relativePath = join5(baseDir, file.path);
+        const status = await checkFileStatus(targetPath, file.content);
+        switch (status) {
+          case "new" /* New */:
             await writeComponentFile(targetPath, file.content);
-            updated.push(relativePath);
-          } else {
-            const existing = await readExistingFile(targetPath);
-            const diff = generateDiff(relativePath, existing ?? "", file.content);
-            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 (!p2.isCancel(action) && action === "overwrite") {
+            created.push(relativePath);
+            break;
+          case "identical" /* Identical */:
+            skipped.push(relativePath);
+            break;
+          case "different" /* Different */:
+            if (opts.overwrite) {
               await writeComponentFile(targetPath, file.content);
               updated.push(relativePath);
             } else {
-              skipped.push(relativePath);
+              const existing = await readExistingFile(targetPath);
+              const diff = generateDiff(relativePath, existing ?? "", file.content);
+              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 (!p2.isCancel(action) && action === "overwrite") {
+                await writeComponentFile(targetPath, file.content);
+                updated.push(relativePath);
+              } else {
+                skipped.push(relativePath);
+              }
             }
-          }
-          break;
+            break;
+        }
       }
-    }
-    const installed = config._installed ?? {};
-    const allContent = item.files.map((f) => f.content).join("\n");
-    installed[item.name] = {
-      version: item.version ?? "1.0.0",
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      files: item.files.map((f) => {
+      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) => `./${join5(baseDir, installDir, v)}`);
+        }
+        await patchProjectTsconfig(cwd, resolvedPaths);
+        p2.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 };
+      const installedKey = ref.namespace === "@kitn" ? item.name : `${ref.namespace}/${item.name}`;
+      installed[installedKey] = {
+        registry: ref.namespace,
+        version: item.version ?? "1.0.0",
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files: item.files.map((f) => join5(baseDir, f.path)),
+        hash: contentHash(allContent)
+      };
+      config.installed = installed;
+    } else {
+      for (const file of item.files) {
         const aliasKey = (() => {
           switch (item.type) {
             case "kitn:agent":
@@ -540,12 +653,75 @@ async function addCommand(components, opts) {
               return "storage";
           }
         })();
-        const fileName = f.path.split("/").pop();
-        return join3(config.aliases[aliasKey], fileName);
-      }),
-      hash: contentHash(allContent)
-    };
-    config._installed = installed;
+        const fileName = file.path.split("/").pop();
+        const targetPath = join5(cwd, config.aliases[aliasKey], fileName);
+        const relativePath = join5(config.aliases[aliasKey], fileName);
+        const content = rewriteKitnImports(file.content, item.type, fileName, config.aliases);
+        const status = await checkFileStatus(targetPath, content);
+        switch (status) {
+          case "new" /* New */:
+            await writeComponentFile(targetPath, content);
+            created.push(relativePath);
+            break;
+          case "identical" /* Identical */:
+            skipped.push(relativePath);
+            break;
+          case "different" /* Different */:
+            if (opts.overwrite) {
+              await writeComponentFile(targetPath, content);
+              updated.push(relativePath);
+            } else {
+              const existing = await readExistingFile(targetPath);
+              const diff = generateDiff(relativePath, existing ?? "", content);
+              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 (!p2.isCancel(action) && action === "overwrite") {
+                await writeComponentFile(targetPath, content);
+                updated.push(relativePath);
+              } else {
+                skipped.push(relativePath);
+              }
+            }
+            break;
+        }
+      }
+      const installed = config.installed ?? {};
+      const allContent = item.files.map((f) => {
+        const fn = f.path.split("/").pop();
+        return rewriteKitnImports(f.content, item.type, fn, config.aliases);
+      }).join("\n");
+      const ref = refs.find((r) => r.name === item.name) ?? { namespace: "@kitn", name: item.name, version: void 0 };
+      const installedKey = ref.namespace === "@kitn" ? item.name : `${ref.namespace}/${item.name}`;
+      installed[installedKey] = {
+        registry: ref.namespace,
+        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 join5(config.aliases[aliasKey], fileName);
+        }),
+        hash: contentHash(allContent)
+      };
+      config.installed = installed;
+    }
   }
   await writeConfig(cwd, config);
   const uniqueDeps = [...new Set(allDeps)];
@@ -594,7 +770,10 @@ var init_add = __esm({
     init_file_writer();
     init_dep_installer();
     init_env_checker();
+    init_import_rewriter();
+    init_tsconfig_patcher();
     init_hash();
+    init_parse_ref();
     init_schema();
   }
 });
@@ -614,40 +793,70 @@ async function listCommand(opts) {
     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 ${pc4.bold(opts.registry)} is not configured. Run ${pc4.bold("kitn registry list")} to see configured registries.`);
+    process.exit(1);
+  }
   const s = p3.spinner();
   s.start("Fetching registry index...");
-  let index;
-  try {
-    index = await fetcher.fetchIndex();
-  } catch (err) {
-    s.stop(pc4.red("Failed to fetch registry"));
-    p3.log.error(err.message);
+  const allItems = [];
+  const errors = [];
+  for (const namespace of namespacesToFetch) {
+    try {
+      const index = await fetcher.fetchIndex(namespace);
+      for (const item of index.items) {
+        allItems.push({ ...item, namespace });
+      }
+    } catch (err) {
+      errors.push(`${namespace}: ${err.message}`);
+    }
+  }
+  if (allItems.length === 0 && errors.length > 0) {
+    s.stop(pc4.red("Failed to fetch registries"));
+    for (const e of errors) p3.log.error(e);
     process.exit(1);
   }
-  s.stop(`Found ${index.items.length} components`);
-  const installed = config._installed ?? {};
+  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(`${pc4.yellow("\u26A0")} Failed to fetch ${e}`);
+  }
+  const installed = config.installed ?? {};
   const typeGroups = /* @__PURE__ */ new Map();
-  for (const item of index.items) {
+  for (const item of allItems) {
     if (opts.type && !item.type.endsWith(opts.type)) continue;
-    const group2 = item.type.replace("kitn:", "");
-    if (!typeGroups.has(group2)) typeGroups.set(group2, []);
-    typeGroups.get(group2).push(item);
+    const group = item.type.replace("kitn:", "");
+    if (!typeGroups.has(group)) typeGroups.set(group, []);
+    typeGroups.get(group).push(item);
   }
-  for (const [group2, items] of typeGroups) {
+  let installedCount = 0;
+  let updateCount = 0;
+  for (const [group, items] of typeGroups) {
     p3.log.message(pc4.bold(`
-${group2.charAt(0).toUpperCase() + group2.slice(1)}s:`));
+${group.charAt(0).toUpperCase() + group.slice(1)}s:`));
     for (const item of items) {
-      const inst = installed[item.name];
+      const displayName = item.namespace === "@kitn" ? item.name : `${item.namespace}/${item.name}`;
+      const inst = installed[item.name] ?? installed[displayName];
       if (opts.installed && !inst) continue;
+      const version = pc4.dim(`v${item.version ?? "1.0.0"}`);
       if (inst) {
+        installedCount++;
         const status = pc4.green("\u2713");
-        p3.log.message(`  ${status} ${item.name}  ${pc4.dim(item.description)}`);
+        const hasUpdate = item.version && inst.version !== item.version;
+        const updateTag = hasUpdate ? pc4.yellow(` \u2B06 v${item.version} available`) : "";
+        if (hasUpdate) updateCount++;
+        p3.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc4.dim(item.description)}${updateTag}`);
       } else {
         const status = pc4.dim("\u25CB");
-        p3.log.message(`  ${status} ${item.name}  ${pc4.dim(item.description)}`);
+        p3.log.message(`  ${status} ${displayName.padEnd(20)} ${version}  ${pc4.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(pc4.dim(`  ${parts.join(", ")}`));
 }
 var init_list = __esm({
   "src/commands/list.ts"() {
@@ -663,7 +872,7 @@ __export(diff_exports, {
   diffCommand: () => diffCommand
 });
 import * as p4 from "@clack/prompts";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 async function diffCommand(componentName) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
@@ -671,48 +880,67 @@ async function diffCommand(componentName) {
     p4.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
-  const installed = config._installed?.[componentName];
+  const input = componentName === "routes" ? config.framework ?? "hono" : componentName;
+  const ref = parseComponentRef(input);
+  const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
+  const installed = config.installed?.[installedKey];
   if (!installed) {
-    p4.log.error(`Component '${componentName}' is not installed.`);
+    p4.log.error(`Component '${ref.name}' is not installed.`);
     process.exit(1);
   }
+  const namespace = installed.registry ?? ref.namespace;
   const fetcher = new RegistryFetcher(config.registries);
-  const index = await fetcher.fetchIndex();
-  const indexItem = index.items.find((i) => i.name === componentName);
+  const index = await fetcher.fetchIndex(namespace);
+  const indexItem = index.items.find((i) => i.name === ref.name);
   if (!indexItem) {
-    p4.log.error(`Component '${componentName}' not found in registry.`);
+    p4.log.error(`Component '${ref.name}' not found in ${namespace} registry.`);
     process.exit(1);
   }
   const dir = typeToDir[indexItem.type];
-  const registryItem = await fetcher.fetchItem(componentName, dir);
+  const registryItem = await fetcher.fetchItem(ref.name, dir, namespace, ref.version);
   let hasDiff = false;
   for (const file of registryItem.files) {
-    const fileName = file.path.split("/").pop();
-    const aliasKey = (() => {
-      switch (indexItem.type) {
-        case "kitn:agent":
-          return "agents";
-        case "kitn:tool":
-          return "tools";
-        case "kitn:skill":
-          return "skills";
-        case "kitn:storage":
-          return "storage";
+    if (indexItem.type === "kitn:package") {
+      const baseDir = config.aliases.base ?? "src/ai";
+      const localPath = join6(cwd, baseDir, file.path);
+      const relativePath = join6(baseDir, file.path);
+      const localContent = await readExistingFile(localPath);
+      if (localContent === null) {
+        p4.log.warn(`${relativePath}: file missing locally`);
+        hasDiff = true;
+      } else if (localContent !== file.content) {
+        const diff = generateDiff(relativePath, localContent, file.content);
+        console.log(diff);
+        hasDiff = true;
+      }
+    } else {
+      const fileName = file.path.split("/").pop();
+      const aliasKey = (() => {
+        switch (indexItem.type) {
+          case "kitn:agent":
+            return "agents";
+          case "kitn:tool":
+            return "tools";
+          case "kitn:skill":
+            return "skills";
+          case "kitn:storage":
+            return "storage";
+        }
+      })();
+      const localPath = join6(cwd, config.aliases[aliasKey], fileName);
+      const localContent = await readExistingFile(localPath);
+      if (localContent === null) {
+        p4.log.warn(`${fileName}: file missing locally`);
+        hasDiff = true;
+      } else if (localContent !== file.content) {
+        const diff = generateDiff(fileName, localContent, file.content);
+        console.log(diff);
+        hasDiff = true;
       }
-    })();
-    const localPath = join4(cwd, config.aliases[aliasKey], fileName);
-    const localContent = await readExistingFile(localPath);
-    if (localContent === null) {
-      p4.log.warn(`${fileName}: file missing locally`);
-      hasDiff = true;
-    } else if (localContent !== file.content) {
-      const diff = generateDiff(fileName, localContent, file.content);
-      console.log(diff);
-      hasDiff = true;
     }
   }
   if (!hasDiff) {
-    p4.log.success(`${componentName}: up to date, no differences.`);
+    p4.log.success(`${ref.name}: up to date, no differences.`);
   }
 }
 var init_diff = __esm({
@@ -721,6 +949,7 @@ var init_diff = __esm({
     init_config();
     init_fetcher();
     init_file_writer();
+    init_parse_ref();
     init_schema();
   }
 });
@@ -732,7 +961,7 @@ __export(remove_exports, {
 });
 import * as p5 from "@clack/prompts";
 import pc5 from "picocolors";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { unlink } from "fs/promises";
 async function removeCommand(componentName) {
   const cwd = process.cwd();
@@ -741,13 +970,16 @@ async function removeCommand(componentName) {
     p5.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
-  const installed = config._installed?.[componentName];
+  const input = componentName === "routes" ? config.framework ?? "hono" : componentName;
+  const ref = parseComponentRef(input);
+  const installedKey = ref.namespace === "@kitn" ? ref.name : `${ref.namespace}/${ref.name}`;
+  const installed = config.installed?.[installedKey];
   if (!installed) {
-    p5.log.error(`Component '${componentName}' is not installed.`);
+    p5.log.error(`Component '${ref.name}' is not installed.`);
     process.exit(1);
   }
   const shouldRemove = await p5.confirm({
-    message: `Remove ${componentName}? This will delete ${installed.files.length} file(s).`,
+    message: `Remove ${ref.name}? This will delete ${installed.files.length} file(s).`,
     initialValue: false
   });
   if (p5.isCancel(shouldRemove) || !shouldRemove) {
@@ -757,19 +989,19 @@ async function removeCommand(componentName) {
   const deleted = [];
   for (const filePath of installed.files) {
     try {
-      await unlink(join5(cwd, filePath));
+      await unlink(join7(cwd, filePath));
       deleted.push(filePath);
     } catch {
       p5.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
     }
   }
-  delete config._installed[componentName];
-  if (Object.keys(config._installed).length === 0) {
-    delete config._installed;
+  delete config.installed[installedKey];
+  if (Object.keys(config.installed).length === 0) {
+    delete config.installed;
   }
   await writeConfig(cwd, config);
   if (deleted.length > 0) {
-    p5.log.success(`Removed ${componentName}:`);
+    p5.log.success(`Removed ${ref.name}:`);
     for (const f of deleted) p5.log.message(`  ${pc5.red("-")} ${f}`);
   }
 }
@@ -777,6 +1009,7 @@ var init_remove = __esm({
   "src/commands/remove.ts"() {
     "use strict";
     init_config();
+    init_parse_ref();
   }
 });
 
@@ -785,13 +1018,226 @@ var update_exports = {};
 __export(update_exports, {
   updateCommand: () => updateCommand
 });
+import * as p6 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.");
+      process.exit(1);
+    }
+    const installed = config.installed;
+    if (!installed || Object.keys(installed).length === 0) {
+      p6.log.info("No installed components to update.");
+      return;
+    }
+    components = Object.keys(installed);
+  }
   await addCommand(components, { overwrite: true });
 }
 var init_update = __esm({
   "src/commands/update.ts"() {
     "use strict";
     init_add();
+    init_config();
+  }
+});
+
+// src/commands/info.ts
+var info_exports = {};
+__export(info_exports, {
+  infoCommand: () => infoCommand
+});
+import * as p7 from "@clack/prompts";
+import pc6 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.");
+    process.exit(1);
+  }
+  const ref = parseComponentRef(component);
+  const fetcher = new RegistryFetcher(config.registries);
+  const s = p7.spinner();
+  s.start("Fetching component info...");
+  let index;
+  try {
+    index = await fetcher.fetchIndex(ref.namespace);
+  } catch (err) {
+    s.stop(pc6.red("Failed to fetch registry"));
+    p7.log.error(err.message);
+    process.exit(1);
+  }
+  const indexItem = index.items.find((i) => i.name === ref.name);
+  if (!indexItem) {
+    s.stop(pc6.red("Component not found"));
+    p7.log.error(`Component '${ref.name}' not found in registry.`);
+    process.exit(1);
+  }
+  const dir = typeToDir[indexItem.type];
+  let item;
+  try {
+    item = await fetcher.fetchItem(ref.name, dir, ref.namespace, ref.version);
+  } catch (err) {
+    s.stop(pc6.red("Failed to fetch component"));
+    p7.log.error(err.message);
+    process.exit(1);
+  }
+  s.stop("Component found");
+  const version = item.version ?? indexItem.version ?? "unknown";
+  const typeName = indexItem.type.replace("kitn:", "");
+  console.log();
+  console.log(
+    `  ${pc6.bold(item.name)} ${pc6.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc6.dim(ref.namespace)}`
+  );
+  console.log(`  ${pc6.dim(item.description)}`);
+  console.log();
+  console.log(`  ${pc6.dim("Type:")}           ${typeName}`);
+  if (item.dependencies?.length) {
+    console.log(
+      `  ${pc6.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
+    );
+  }
+  if (item.registryDependencies?.length) {
+    console.log(
+      `  ${pc6.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
+    );
+  }
+  if (item.categories?.length) {
+    console.log(
+      `  ${pc6.dim("Categories:")}     ${item.categories.join(", ")}`
+    );
+  }
+  if (item.updatedAt) {
+    console.log(`  ${pc6.dim("Updated:")}        ${item.updatedAt}`);
+  }
+  const versions = indexItem.versions;
+  if (versions?.length) {
+    console.log(`  ${pc6.dim("Versions:")}       ${versions.join(", ")}`);
+  }
+  if (item.changelog?.length) {
+    console.log();
+    console.log(`  ${pc6.bold("Changelog:")}`);
+    for (const entry of item.changelog) {
+      const tag = entry.type === "feature" ? pc6.green(entry.type) : entry.type === "fix" ? pc6.yellow(entry.type) : entry.type === "breaking" ? pc6.red(entry.type) : pc6.dim(entry.type);
+      console.log(
+        `    ${pc6.cyan(entry.version)}  ${pc6.dim(entry.date)}  ${tag}  ${entry.note}`
+      );
+    }
+  }
+  console.log();
+  const fileCount = item.files.length;
+  console.log(`  ${pc6.bold(`Files:`)} ${pc6.dim(`(${fileCount})`)}`);
+  const maxShown = 10;
+  for (const file of item.files.slice(0, maxShown)) {
+    console.log(`    ${pc6.dim(file.path)}`);
+  }
+  if (fileCount > maxShown) {
+    console.log(`    ${pc6.dim(`... and ${fileCount - maxShown} more`)}`);
+  }
+  const installed = config.installed?.[item.name];
+  if (installed) {
+    console.log();
+    console.log(
+      `  ${pc6.green("Installed")} ${pc6.dim(`v${installed.version}`)}`
+    );
+    if (version !== installed.version) {
+      console.log(
+        `  ${pc6.yellow("Update available:")} ${pc6.dim(`v${installed.version}`)} \u2192 ${pc6.cyan(`v${version}`)}`
+      );
+    }
+  }
+  console.log();
+}
+var init_info = __esm({
+  "src/commands/info.ts"() {
+    "use strict";
+    init_config();
+    init_parse_ref();
+    init_fetcher();
+    init_schema();
+  }
+});
+
+// src/commands/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  registryAddCommand: () => registryAddCommand,
+  registryListCommand: () => registryListCommand,
+  registryRemoveCommand: () => registryRemoveCommand
+});
+import * as p8 from "@clack/prompts";
+import pc7 from "picocolors";
+async function registryAddCommand(namespace, url, 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.");
+  if (!namespace.startsWith("@")) {
+    throw new Error("Namespace must start with @ (e.g. @myteam)");
+  }
+  if (!url.includes("{type}")) {
+    throw new Error("URL template must include {type} placeholder");
+  }
+  if (!url.includes("{name}")) {
+    throw new Error("URL template must include {name} placeholder");
+  }
+  if (config.registries[namespace] && !opts.overwrite) {
+    throw new Error(`Registry '${namespace}' is already configured. Use --overwrite to replace.`);
+  }
+  config.registries[namespace] = url;
+  await writeConfig(cwd, config);
+  p8.log.success(`Added registry ${pc7.bold(namespace)}`);
+  p8.log.message(pc7.dim(`  ${url}`));
+}
+async function registryRemoveCommand(namespace, 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.");
+  if (!config.registries[namespace]) {
+    throw new Error(`Registry '${namespace}' is not configured.`);
+  }
+  if (namespace === "@kitn" && !opts.force) {
+    throw new Error("Cannot remove the default @kitn registry. Use --force to override.");
+  }
+  const affectedComponents = [];
+  if (config.installed) {
+    for (const [name, entry] of Object.entries(config.installed)) {
+      if (entry.registry === namespace) {
+        affectedComponents.push(name);
+      }
+    }
+  }
+  delete config.registries[namespace];
+  await writeConfig(cwd, config);
+  p8.log.success(`Removed registry ${pc7.bold(namespace)}`);
+  if (affectedComponents.length > 0) {
+    p8.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:`);
+    for (const name of affectedComponents) {
+      p8.log.message(`  ${pc7.yellow("!")} ${name}`);
+    }
+  }
+  return { affectedComponents };
+}
+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 }));
+  if (entries.length === 0) {
+    p8.log.message(pc7.dim("  No registries configured."));
+  } else {
+    for (const { namespace, url } of entries) {
+      p8.log.message(`  ${pc7.bold(namespace.padEnd(16))} ${pc7.dim(url)}`);
+    }
+  }
+  return entries;
+}
+var init_registry = __esm({
+  "src/commands/registry.ts"() {
+    "use strict";
+    init_config();
   }
 });
 
@@ -806,7 +1252,7 @@ program.command("add").description("Add components from the kitn registry").argu
   const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
   await addCommand2(components, opts);
 });
-program.command("list").description("List available and installed components").option("-i, --installed", "only show installed components").option("-t, --type <type>", "filter by type (agent, tool, skill, storage)").action(async (opts) => {
+program.command("list").description("List available and installed components").option("-i, --installed", "only show installed components").option("-t, --type <type>", "filter by type (agent, tool, skill, storage, package)").option("-r, --registry <namespace>", "only show components from this registry").action(async (opts) => {
   const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
   await listCommand2(opts);
 });
@@ -822,5 +1268,22 @@ 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("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);
+});
+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) => {
+  const { registryAddCommand: registryAddCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  await registryAddCommand2(namespace, url, opts);
+});
+registry.command("remove").description("Remove a component registry").argument("<namespace>", "registry namespace to remove (e.g. @myteam)").option("-f, --force", "allow removing the default @kitn registry").action(async (namespace, opts) => {
+  const { registryRemoveCommand: registryRemoveCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  await registryRemoveCommand2(namespace, opts);
+});
+registry.command("list").description("List all configured registries").action(async () => {
+  const { registryListCommand: registryListCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  await registryListCommand2();
+});
 program.parse();
 //# sourceMappingURL=index.js.map