@kitnai/cli 0.1.30 → 0.1.32

package/dist/index.js

@@ -240,7 +240,8 @@ var init_config = __esm({
         storage: z.string(),
         crons: z.string().optional()
       }),
-      registries: z.record(z.string(), registryValueSchema)
+      registries: z.record(z.string(), registryValueSchema),
+      aiTools: z.array(z.string()).optional()
     });
     FRAMEWORK_TO_ADAPTER = {
       hono: "hono",
@@ -1421,6 +1422,145 @@ var init_add = __esm({
   }
 });
 
+// src/installers/rules-generator.ts
+import { writeFile as writeFile7, mkdir as mkdir4 } from "fs/promises";
+import { join as join8, dirname as dirname4 } from "path";
+function deriveRulesBaseUrl(registries) {
+  const kitnEntry = registries["@kitn"];
+  if (!kitnEntry) {
+    throw new Error("No @kitn registry configured");
+  }
+  const url = getRegistryUrl(kitnEntry);
+  return url.replace("{type}/{name}.json", "rules/");
+}
+async function fetchRulesConfig(registries) {
+  try {
+    const baseUrl = deriveRulesBaseUrl(registries);
+    const res = await fetch(baseUrl + "config.json");
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.json();
+  } catch {
+    return FALLBACK_CONFIG;
+  }
+}
+async function fetchRulesTemplate(registries) {
+  try {
+    const baseUrl = deriveRulesBaseUrl(registries);
+    const res = await fetch(baseUrl + "template.md");
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    return await res.text();
+  } catch {
+    return FALLBACK_TEMPLATE;
+  }
+}
+function renderTemplate(template, aliases) {
+  const base = aliases.base ?? "src/ai";
+  return template.replace(/\{base\}/g, base).replace(/\{agents\}/g, aliases.agents).replace(/\{tools\}/g, aliases.tools).replace(/\{skills\}/g, aliases.skills).replace(/\{storage\}/g, aliases.storage).replace(/\{crons\}/g, aliases.crons ?? `${base}/crons`);
+}
+function wrapContent(content, tool) {
+  if (tool.format === "mdc" && tool.frontmatter) {
+    const lines = Object.entries(tool.frontmatter).map(
+      ([key, value]) => `${key}: ${value}`
+    );
+    return `---
+${lines.join("\n")}
+---
+
+${content}`;
+  }
+  return content;
+}
+async function generateRulesFiles(cwd, config, selectedToolIds) {
+  const rulesConfig = await fetchRulesConfig(config.registries);
+  const template = await fetchRulesTemplate(config.registries);
+  const rendered = renderTemplate(template, config.aliases);
+  const toolsToWrite = selectedToolIds ? rulesConfig.tools.filter((t) => selectedToolIds.includes(t.id)) : rulesConfig.tools;
+  const written = [];
+  for (const tool of toolsToWrite) {
+    const content = wrapContent(rendered, tool);
+    const filePath = join8(cwd, tool.filePath);
+    await mkdir4(dirname4(filePath), { recursive: true });
+    await writeFile7(filePath, content);
+    written.push(tool.filePath);
+  }
+  return written;
+}
+var FALLBACK_CONFIG, FALLBACK_TEMPLATE;
+var init_rules_generator = __esm({
+  "src/installers/rules-generator.ts"() {
+    "use strict";
+    init_config();
+    FALLBACK_CONFIG = {
+      version: "1.0.0",
+      tools: [
+        {
+          id: "claude-code",
+          name: "Claude Code",
+          filePath: "AGENTS.md",
+          format: "plain",
+          description: "Also works with any tool that reads AGENTS.md"
+        },
+        {
+          id: "cursor",
+          name: "Cursor",
+          filePath: ".cursor/rules/kitn.mdc",
+          format: "mdc",
+          frontmatter: {
+            description: "kitn AI agent framework conventions and patterns",
+            globs: "src/ai/**/*.ts, kitn.json"
+          }
+        },
+        {
+          id: "github-copilot",
+          name: "GitHub Copilot",
+          filePath: ".github/copilot-instructions.md",
+          format: "plain"
+        },
+        {
+          id: "cline",
+          name: "Cline",
+          filePath: ".clinerules",
+          format: "plain"
+        },
+        {
+          id: "windsurf",
+          name: "Windsurf",
+          filePath: ".windsurfrules",
+          format: "plain"
+        }
+      ]
+    };
+    FALLBACK_TEMPLATE = `# kitn AI Agent Framework
+
+This project uses **kitn** to build multi-agent AI systems.
+
+## Project Structure
+
+AI components live under \`{base}\`:
+
+- \`{agents}/\` \u2014 Agent definitions
+- \`{tools}/\` \u2014 Tool definitions
+- \`{skills}/\` \u2014 Skill files (markdown)
+- \`{storage}/\` \u2014 Storage providers
+- \`{crons}/\` \u2014 Cron job definitions
+
+## Patterns
+
+- Agents: \`registerAgent({ name, system, tools })\` from \`@kitn/core\`
+- Tools: \`tool()\` from \`ai\` + \`registerTool()\` from \`@kitn/core\`
+- Always use \`.js\` extension in relative imports
+- Use \`@kitn/core\` for core imports, \`ai\` for Vercel AI SDK
+
+## CLI
+
+- \`kitn add <name>\` \u2014 install from registry
+- \`kitn create <type> <name>\` \u2014 scaffold locally
+- \`kitn link tool <name> --to <agent>\` \u2014 wire a tool to an agent
+- \`kitn list\` \u2014 browse components
+`;
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -1428,8 +1568,20 @@ __export(init_exports, {
 });
 import * as p3 from "@clack/prompts";
 import pc4 from "picocolors";
-import { mkdir as mkdir4, writeFile as writeFile7 } from "fs/promises";
-import { join as join8 } from "path";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import { join as join9 } from "path";
+async function detectFramework(cwd) {
+  try {
+    const pkg = JSON.parse(await readFile7(join9(cwd, "package.json"), "utf-8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["elysia"]) return "elysia";
+    if (deps["@hono/zod-openapi"]) return "hono-openapi";
+    if (deps["hono"]) return "hono";
+    return null;
+  } catch {
+    return null;
+  }
+}
 function getPluginTemplate(framework) {
   const adapterName = framework === "hono-openapi" ? "hono-openapi" : framework;
   return `import { createAIPlugin } from "@kitn/adapters/${adapterName}";
@@ -1497,12 +1649,41 @@ async function initCommand(opts = {}) {
   }
   const validFrameworks = ["hono", "hono-openapi", "elysia"];
   let framework;
+  const detected = await detectFramework(cwd);
   if (opts.framework) {
     if (!validFrameworks.includes(opts.framework)) {
       p3.log.error(`Invalid framework: ${opts.framework}. Must be one of: ${validFrameworks.join(", ")}`);
       process.exit(1);
     }
     framework = opts.framework;
+  } else if (detected) {
+    framework = detected;
+    p3.log.info(`Detected ${pc4.bold(detected)} from package.json`);
+    if (!opts.yes) {
+      const confirm6 = await p3.confirm({
+        message: `Use ${detected}?`,
+        initialValue: true
+      });
+      if (p3.isCancel(confirm6)) {
+        p3.cancel("Init cancelled.");
+        process.exit(0);
+      }
+      if (!confirm6) {
+        const selected = await p3.select({
+          message: "Which HTTP framework do you use?",
+          options: [
+            { value: "hono", label: "Hono" },
+            { value: "hono-openapi", label: "Hono + OpenAPI", hint: "zod-openapi routes with /doc endpoint" },
+            { value: "elysia", label: "Elysia", hint: "Bun-native framework" }
+          ]
+        });
+        if (p3.isCancel(selected)) {
+          p3.cancel("Init cancelled.");
+          process.exit(0);
+        }
+        framework = selected;
+      }
+    }
   } else if (opts.yes) {
     framework = "hono";
   } else {
@@ -1567,13 +1748,45 @@ async function initCommand(opts = {}) {
   p3.log.info(`Patched tsconfig.json with path: ${pc4.bold("@kitn/*")}`);
   p3.log.info("Installing core engine and adapter...");
   await addCommand(["core", "routes"], { overwrite: true });
-  const aiDir = join8(cwd, baseDir);
-  await mkdir4(aiDir, { recursive: true });
-  const barrelPath = join8(aiDir, "index.ts");
-  await writeFile7(barrelPath, createBarrelFile());
-  const pluginPath = join8(aiDir, "plugin.ts");
-  await writeFile7(pluginPath, getPluginTemplate(framework));
+  const aiDir = join9(cwd, baseDir);
+  await mkdir5(aiDir, { recursive: true });
+  const barrelPath = join9(aiDir, "index.ts");
+  await writeFile8(barrelPath, createBarrelFile());
+  const pluginPath = join9(aiDir, "plugin.ts");
+  await writeFile8(pluginPath, getPluginTemplate(framework));
   p3.log.success(`Created ${pc4.bold(baseDir + "/plugin.ts")} \u2014 configure your AI provider there`);
+  try {
+    const rulesConfig = await fetchRulesConfig(config.registries);
+    let selectedToolIds;
+    if (opts.yes) {
+      selectedToolIds = rulesConfig.tools.map((t) => t.id);
+    } else {
+      const selected = await p3.multiselect({
+        message: "Which AI coding tools do you use?",
+        options: rulesConfig.tools.map((t) => ({
+          value: t.id,
+          label: t.name,
+          hint: t.description
+        })),
+        required: false
+      });
+      if (p3.isCancel(selected)) {
+        selectedToolIds = [];
+      } else {
+        selectedToolIds = selected;
+      }
+    }
+    if (selectedToolIds.length > 0) {
+      const updatedConfig = { ...config, aiTools: selectedToolIds };
+      await writeConfig(cwd, updatedConfig);
+      const written = await generateRulesFiles(cwd, updatedConfig, selectedToolIds);
+      for (const filePath of written) {
+        p3.log.success(`Created ${pc4.bold(filePath)}`);
+      }
+    }
+  } catch {
+    p3.log.warn("Could not generate AI coding tool rules (non-fatal).");
+  }
   const mountCode = framework === "elysia" ? `app.use(new Elysia({ prefix: "/api" }).use(ai.router));` : `app.route("/api", ai.router);`;
   p3.note(
     [
@@ -1601,6 +1814,7 @@ var init_init = __esm({
     init_tsconfig_patcher();
     init_barrel_manager();
     init_add();
+    init_rules_generator();
   }
 });
 
@@ -1736,7 +1950,7 @@ __export(diff_exports, {
   diffCommand: () => diffCommand
 });
 import * as p5 from "@clack/prompts";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 async function diffCommand(componentName) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
@@ -1767,8 +1981,8 @@ async function diffCommand(componentName) {
   for (const file of registryItem.files) {
     if (indexItem.type === "kitn:package") {
       const baseDir = config.aliases.base ?? "src/ai";
-      const localPath = join9(cwd, baseDir, file.path);
-      const relativePath = join9(baseDir, file.path);
+      const localPath = join10(cwd, baseDir, file.path);
+      const relativePath = join10(baseDir, file.path);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
         p5.log.warn(`${relativePath}: file missing locally`);
@@ -1792,7 +2006,7 @@ async function diffCommand(componentName) {
             return "storage";
         }
       })();
-      const localPath = join9(cwd, config.aliases[aliasKey], fileName);
+      const localPath = join10(cwd, config.aliases[aliasKey], fileName);
       const localContent = await readExistingFile(localPath);
       if (localContent === null) {
         p5.log.warn(`${fileName}: file missing locally`);
@@ -1826,8 +2040,8 @@ __export(remove_exports, {
 });
 import * as p6 from "@clack/prompts";
 import pc6 from "picocolors";
-import { join as join10, relative as relative3, dirname as dirname4 } from "path";
-import { unlink as unlink3, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import { join as join11, relative as relative3, dirname as dirname5 } from "path";
+import { unlink as unlink3, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 async function removeSingleComponent(installedKey, lock, config, cwd) {
   const entry = lock[installedKey];
@@ -1835,27 +2049,27 @@ async function removeSingleComponent(installedKey, lock, config, cwd) {
   const deleted = [];
   for (const filePath of entry.files) {
     try {
-      await unlink3(join10(cwd, filePath));
+      await unlink3(join11(cwd, filePath));
       deleted.push(filePath);
     } catch {
       p6.log.warn(`Could not delete ${filePath} (may have been moved or renamed)`);
     }
   }
   const baseDir = config.aliases.base ?? "src/ai";
-  const barrelPath = join10(cwd, baseDir, "index.ts");
-  const barrelDir = join10(cwd, baseDir);
+  const barrelPath = join11(cwd, baseDir, "index.ts");
+  const barrelDir = join11(cwd, baseDir);
   const barrelEligibleDirs = /* @__PURE__ */ new Set([
     config.aliases.agents,
     config.aliases.tools,
     config.aliases.skills
   ]);
   if (existsSync2(barrelPath) && deleted.length > 0) {
-    let barrelContent = await readFile7(barrelPath, "utf-8");
+    let barrelContent = await readFile8(barrelPath, "utf-8");
     let barrelChanged = false;
     for (const filePath of deleted) {
-      const fileDir = dirname4(filePath);
+      const fileDir = dirname5(filePath);
       if (!barrelEligibleDirs.has(fileDir)) continue;
-      const importPath = "./" + relative3(barrelDir, join10(cwd, filePath)).replace(/\\/g, "/");
+      const importPath = "./" + relative3(barrelDir, join11(cwd, filePath)).replace(/\\/g, "/");
       const updated = removeImportFromBarrel(barrelContent, importPath);
       if (updated !== barrelContent) {
         barrelContent = updated;
@@ -1863,8 +2077,8 @@ async function removeSingleComponent(installedKey, lock, config, cwd) {
       }
     }
     if (barrelChanged) {
-      await writeFile8(barrelPath, barrelContent);
-      p6.log.info(`Updated barrel file: ${join10(baseDir, "index.ts")}`);
+      await writeFile9(barrelPath, barrelContent);
+      p6.log.info(`Updated barrel file: ${join11(baseDir, "index.ts")}`);
     }
   }
   delete lock[installedKey];
@@ -2012,6 +2226,19 @@ var init_update = __esm({
   }
 });
 
+// src/utils/naming.ts
+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(" ");
+}
+var init_naming = __esm({
+  "src/utils/naming.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/create.ts
 var create_exports = {};
 __export(create_exports, {
@@ -2020,15 +2247,9 @@ __export(create_exports, {
 });
 import * as p8 from "@clack/prompts";
 import pc7 from "picocolors";
-import { join as join11, relative as relative4 } from "path";
+import { join as join12, relative as relative4 } from "path";
 import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir5 } from "fs/promises";
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-function toTitleCase(str) {
-  return str.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
+import { readFile as readFile9, writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
 function generateAgentSource(name) {
   const camel = toCamelCase(name);
   return `import { registerAgent } from "@kitn/core";
@@ -2135,7 +2356,7 @@ async function createComponentInProject(type, name, opts) {
   const validType = type;
   const kitnType = typeToKitnType[validType];
   const fileName = validType === "skill" ? `${name}.md` : `${name}.ts`;
-  const filePath = join11(cwd, getInstallPath(config, kitnType, fileName));
+  const filePath = join12(cwd, getInstallPath(config, kitnType, fileName));
   const dummyContent = "";
   const status = await checkFileStatus(filePath, dummyContent);
   if (status !== "new" /* New */) {
@@ -2163,18 +2384,18 @@ async function createComponentInProject(type, name, opts) {
   let barrelUpdated = false;
   if (BARREL_TYPES.includes(validType)) {
     const baseDir = config.aliases.base ?? "src/ai";
-    const barrelPath = join11(cwd, baseDir, "index.ts");
+    const barrelPath = join12(cwd, baseDir, "index.ts");
     let barrelContent;
     if (existsSync3(barrelPath)) {
-      barrelContent = await readFile8(barrelPath, "utf-8");
+      barrelContent = await readFile9(barrelPath, "utf-8");
     } else {
       barrelContent = createBarrelFile();
-      await mkdir5(join11(cwd, baseDir), { recursive: true });
+      await mkdir6(join12(cwd, baseDir), { recursive: true });
     }
-    const importPath = "./" + relative4(join11(cwd, baseDir), filePath).replace(/\.ts$/, ".js");
+    const importPath = "./" + relative4(join12(cwd, baseDir), filePath).replace(/\.ts$/, ".js");
     const updatedBarrel = addImportToBarrel(barrelContent, importPath);
     if (updatedBarrel !== barrelContent) {
-      await writeFile9(barrelPath, updatedBarrel);
+      await writeFile10(barrelPath, updatedBarrel);
       barrelUpdated = true;
     }
   }
@@ -2202,6 +2423,7 @@ var init_create = __esm({
   "src/commands/create.ts"() {
     "use strict";
     init_config();
+    init_naming();
     init_file_writer();
     init_barrel_manager();
     VALID_TYPES = ["agent", "tool", "skill", "storage", "cron"];
@@ -2216,36 +2438,661 @@ var init_create = __esm({
   }
 });
 
+// src/utils/component-resolver.ts
+import { readdir, readFile as readFile10 } from "fs/promises";
+import { join as join13, relative as relative5 } from "path";
+function stripSuffix(name, suffix) {
+  if (name.endsWith(`-${suffix}`)) {
+    return name.slice(0, -(suffix.length + 1));
+  }
+  return name;
+}
+function toolsDir(config, cwd) {
+  const baseAlias = config.aliases.base ?? "src/ai";
+  const tools = config.aliases.tools ?? join13(baseAlias, "tools");
+  return join13(cwd, tools);
+}
+function agentsDir(config, cwd) {
+  const baseAlias = config.aliases.base ?? "src/ai";
+  const agents = config.aliases.agents ?? join13(baseAlias, "agents");
+  return join13(cwd, agents);
+}
+async function findFile(dir, candidates) {
+  for (const name of candidates) {
+    const filePath = join13(dir, `${name}.ts`);
+    try {
+      await readFile10(filePath);
+      return filePath;
+    } catch {
+    }
+  }
+  return null;
+}
+function parseExportName(source) {
+  const match = source.match(/export\s+const\s+(\w+)/);
+  return match ? match[1] : null;
+}
+function parseAgentName(source) {
+  const match = source.match(/registerAgent\s*\(\s*\{[^}]*name:\s*"([^"]+)"/s);
+  return match ? match[1] : null;
+}
+function computeImportPath(fromDir, toFile) {
+  let rel = relative5(fromDir, toFile);
+  if (!rel.startsWith(".")) {
+    rel = `./${rel}`;
+  }
+  return rel.replace(/\.ts$/, ".js");
+}
+async function resolveToolByName(name, config, cwd) {
+  const tDir = toolsDir(config, cwd);
+  const aDir = agentsDir(config, cwd);
+  const lock = await readLock(cwd);
+  for (const [componentName, entry] of Object.entries(lock)) {
+    if (componentName === name || componentName === `${name}-tool`) {
+      const toolFile = entry.files.find((f) => {
+        const toolsAlias = config.aliases.tools ?? join13(config.aliases.base ?? "src/ai", "tools");
+        return f.startsWith(toolsAlias);
+      });
+      if (toolFile) {
+        const filePath2 = join13(cwd, toolFile);
+        try {
+          const source2 = await readFile10(filePath2, "utf-8");
+          const exportName2 = parseExportName(source2);
+          if (exportName2) {
+            return {
+              filePath: filePath2,
+              exportName: exportName2,
+              importPath: computeImportPath(aDir, filePath2)
+            };
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  const candidates = [name, stripSuffix(name, "tool")];
+  const uniqueCandidates = [...new Set(candidates)];
+  const filePath = await findFile(tDir, uniqueCandidates);
+  if (!filePath) return null;
+  const source = await readFile10(filePath, "utf-8");
+  const exportName = parseExportName(source);
+  if (!exportName) return null;
+  return {
+    filePath,
+    exportName,
+    importPath: computeImportPath(aDir, filePath)
+  };
+}
+async function resolveAgentByName(name, config, cwd) {
+  const aDir = agentsDir(config, cwd);
+  const lock = await readLock(cwd);
+  for (const [componentName, entry] of Object.entries(lock)) {
+    if (componentName === name || componentName === `${name}-agent`) {
+      const agentFile = entry.files.find((f) => {
+        const agentsAlias = config.aliases.agents ?? join13(config.aliases.base ?? "src/ai", "agents");
+        return f.startsWith(agentsAlias);
+      });
+      if (agentFile) {
+        const filePath2 = join13(cwd, agentFile);
+        try {
+          const source2 = await readFile10(filePath2, "utf-8");
+          const agentName2 = parseAgentName(source2);
+          return {
+            filePath: filePath2,
+            name: agentName2 ?? componentName
+          };
+        } catch {
+        }
+      }
+    }
+  }
+  const candidates = [name, stripSuffix(name, "agent")];
+  const uniqueCandidates = [...new Set(candidates)];
+  const filePath = await findFile(aDir, uniqueCandidates);
+  if (!filePath) return null;
+  const source = await readFile10(filePath, "utf-8");
+  const agentName = parseAgentName(source);
+  const fallbackName = filePath.split("/").pop().replace(/\.ts$/, "");
+  return {
+    filePath,
+    name: agentName ?? fallbackName
+  };
+}
+async function listTools(config, cwd) {
+  const dir = toolsDir(config, cwd);
+  return listComponentsInDir(dir);
+}
+async function listAgents(config, cwd) {
+  const dir = agentsDir(config, cwd);
+  return listComponentsInDir(dir);
+}
+async function listComponentsInDir(dir) {
+  try {
+    const entries = await readdir(dir);
+    return entries.filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts") && !f.endsWith(".d.ts")).sort().map((f) => ({
+      name: f.replace(/\.ts$/, ""),
+      filePath: join13(dir, f)
+    }));
+  } catch {
+    return [];
+  }
+}
+var init_component_resolver = __esm({
+  "src/utils/component-resolver.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/installers/agent-linker.ts
+function linkToolToAgent(content, tool, toolKey) {
+  const key = toolKey ?? tool.exportName;
+  const { exportName, importPath } = tool;
+  const toolEntry = key === exportName ? exportName : `${key}: ${exportName}`;
+  if (hasToolEntry(content, key)) {
+    return { content, changed: false };
+  }
+  const importLine = `import { ${exportName} } from "${importPath}";`;
+  let result = content;
+  if (!result.includes(importLine)) {
+    const lines = result.split("\n");
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (/^import\s+/.test(lines[i])) lastImportIndex = i;
+    }
+    if (lastImportIndex === -1) {
+      result = `${importLine}
+${result}`;
+    } else {
+      lines.splice(lastImportIndex + 1, 0, importLine);
+      result = lines.join("\n");
+    }
+  }
+  const insertResult = insertToolEntry(result, key, exportName);
+  if (insertResult.error) {
+    return {
+      content,
+      changed: false,
+      error: `Could not auto-modify the agent file. Add manually:
+  1. Import: ${importLine}
+  2. Add to tools: { ${toolEntry} }`
+    };
+  }
+  return { content: insertResult.content, changed: true };
+}
+function unlinkToolFromAgent(content, tool, toolKey) {
+  const key = toolKey ?? tool.exportName;
+  const { exportName, importPath } = tool;
+  if (!hasToolEntry(content, key)) {
+    return { content, changed: false };
+  }
+  const removeResult = removeToolEntry(content, key, exportName);
+  if (removeResult.error) {
+    return {
+      content,
+      changed: false,
+      error: `Could not auto-modify the agent file. Remove manually:
+  1. Remove from tools: ${key === exportName ? key : `${key}: ${exportName}`}
+  2. Remove import if unused: import { ${exportName} } from "${importPath}";`
+    };
+  }
+  let result = removeResult.content;
+  if (!isExportNameReferenced(result, exportName)) {
+    result = removeImportLine(result, exportName, importPath);
+  }
+  return { content: result, changed: true };
+}
+function hasToolEntry(content, key) {
+  const toolsMatch = extractToolsBlock(content);
+  if (!toolsMatch) return false;
+  const toolsContent = toolsMatch.inner;
+  const keyPattern = new RegExp(
+    `(?:^|[,{\\s])${escapeRegex(key)}(?:\\s*[:,}\\s]|$)`
+  );
+  return keyPattern.test(toolsContent);
+}
+function extractToolsBlock(content) {
+  const singleLine = /^([ \t]*)tools\s*:\s*\{([^}]*)\}/m;
+  const singleMatch = singleLine.exec(content);
+  if (singleMatch) {
+    return {
+      full: singleMatch[0],
+      inner: singleMatch[2],
+      startIndex: singleMatch.index,
+      indent: singleMatch[1]
+    };
+  }
+  const multiStart = /^([ \t]*)tools\s*:\s*\{/m;
+  const multiMatch = multiStart.exec(content);
+  if (!multiMatch) return null;
+  const braceStart = multiMatch.index + multiMatch[0].length;
+  let depth = 1;
+  let i = braceStart;
+  while (i < content.length && depth > 0) {
+    if (content[i] === "{") depth++;
+    else if (content[i] === "}") depth--;
+    i++;
+  }
+  if (depth !== 0) return null;
+  const full = content.slice(multiMatch.index, i);
+  const inner = content.slice(braceStart, i - 1);
+  return {
+    full,
+    inner,
+    startIndex: multiMatch.index,
+    indent: multiMatch[1]
+  };
+}
+function insertToolEntry(content, key, exportName) {
+  const block = extractToolsBlock(content);
+  if (!block) return { content, error: "no tools block found" };
+  const entry = key === exportName ? key : `${key}: ${exportName}`;
+  const trimmedInner = block.inner.trim();
+  let newToolsContent;
+  if (trimmedInner === "") {
+    newToolsContent = `tools: { ${entry} }`;
+  } else if (!block.inner.includes("\n")) {
+    const cleaned = trimmedInner.replace(/,?\s*$/, "");
+    newToolsContent = `tools: { ${cleaned}, ${entry} }`;
+  } else {
+    const entryIndent = block.indent + "  ";
+    const existingTrimmed = block.inner.trimEnd();
+    const withComma = existingTrimmed.endsWith(",") ? existingTrimmed : existingTrimmed + ",";
+    newToolsContent = `tools: {
+${withComma}
+${entryIndent}${entry},
+${block.indent}}`;
+  }
+  const newContent = content.replace(block.full, newToolsContent);
+  return { content: newContent };
+}
+function removeToolEntry(content, key, exportName) {
+  const block = extractToolsBlock(content);
+  if (!block) return { content, error: "no tools block found" };
+  const trimmedInner = block.inner.trim();
+  if (!block.inner.includes("\n")) {
+    const entries = trimmedInner.split(",").map((e) => e.trim()).filter((e) => e !== "");
+    const filtered = entries.filter((e) => {
+      const colonIdx = e.indexOf(":");
+      const entryKey = colonIdx >= 0 ? e.slice(0, colonIdx).trim() : e.trim();
+      return entryKey !== key;
+    });
+    const newInner = filtered.length === 0 ? "" : ` ${filtered.join(", ")} `;
+    const newBlock = `tools: {${newInner}}`;
+    return { content: content.replace(block.full, newBlock) };
+  } else {
+    const lines = block.inner.split("\n");
+    const keyPattern = new RegExp(
+      `^\\s*${escapeRegex(key)}\\s*(?::|,|$)`
+    );
+    const filtered = lines.filter((line) => !keyPattern.test(line));
+    const hasEntries = filtered.some((l) => l.trim() !== "");
+    if (!hasEntries) {
+      const newBlock2 = `tools: {}`;
+      return { content: content.replace(block.full, newBlock2) };
+    }
+    const cleanedLines = filtered.slice();
+    for (let i = cleanedLines.length - 1; i >= 0; i--) {
+      if (cleanedLines[i].trim() !== "") {
+        if (!cleanedLines[i].trimEnd().endsWith(",")) {
+          cleanedLines[i] = cleanedLines[i].trimEnd() + ",";
+        }
+        break;
+      }
+    }
+    const newBlock = `tools: {
+${cleanedLines.join("\n")}
+${block.indent}}`;
+    return { content: content.replace(block.full, newBlock) };
+  }
+}
+function isExportNameReferenced(content, exportName) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    if (/^import\s+/.test(line)) continue;
+    const wordPattern = new RegExp(`\\b${escapeRegex(exportName)}\\b`);
+    if (wordPattern.test(line)) return true;
+  }
+  return false;
+}
+function removeImportLine(content, exportName, importPath) {
+  const lines = content.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const singleImportMatch = line.match(
+      /^import\s*\{([^}]+)\}\s*from\s*["'](.+?)["']\s*;?\s*$/
+    );
+    if (singleImportMatch && singleImportMatch[2] === importPath) {
+      const imports = singleImportMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "");
+      if (imports.length === 1 && imports[0] === exportName) {
+        if (i + 1 < lines.length && lines[i + 1].trim() === "") {
+          i++;
+        }
+        continue;
+      }
+      const remaining = imports.filter((s) => s !== exportName);
+      result.push(
+        `import { ${remaining.join(", ")} } from "${importPath}";`
+      );
+      continue;
+    }
+    if (/^import\s*\{/.test(line) && !line.includes("}") && content.includes(importPath)) {
+      const importLines = [line];
+      let j = i + 1;
+      while (j < lines.length && !lines[j].includes("}")) {
+        importLines.push(lines[j]);
+        j++;
+      }
+      if (j < lines.length) {
+        importLines.push(lines[j]);
+      }
+      const fullImport = importLines.join("\n");
+      if (fullImport.includes(importPath)) {
+        const namesMatch = fullImport.match(/\{([^}]+)\}/);
+        if (namesMatch) {
+          const imports = namesMatch[1].split(",").map((s) => s.trim()).filter((s) => s !== "");
+          if (imports.length === 1 && imports[0] === exportName) {
+            i = j;
+            if (i + 1 < lines.length && lines[i + 1].trim() === "") {
+              i++;
+            }
+            continue;
+          }
+          const remaining = imports.filter((s) => s !== exportName);
+          if (remaining.length <= 2) {
+            result.push(
+              `import { ${remaining.join(", ")} } from "${importPath}";`
+            );
+          } else {
+            result.push(`import {`);
+            remaining.forEach((name, idx) => {
+              result.push(
+                `  ${name}${idx < remaining.length - 1 ? "," : ""}`
+              );
+            });
+            result.push(`} from "${importPath}";`);
+          }
+          i = j;
+          continue;
+        }
+      }
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var init_agent_linker = __esm({
+  "src/installers/agent-linker.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/link.ts
+var link_exports = {};
+__export(link_exports, {
+  linkCommand: () => linkCommand
+});
+import * as p9 from "@clack/prompts";
+import pc8 from "picocolors";
+import { readFile as readFile11, writeFile as writeFile11 } from "fs/promises";
+import { basename } from "path";
+async function linkCommand(type, name, opts) {
+  p9.intro(pc8.bgCyan(pc8.black(" kitn link ")));
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    p9.log.error("No kitn.json found. Run `kitn init` first.");
+    process.exit(1);
+  }
+  if (type && type !== "tool") {
+    p9.log.error(
+      `Unsupported type "${type}". Only ${pc8.bold("tool")} is supported.`
+    );
+    process.exit(1);
+  }
+  let toolName = name;
+  if (!toolName) {
+    const tools = await listTools(config, cwd);
+    if (tools.length === 0) {
+      p9.log.error("No tools found in your project.");
+      process.exit(1);
+    }
+    const selected = await p9.select({
+      message: "Select a tool to link:",
+      options: tools.map((t) => ({
+        value: t.name,
+        label: t.name
+      }))
+    });
+    if (p9.isCancel(selected)) {
+      p9.cancel("Cancelled.");
+      process.exit(0);
+    }
+    toolName = selected;
+  }
+  const tool = await resolveToolByName(toolName, config, cwd);
+  if (!tool) {
+    p9.log.error(
+      `Tool "${toolName}" not found. Check that the file exists in your tools directory.`
+    );
+    process.exit(1);
+  }
+  let agentName = opts?.to;
+  if (!agentName) {
+    const agents = await listAgents(config, cwd);
+    if (agents.length === 0) {
+      p9.log.error("No agents found in your project.");
+      process.exit(1);
+    }
+    const selected = await p9.select({
+      message: "Select an agent to link the tool to:",
+      options: agents.map((a) => ({
+        value: a.name,
+        label: a.name
+      }))
+    });
+    if (p9.isCancel(selected)) {
+      p9.cancel("Cancelled.");
+      process.exit(0);
+    }
+    agentName = selected;
+  }
+  const agent = await resolveAgentByName(agentName, config, cwd);
+  if (!agent) {
+    p9.log.error(
+      `Agent "${agentName}" not found. Check that the file exists in your agents directory.`
+    );
+    process.exit(1);
+  }
+  const agentContent = await readFile11(agent.filePath, "utf-8");
+  const toolRef = {
+    exportName: tool.exportName,
+    importPath: tool.importPath
+  };
+  const result = linkToolToAgent(agentContent, toolRef, opts?.as);
+  if (result.error) {
+    p9.log.warn(result.error);
+    p9.outro("Could not auto-link. Follow the manual instructions above.");
+    process.exit(1);
+  }
+  if (!result.changed) {
+    p9.log.info(
+      `${pc8.cyan(tool.exportName)} is already linked to ${pc8.cyan(basename(agent.filePath))}.`
+    );
+    p9.outro("Nothing to do.");
+    return;
+  }
+  await writeFile11(agent.filePath, result.content);
+  p9.log.success(
+    `Linked ${pc8.cyan(tool.exportName)} to ${pc8.cyan(basename(agent.filePath))}`
+  );
+  p9.log.message(
+    `  ${pc8.green("+")} import { ${tool.exportName} } from "${tool.importPath}"`
+  );
+  p9.log.message(
+    `  ${pc8.green("+")} tools: { ${opts?.as ? `${opts.as}: ${tool.exportName}` : tool.exportName} }`
+  );
+  p9.outro("Done!");
+}
+var init_link = __esm({
+  "src/commands/link.ts"() {
+    "use strict";
+    init_config();
+    init_component_resolver();
+    init_agent_linker();
+  }
+});
+
+// src/commands/unlink.ts
+var unlink_exports = {};
+__export(unlink_exports, {
+  unlinkCommand: () => unlinkCommand
+});
+import * as p10 from "@clack/prompts";
+import pc9 from "picocolors";
+import { readFile as readFile12, writeFile as writeFile12 } from "fs/promises";
+import { basename as basename2 } from "path";
+async function unlinkCommand(type, name, opts) {
+  p10.intro(pc9.bgCyan(pc9.black(" kitn unlink ")));
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    p10.log.error("No kitn.json found. Run `kitn init` first.");
+    process.exit(1);
+  }
+  if (type && type !== "tool") {
+    p10.log.error(
+      `Unsupported type "${type}". Only ${pc9.bold("tool")} is supported.`
+    );
+    process.exit(1);
+  }
+  let toolName = name;
+  if (!toolName) {
+    const tools = await listTools(config, cwd);
+    if (tools.length === 0) {
+      p10.log.error("No tools found in your project.");
+      process.exit(1);
+    }
+    const selected = await p10.select({
+      message: "Select a tool to unlink:",
+      options: tools.map((t) => ({
+        value: t.name,
+        label: t.name
+      }))
+    });
+    if (p10.isCancel(selected)) {
+      p10.cancel("Cancelled.");
+      process.exit(0);
+    }
+    toolName = selected;
+  }
+  const tool = await resolveToolByName(toolName, config, cwd);
+  if (!tool) {
+    p10.log.error(
+      `Tool "${toolName}" not found. Check that the file exists in your tools directory.`
+    );
+    process.exit(1);
+  }
+  let agentName = opts?.from;
+  if (!agentName) {
+    const agents = await listAgents(config, cwd);
+    if (agents.length === 0) {
+      p10.log.error("No agents found in your project.");
+      process.exit(1);
+    }
+    const selected = await p10.select({
+      message: "Select an agent to unlink the tool from:",
+      options: agents.map((a) => ({
+        value: a.name,
+        label: a.name
+      }))
+    });
+    if (p10.isCancel(selected)) {
+      p10.cancel("Cancelled.");
+      process.exit(0);
+    }
+    agentName = selected;
+  }
+  const agent = await resolveAgentByName(agentName, config, cwd);
+  if (!agent) {
+    p10.log.error(
+      `Agent "${agentName}" not found. Check that the file exists in your agents directory.`
+    );
+    process.exit(1);
+  }
+  const agentContent = await readFile12(agent.filePath, "utf-8");
+  const toolRef = {
+    exportName: tool.exportName,
+    importPath: tool.importPath
+  };
+  const result = unlinkToolFromAgent(agentContent, toolRef);
+  if (result.error) {
+    p10.log.warn(result.error);
+    p10.outro("Could not auto-unlink. Follow the manual instructions above.");
+    process.exit(1);
+  }
+  if (!result.changed) {
+    p10.log.info(
+      `${pc9.cyan(tool.exportName)} is not linked to ${pc9.cyan(basename2(agent.filePath))}.`
+    );
+    p10.outro("Nothing to do.");
+    return;
+  }
+  await writeFile12(agent.filePath, result.content);
+  p10.log.success(
+    `Unlinked ${pc9.cyan(tool.exportName)} from ${pc9.cyan(basename2(agent.filePath))}`
+  );
+  p10.log.message(
+    `  ${pc9.red("-")} import { ${tool.exportName} } from "${tool.importPath}"`
+  );
+  p10.log.message(
+    `  ${pc9.red("-")} tools: { ${tool.exportName} }`
+  );
+  p10.outro("Done!");
+}
+var init_unlink = __esm({
+  "src/commands/unlink.ts"() {
+    "use strict";
+    init_config();
+    init_component_resolver();
+    init_agent_linker();
+  }
+});
+
 // src/commands/info.ts
 var info_exports = {};
 __export(info_exports, {
   infoCommand: () => infoCommand
 });
-import * as p9 from "@clack/prompts";
-import pc8 from "picocolors";
+import * as p11 from "@clack/prompts";
+import pc10 from "picocolors";
 async function infoCommand(component) {
   const cwd = process.cwd();
   const config = await readConfig(cwd);
   if (!config) {
-    p9.log.error("No kitn.json found. Run `kitn init` first.");
+    p11.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 = p9.spinner();
+  const s = p11.spinner();
   s.start("Fetching component info...");
   let index;
   try {
     index = await fetcher.fetchIndex(ref.namespace);
   } catch (err) {
-    s.stop(pc8.red("Failed to fetch registry"));
-    p9.log.error(err.message);
+    s.stop(pc10.red("Failed to fetch registry"));
+    p11.log.error(err.message);
     process.exit(1);
   }
   const indexItem = index.items.find((i) => i.name === ref.name);
   if (!indexItem) {
-    s.stop(pc8.red("Component not found"));
-    p9.log.error(`Component '${ref.name}' not found in registry.`);
+    s.stop(pc10.red("Component not found"));
+    p11.log.error(`Component '${ref.name}' not found in registry.`);
     process.exit(1);
   }
   const dir = typeToDir[indexItem.type];
@@ -2253,8 +3100,8 @@ async function infoCommand(component) {
   try {
     item = await fetcher.fetchItem(ref.name, dir, ref.namespace, ref.version);
   } catch (err) {
-    s.stop(pc8.red("Failed to fetch component"));
-    p9.log.error(err.message);
+    s.stop(pc10.red("Failed to fetch component"));
+    p11.log.error(err.message);
     process.exit(1);
   }
   s.stop("Component found");
@@ -2262,63 +3109,63 @@ async function infoCommand(component) {
   const typeName = indexItem.type.replace("kitn:", "");
   console.log();
   console.log(
-    `  ${pc8.bold(item.name)} ${pc8.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc8.dim(ref.namespace)}`
+    `  ${pc10.bold(item.name)} ${pc10.cyan(`v${version}`)}${" ".repeat(Math.max(1, 40 - item.name.length - version.length - 2))}${pc10.dim(ref.namespace)}`
   );
-  console.log(`  ${pc8.dim(item.description)}`);
+  console.log(`  ${pc10.dim(item.description)}`);
   console.log();
-  console.log(`  ${pc8.dim("Type:")}           ${typeName}`);
+  console.log(`  ${pc10.dim("Type:")}           ${typeName}`);
   if (item.dependencies?.length) {
     console.log(
-      `  ${pc8.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
+      `  ${pc10.dim("Dependencies:")}   ${item.dependencies.join(", ")}`
     );
   }
   if (item.registryDependencies?.length) {
     console.log(
-      `  ${pc8.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
+      `  ${pc10.dim("Registry deps:")}  ${item.registryDependencies.join(", ")}`
     );
   }
   if (item.categories?.length) {
     console.log(
-      `  ${pc8.dim("Categories:")}     ${item.categories.join(", ")}`
+      `  ${pc10.dim("Categories:")}     ${item.categories.join(", ")}`
     );
   }
   if (item.updatedAt) {
-    console.log(`  ${pc8.dim("Updated:")}        ${item.updatedAt}`);
+    console.log(`  ${pc10.dim("Updated:")}        ${item.updatedAt}`);
   }
   const versions = indexItem.versions;
   if (versions?.length) {
-    console.log(`  ${pc8.dim("Versions:")}       ${versions.join(", ")}`);
+    console.log(`  ${pc10.dim("Versions:")}       ${versions.join(", ")}`);
   }
   if (item.changelog?.length) {
     console.log();
-    console.log(`  ${pc8.bold("Changelog:")}`);
+    console.log(`  ${pc10.bold("Changelog:")}`);
     for (const entry of item.changelog) {
-      const tag = entry.type === "feature" ? pc8.green(entry.type) : entry.type === "fix" ? pc8.yellow(entry.type) : entry.type === "breaking" ? pc8.red(entry.type) : pc8.dim(entry.type);
+      const tag = entry.type === "feature" ? pc10.green(entry.type) : entry.type === "fix" ? pc10.yellow(entry.type) : entry.type === "breaking" ? pc10.red(entry.type) : pc10.dim(entry.type);
       console.log(
-        `    ${pc8.cyan(entry.version)}  ${pc8.dim(entry.date)}  ${tag}  ${entry.note}`
+        `    ${pc10.cyan(entry.version)}  ${pc10.dim(entry.date)}  ${tag}  ${entry.note}`
       );
     }
   }
   console.log();
   const fileCount = item.files.length;
-  console.log(`  ${pc8.bold(`Files:`)} ${pc8.dim(`(${fileCount})`)}`);
+  console.log(`  ${pc10.bold(`Files:`)} ${pc10.dim(`(${fileCount})`)}`);
   const maxShown = 10;
   for (const file of item.files.slice(0, maxShown)) {
-    console.log(`    ${pc8.dim(file.path)}`);
+    console.log(`    ${pc10.dim(file.path)}`);
   }
   if (fileCount > maxShown) {
-    console.log(`    ${pc8.dim(`... and ${fileCount - maxShown} more`)}`);
+    console.log(`    ${pc10.dim(`... and ${fileCount - maxShown} more`)}`);
   }
   const lock = await readLock(cwd);
   const installed = lock[item.name];
   if (installed) {
     console.log();
     console.log(
-      `  ${pc8.green("Installed")} ${pc8.dim(`v${installed.version}`)}`
+      `  ${pc10.green("Installed")} ${pc10.dim(`v${installed.version}`)}`
     );
     if (version !== installed.version) {
       console.log(
-        `  ${pc8.yellow("Update available:")} ${pc8.dim(`v${installed.version}`)} \u2192 ${pc8.cyan(`v${version}`)}`
+        `  ${pc10.yellow("Update available:")} ${pc10.dim(`v${installed.version}`)} \u2192 ${pc10.cyan(`v${version}`)}`
       );
     }
   }
@@ -2340,41 +3187,41 @@ __export(check_exports, {
   checkCommand: () => checkCommand
 });
 import { execSync as execSync2 } from "child_process";
-import * as p10 from "@clack/prompts";
-import pc9 from "picocolors";
+import * as p12 from "@clack/prompts";
+import pc11 from "picocolors";
 async function checkCommand(currentVersion) {
-  p10.intro(pc9.bgCyan(pc9.black(" kitn check ")));
-  p10.log.info(`kitn v${currentVersion}`);
-  const s = p10.spinner();
+  p12.intro(pc11.bgCyan(pc11.black(" kitn check ")));
+  p12.log.info(`kitn v${currentVersion}`);
+  const s = p12.spinner();
   s.start("Checking for updates...");
   const latest = await fetchLatestVersion();
   if (!latest) {
-    s.stop(pc9.yellow("Could not reach the npm registry"));
-    p10.outro("Try again later.");
+    s.stop(pc11.yellow("Could not reach the npm registry"));
+    p12.outro("Try again later.");
     return;
   }
   if (isNewer(latest, currentVersion)) {
-    s.stop(pc9.yellow(`Update available: ${currentVersion} \u2192 ${latest}`));
+    s.stop(pc11.yellow(`Update available: ${currentVersion} \u2192 ${latest}`));
     const pm = detectCliInstaller();
     const installCmd = getGlobalInstallCommand(pm, "@kitnai/cli");
-    const shouldUpdate = await p10.confirm({ message: "Update now?" });
-    if (p10.isCancel(shouldUpdate) || !shouldUpdate) {
-      p10.log.message(`  Run: ${pc9.cyan(installCmd)}`);
+    const shouldUpdate = await p12.confirm({ message: "Update now?" });
+    if (p12.isCancel(shouldUpdate) || !shouldUpdate) {
+      p12.log.message(`  Run: ${pc11.cyan(installCmd)}`);
     } else {
-      const us = p10.spinner();
+      const us = p12.spinner();
       us.start("Updating...");
       try {
         execSync2(installCmd, { stdio: "pipe" });
-        us.stop(pc9.green(`Updated to v${latest}`));
+        us.stop(pc11.green(`Updated to v${latest}`));
       } catch {
-        us.stop(pc9.red("Update failed"));
-        p10.log.message(`  Run manually: ${pc9.cyan(installCmd)}`);
+        us.stop(pc11.red("Update failed"));
+        p12.log.message(`  Run manually: ${pc11.cyan(installCmd)}`);
       }
     }
   } else {
-    s.stop(pc9.green("You're on the latest version"));
+    s.stop(pc11.green("You're on the latest version"));
   }
-  p10.outro("");
+  p12.outro("");
 }
 var init_check = __esm({
   "src/commands/check.ts"() {
@@ -2384,6 +3231,64 @@ var init_check = __esm({
   }
 });
 
+// src/commands/rules.ts
+var rules_exports = {};
+__export(rules_exports, {
+  rulesCommand: () => rulesCommand
+});
+import * as p13 from "@clack/prompts";
+import pc12 from "picocolors";
+async function rulesCommand() {
+  p13.intro(pc12.bgCyan(pc12.black(" kitn rules ")));
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    p13.log.error(`No kitn.json found. Run ${pc12.bold("kitn init")} first.`);
+    process.exit(1);
+  }
+  let selectedIds = config.aiTools;
+  if (!selectedIds || selectedIds.length === 0) {
+    const rulesConfig = await fetchRulesConfig(config.registries);
+    const selected = await p13.multiselect({
+      message: "Which AI coding tools do you use?",
+      options: rulesConfig.tools.map((t) => ({
+        value: t.id,
+        label: t.name,
+        hint: t.description
+      })),
+      required: false
+    });
+    if (p13.isCancel(selected)) {
+      p13.cancel("Cancelled.");
+      process.exit(0);
+    }
+    selectedIds = selected;
+    if (selectedIds.length === 0) {
+      p13.log.warn("No tools selected. Nothing to generate.");
+      p13.outro("Done.");
+      return;
+    }
+    const updatedConfig = { ...config, aiTools: selectedIds };
+    await writeConfig(cwd, updatedConfig);
+    p13.log.info(`Saved tool selections to ${pc12.bold("kitn.json")}`);
+  }
+  const s = p13.spinner();
+  s.start("Generating rules files");
+  const written = await generateRulesFiles(cwd, config, selectedIds);
+  s.stop("Rules files generated");
+  for (const filePath of written) {
+    p13.log.success(`${pc12.green("+")} ${filePath}`);
+  }
+  p13.outro(`Generated ${written.length} rules file${written.length === 1 ? "" : "s"}.`);
+}
+var init_rules = __esm({
+  "src/commands/rules.ts"() {
+    "use strict";
+    init_config();
+    init_rules_generator();
+  }
+});
+
 // src/commands/registry.ts
 var registry_exports = {};
 __export(registry_exports, {
@@ -2391,8 +3296,8 @@ __export(registry_exports, {
   registryListCommand: () => registryListCommand,
   registryRemoveCommand: () => registryRemoveCommand
 });
-import * as p11 from "@clack/prompts";
-import pc10 from "picocolors";
+import * as p14 from "@clack/prompts";
+import pc13 from "picocolors";
 async function registryAddCommand(namespace, url, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const config = await readConfig(cwd);
@@ -2418,10 +3323,10 @@ async function registryAddCommand(namespace, url, opts = {}) {
     config.registries[namespace] = url;
   }
   await writeConfig(cwd, config);
-  p11.log.success(`Added registry ${pc10.bold(namespace)}`);
-  p11.log.message(pc10.dim(`  ${url}`));
-  if (opts.homepage) p11.log.message(pc10.dim(`  Homepage: ${opts.homepage}`));
-  if (opts.description) p11.log.message(pc10.dim(`  ${opts.description}`));
+  p14.log.success(`Added registry ${pc13.bold(namespace)}`);
+  p14.log.message(pc13.dim(`  ${url}`));
+  if (opts.homepage) p14.log.message(pc13.dim(`  Homepage: ${opts.homepage}`));
+  if (opts.description) p14.log.message(pc13.dim(`  ${opts.description}`));
 }
 async function registryRemoveCommand(namespace, opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
@@ -2442,10 +3347,10 @@ async function registryRemoveCommand(namespace, opts = {}) {
   }
   delete config.registries[namespace];
   await writeConfig(cwd, config);
-  p11.log.success(`Removed registry ${pc10.bold(namespace)}`);
+  p14.log.success(`Removed registry ${pc13.bold(namespace)}`);
   if (affectedComponents.length > 0) {
-    p11.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
-` + affectedComponents.map((name) => `  ${pc10.yellow("!")} ${name}`).join("\n"));
+    p14.log.warn(`${affectedComponents.length} installed component(s) referenced this registry:
+` + affectedComponents.map((name) => `  ${pc13.yellow("!")} ${name}`).join("\n"));
   }
   return { affectedComponents };
 }
@@ -2460,15 +3365,15 @@ async function registryListCommand(opts = {}) {
     return { namespace, url, homepage, description };
   });
   if (entries.length === 0) {
-    p11.log.message(pc10.dim("  No registries configured."));
+    p14.log.message(pc13.dim("  No registries configured."));
   } else {
     const lines = [];
     for (const { namespace, url, homepage, description } of entries) {
-      lines.push(`  ${pc10.bold(namespace.padEnd(16))} ${pc10.dim(url)}`);
+      lines.push(`  ${pc13.bold(namespace.padEnd(16))} ${pc13.dim(url)}`);
       if (description) lines.push(`  ${" ".repeat(16)} ${description}`);
-      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc10.dim(homepage)}`);
+      if (homepage) lines.push(`  ${" ".repeat(16)} ${pc13.dim(homepage)}`);
     }
-    p11.log.message(lines.join("\n"));
+    p14.log.message(lines.join("\n"));
   }
   return entries;
 }
@@ -2482,7 +3387,7 @@ var init_registry = __esm({
 // src/index.ts
 init_update_check();
 import { Command } from "commander";
-var VERSION = true ? "0.1.30" : "0.0.0-dev";
+var VERSION = true ? "0.1.32" : "0.0.0-dev";
 var printUpdateNotice = startUpdateCheck(VERSION);
 var program = new Command().name("kitn").description("Install AI agent components from the kitn registry").version(VERSION);
 program.command("init").description("Initialize kitn in your project").option("-r, --runtime <runtime>", "runtime to use (bun, node, deno)").option("-f, --framework <framework>", "HTTP framework (hono, hono-openapi, elysia)").option("-b, --base <path>", "base directory for components (default: src/ai)").option("-y, --yes", "accept all defaults without prompting").action(async (opts) => {
@@ -2513,6 +3418,14 @@ program.command("create").description("Scaffold a new kitn component").argument(
   const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
   await createCommand2(type, name);
 });
+program.command("link").description("Wire a tool to an agent").argument("[type]", "component type (tool)").argument("[name]", "component name").option("--to <agent>", "target agent name").option("--as <key>", "key name in the tools object").action(async (type, name, opts) => {
+  const { linkCommand: linkCommand2 } = await Promise.resolve().then(() => (init_link(), link_exports));
+  await linkCommand2(type, name, opts);
+});
+program.command("unlink").description("Unwire a tool from an agent").argument("[type]", "component type (tool)").argument("[name]", "component name").option("--from <agent>", "target agent name").action(async (type, name, opts) => {
+  const { unlinkCommand: unlinkCommand2 } = await Promise.resolve().then(() => (init_unlink(), unlink_exports));
+  await unlinkCommand2(type, name, opts);
+});
 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);
@@ -2521,6 +3434,10 @@ program.command("check").description("Check for CLI updates").action(async () =>
   const { checkCommand: checkCommand2 } = await Promise.resolve().then(() => (init_check(), check_exports));
   await checkCommand2(VERSION);
 });
+program.command("rules").description("Regenerate AI coding tool rules files").action(async () => {
+  const { rulesCommand: rulesCommand2 } = await Promise.resolve().then(() => (init_rules(), rules_exports));
+  await rulesCommand2();
+});
 var registry = program.command("registry").description("Manage component registries");
 registry.command("add").description("Add a component registry").argument("<namespace>", "registry namespace (e.g. @myteam)").argument("<url>", "URL template with {type} and {name} placeholders").option("-o, --overwrite", "overwrite if namespace already exists").option("--homepage <url>", "registry homepage URL").option("--description <text>", "short description of the registry").action(async (namespace, url, opts) => {
   const { registryAddCommand: registryAddCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));