@smicolon/ai-kit 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,901 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import path5 from "path";
+
+// src/tools.ts
+var TOOL_REGISTRY = {
+  "claude-code": {
+    label: "Claude Code",
+    hint: "agents, skills, commands, rules, hooks",
+    skillsDir: ".claude/skills",
+    components: {
+      agents: ".claude/agents",
+      skills: ".claude/skills",
+      commands: ".claude/commands",
+      rules: ".claude/rules",
+      hooks: ".claude/hooks"
+    }
+  },
+  cursor: {
+    label: "Cursor",
+    hint: "skills, rules",
+    skillsDir: ".cursor/skills",
+    components: {
+      skills: ".cursor/skills",
+      rules: ".cursor/rules"
+    }
+  },
+  windsurf: {
+    label: "Windsurf",
+    hint: "skills, rules",
+    skillsDir: ".windsurf/skills",
+    components: {
+      skills: ".windsurf/skills",
+      rules: ".windsurf/rules"
+    }
+  },
+  copilot: {
+    label: "GitHub Copilot",
+    hint: "agents, skills",
+    skillsDir: ".github/skills",
+    components: {
+      agents: ".github/agents",
+      skills: ".github/skills"
+    }
+  },
+  codex: {
+    label: "OpenAI Codex",
+    hint: "agents, skills",
+    skillsDir: ".codex/skills",
+    components: {
+      agents: ".codex/agents",
+      skills: ".codex/skills"
+    }
+  },
+  cline: {
+    label: "Cline",
+    hint: "skills, rules",
+    skillsDir: ".cline/skills",
+    components: {
+      skills: ".cline/skills",
+      rules: ".cline/rules"
+    }
+  },
+  continue: {
+    label: "Continue",
+    hint: "skills, rules",
+    skillsDir: ".continue/skills",
+    components: {
+      skills: ".continue/skills",
+      rules: ".continue/rules"
+    }
+  },
+  gemini: {
+    label: "Gemini Code Assist",
+    hint: "agents, skills",
+    skillsDir: ".gemini/skills",
+    components: {
+      agents: ".gemini/agents",
+      skills: ".gemini/skills"
+    }
+  },
+  junie: {
+    label: "Junie",
+    hint: "skills, rules",
+    skillsDir: ".junie/skills",
+    components: {
+      skills: ".junie/skills",
+      rules: ".junie/rules"
+    }
+  },
+  kiro: {
+    label: "Kiro",
+    hint: "skills, rules",
+    skillsDir: ".kiro/skills",
+    components: {
+      skills: ".kiro/skills",
+      rules: ".kiro/rules"
+    }
+  },
+  amp: {
+    label: "Amp",
+    hint: "agents, skills",
+    skillsDir: ".amp/skills",
+    components: {
+      agents: ".amp/agents",
+      skills: ".amp/skills"
+    }
+  },
+  antigravity: {
+    label: "Antigravity",
+    hint: "skills, rules",
+    skillsDir: ".antigravity/skills",
+    components: {
+      skills: ".antigravity/skills",
+      rules: ".antigravity/rules"
+    }
+  },
+  augment: {
+    label: "Augment",
+    hint: "skills, rules",
+    skillsDir: ".augment/skills",
+    components: {
+      skills: ".augment/skills",
+      rules: ".augment/rules"
+    }
+  },
+  "roo-code": {
+    label: "Roo Code",
+    hint: "skills, rules",
+    skillsDir: ".roo-code/skills",
+    components: {
+      skills: ".roo-code/skills",
+      rules: ".roo-code/rules"
+    }
+  },
+  "amazon-q": {
+    label: "Amazon Q",
+    hint: "skills, rules",
+    skillsDir: ".amazon-q/skills",
+    components: {
+      skills: ".amazon-q/skills",
+      rules: ".amazon-q/rules"
+    }
+  }
+};
+var TOOL_IDS = Object.keys(TOOL_REGISTRY);
+var CANONICAL_SKILLS_DIR = ".agents/skills";
+
+// src/discovery.ts
+import fs from "fs";
+import path from "path";
+function findMarketplaceJson(startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = path.join(dir, ".claude-plugin", "marketplace.json");
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function resolvePack(plugin, marketplaceDir) {
+  const sourceDir = path.resolve(marketplaceDir, plugin.source);
+  const resolveFiles = (files) => (files ?? []).map((f) => path.resolve(sourceDir, f));
+  let rules = [];
+  const rulesDir = path.join(sourceDir, "rules");
+  if (fs.existsSync(rulesDir)) {
+    rules = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md")).map((f) => path.join(rulesDir, f));
+  }
+  const skills = (plugin.skills ?? []).map((s) => {
+    const skillMdPath = path.resolve(sourceDir, s);
+    return path.dirname(skillMdPath);
+  });
+  return {
+    name: plugin.name,
+    version: plugin.version,
+    description: plugin.description,
+    sourceDir,
+    agents: resolveFiles(plugin.agents),
+    commands: resolveFiles(plugin.commands),
+    skills,
+    rules,
+    hooks: resolveFiles(plugin.hooks),
+    mcpServers: plugin.mcpServers ? path.resolve(sourceDir, plugin.mcpServers) : void 0
+  };
+}
+function discoverPacks(startDir) {
+  const start = startDir ?? path.dirname(new URL(import.meta.url).pathname);
+  const marketplacePath = findMarketplaceJson(start);
+  if (!marketplacePath) {
+    throw new Error(
+      "Could not find .claude-plugin/marketplace.json. Make sure ai-kit is installed correctly."
+    );
+  }
+  const marketplaceDir = path.dirname(path.dirname(marketplacePath));
+  const raw = JSON.parse(fs.readFileSync(marketplacePath, "utf-8"));
+  return raw.plugins.map((p2) => resolvePack(p2, marketplaceDir)).filter((p2) => fs.existsSync(p2.sourceDir));
+}
+function findPack(name, startDir) {
+  return discoverPacks(startDir).find((p2) => p2.name === name);
+}
+
+// src/config.ts
+import fs2 from "fs";
+import path2 from "path";
+var CONFIG_FILE = ".ai-kit.json";
+function configPath(projectDir) {
+  return path2.join(projectDir, CONFIG_FILE);
+}
+function readConfig(projectDir) {
+  const fp = configPath(projectDir);
+  if (!fs2.existsSync(fp)) return null;
+  return JSON.parse(fs2.readFileSync(fp, "utf-8"));
+}
+function writeConfig(projectDir, config) {
+  fs2.writeFileSync(configPath(projectDir), JSON.stringify(config, null, 2) + "\n");
+}
+function mergeInstall(config, result) {
+  const components = {};
+  for (const [type, count] of Object.entries(result.installed)) {
+    if (count > 0) {
+      components[type] = [`${count} files`];
+    }
+  }
+  return {
+    ...config,
+    packs: {
+      ...config.packs,
+      [result.pack]: {
+        version: config.packs[result.pack]?.version ?? "0.0.0",
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        components,
+        files: result.files
+      }
+    }
+  };
+}
+function removePack(config, packName) {
+  const { [packName]: _, ...rest } = config.packs;
+  return { ...config, packs: rest };
+}
+function createDefaultConfig(tools) {
+  return {
+    version: "1",
+    tools,
+    packs: {}
+  };
+}
+
+// src/gitignore.ts
+import fs3 from "fs";
+import path3 from "path";
+var MANAGED_COMMENT = "# AI coding tools (managed by @smicolon/ai-kit)";
+function findGitRoot(startDir) {
+  let dir = startDir;
+  while (true) {
+    if (fs3.existsSync(path3.join(dir, ".git"))) return dir;
+    const parent = path3.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function appendToGitignore(gitignorePath, entries) {
+  const existing = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf-8") : "";
+  const lines = existing.split("\n");
+  const newEntries = entries.filter(
+    (entry) => !lines.some(
+      (line) => line.trim() === entry.replace(/\/$/, "") || line.trim() === entry
+    )
+  );
+  if (newEntries.length === 0) return;
+  const hasBlock = lines.includes(MANAGED_COMMENT);
+  let updated;
+  if (hasBlock) {
+    const blockIdx = lines.indexOf(MANAGED_COMMENT);
+    let endIdx = blockIdx + 1;
+    while (endIdx < lines.length && lines[endIdx].trim() !== "" && !lines[endIdx].startsWith("#")) {
+      endIdx++;
+    }
+    lines.splice(endIdx, 0, ...newEntries);
+    updated = lines.join("\n");
+  } else {
+    const block = `
+${MANAGED_COMMENT}
+${newEntries.join("\n")}
+`;
+    updated = existing.endsWith("\n") ? existing + block : existing + "\n" + block;
+  }
+  fs3.writeFileSync(gitignorePath, updated);
+}
+function updateGitignore(projectDir, dirs) {
+  if (dirs.length === 0) return;
+  const entries = dirs.map((d) => d.endsWith("/") ? d : `${d}/`);
+  const projectGitignore = path3.join(projectDir, ".gitignore");
+  appendToGitignore(projectGitignore, entries);
+  const gitRoot = findGitRoot(projectDir);
+  if (gitRoot && path3.resolve(gitRoot) !== path3.resolve(projectDir)) {
+    const relFromRoot = path3.relative(gitRoot, projectDir);
+    const rootEntries = entries.map((e) => `${relFromRoot}/${e}`);
+    appendToGitignore(path3.join(gitRoot, ".gitignore"), rootEntries);
+  }
+}
+
+// src/installer.ts
+import fs5 from "fs";
+import path4 from "path";
+
+// src/converters/cursor-mdc.ts
+import fs4 from "fs";
+function convertToMdc(mdFilePath, packName) {
+  const content = fs4.readFileSync(mdFilePath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  const paths = frontmatter.paths;
+  const globs = paths && paths.length > 0 ? paths.length === 1 ? paths[0] : paths.join(", ") : "";
+  const headingMatch = body.match(/^#\s+(.+)$/m);
+  const description = headingMatch ? headingMatch[1].trim() : `${packName} rule`;
+  const mdcFrontmatter = [
+    "---",
+    `description: ${description}`,
+    ...globs ? [`globs: ${globs}`] : [],
+    "---"
+  ].join("\n");
+  return `${mdcFrontmatter}
+${body}`;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const yamlStr = match[1];
+  const body = match[2];
+  const frontmatter = {};
+  let currentKey = "";
+  const currentArray = [];
+  for (const line of yamlStr.split("\n")) {
+    const keyMatch = line.match(/^(\w+):(.*)$/);
+    if (keyMatch) {
+      if (currentKey && currentArray.length > 0) {
+        frontmatter[currentKey] = [...currentArray];
+        currentArray.length = 0;
+      }
+      currentKey = keyMatch[1];
+      const value = keyMatch[2].trim();
+      if (value) {
+        frontmatter[currentKey] = value;
+        currentKey = "";
+      }
+    } else {
+      const itemMatch = line.match(/^\s+-\s+"?(.+?)"?\s*$/);
+      if (itemMatch) {
+        currentArray.push(itemMatch[1]);
+      }
+    }
+  }
+  if (currentKey && currentArray.length > 0) {
+    frontmatter[currentKey] = [...currentArray];
+  }
+  return { frontmatter, body };
+}
+
+// src/installer.ts
+var trackedFiles = [];
+var currentProjectDir = "";
+function trackFile(absPath) {
+  trackedFiles.push(path4.relative(currentProjectDir, absPath));
+}
+function ensureDir(dir) {
+  fs5.mkdirSync(dir, { recursive: true });
+}
+function copyFile(src, dest) {
+  ensureDir(path4.dirname(dest));
+  fs5.copyFileSync(src, dest);
+  trackFile(dest);
+}
+function copyDir(src, dest) {
+  ensureDir(dest);
+  for (const entry of fs5.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path4.join(src, entry.name);
+    const destPath = path4.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs5.copyFileSync(srcPath, destPath);
+      trackFile(destPath);
+    }
+  }
+}
+function createSymlink(target, linkPath) {
+  ensureDir(path4.dirname(linkPath));
+  if (fs5.existsSync(linkPath)) {
+    const stat = fs5.lstatSync(linkPath);
+    if (stat.isSymbolicLink()) fs5.unlinkSync(linkPath);
+    else return;
+  }
+  const type = process.platform === "win32" ? "junction" : void 0;
+  fs5.symlinkSync(target, linkPath, type);
+  trackFile(linkPath);
+}
+function installSkills(skillDirs, tools, projectDir) {
+  if (skillDirs.length === 0 || tools.length === 0) return 0;
+  const skillTools = tools.filter((t) => TOOL_REGISTRY[t].components.skills);
+  if (skillTools.length === 0) return 0;
+  const canonicalBase = path4.join(projectDir, CANONICAL_SKILLS_DIR);
+  let count = 0;
+  for (const skillDir of skillDirs) {
+    const skillName = path4.basename(skillDir);
+    const canonicalDest = path4.join(canonicalBase, skillName);
+    if (!fs5.existsSync(canonicalDest)) {
+      copyDir(skillDir, canonicalDest);
+      count++;
+    }
+  }
+  for (const toolId of skillTools) {
+    const toolSkillsDir = path4.join(projectDir, TOOL_REGISTRY[toolId].skillsDir);
+    if (path4.resolve(toolSkillsDir) === path4.resolve(canonicalBase)) continue;
+    ensureDir(toolSkillsDir);
+    for (const skillDir of skillDirs) {
+      const skillName = path4.basename(skillDir);
+      const canonicalDest = path4.join(canonicalBase, skillName);
+      const linkPath = path4.join(toolSkillsDir, skillName);
+      const relTarget = path4.relative(path4.dirname(linkPath), canonicalDest);
+      createSymlink(relTarget, linkPath);
+    }
+  }
+  return count;
+}
+function installMdFiles(files, componentType, tools, projectDir, packName) {
+  if (files.length === 0) return 0;
+  for (const toolId of tools) {
+    const targetDir = TOOL_REGISTRY[toolId].components[componentType];
+    if (!targetDir) continue;
+    const dest = path4.join(projectDir, targetDir);
+    ensureDir(dest);
+    for (const file of files) {
+      if (componentType === "rules" && toolId === "cursor") {
+        const mdcContent = convertToMdc(file, packName ?? "unknown");
+        const mdcName = path4.basename(file, ".md") + ".mdc";
+        const destPath = path4.join(dest, mdcName);
+        ensureDir(path4.dirname(destPath));
+        fs5.writeFileSync(destPath, mdcContent);
+        trackFile(destPath);
+      } else {
+        copyFile(file, path4.join(dest, path4.basename(file)));
+      }
+    }
+  }
+  return files.length;
+}
+function installHooks(hookFiles, tools, projectDir) {
+  if (hookFiles.length === 0) return 0;
+  if (!tools.includes("claude-code")) return 0;
+  let count = 0;
+  const targetHooksDir = path4.join(projectDir, ".claude", "hooks");
+  for (const hookFile of hookFiles) {
+    if (!fs5.existsSync(hookFile)) continue;
+    const raw = JSON.parse(fs5.readFileSync(hookFile, "utf-8"));
+    if (!raw.hooks || Object.keys(raw.hooks).length === 0) continue;
+    const hookSourceDir = path4.dirname(hookFile);
+    const scriptFiles = findScriptFiles(hookSourceDir);
+    for (const script of scriptFiles) {
+      const relPath = path4.relative(hookSourceDir, script);
+      const destPath = path4.join(targetHooksDir, relPath);
+      copyFile(script, destPath);
+      fs5.chmodSync(destPath, 493);
+    }
+    const rewritten = JSON.stringify(raw.hooks).replace(/\$\{CLAUDE_PLUGIN_ROOT\}\/hooks/g, ".claude/hooks");
+    const projectHooksPath = path4.join(projectDir, ".claude", "hooks.json");
+    let existing = {};
+    if (fs5.existsSync(projectHooksPath)) {
+      const parsed = JSON.parse(fs5.readFileSync(projectHooksPath, "utf-8"));
+      existing = parsed.hooks ?? parsed;
+    }
+    const newHooks = JSON.parse(rewritten);
+    for (const [event, handlers] of Object.entries(newHooks)) {
+      if (!existing[event]) existing[event] = [];
+      existing[event].push(...handlers);
+    }
+    ensureDir(path4.dirname(projectHooksPath));
+    fs5.writeFileSync(
+      projectHooksPath,
+      JSON.stringify({ hooks: existing }, null, 2) + "\n"
+    );
+    trackFile(projectHooksPath);
+    count++;
+  }
+  return count;
+}
+function findScriptFiles(dir) {
+  const scripts = [];
+  if (!fs5.existsSync(dir)) return scripts;
+  for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      scripts.push(...findScriptFiles(fullPath));
+    } else if (/\.(sh|js|ts)$/.test(entry.name)) {
+      scripts.push(fullPath);
+    }
+  }
+  return scripts;
+}
+function installPack(options) {
+  const { pack, tools, filter, projectDir } = options;
+  trackedFiles = [];
+  currentProjectDir = projectDir;
+  const installed = {
+    agents: 0,
+    skills: 0,
+    commands: 0,
+    rules: 0,
+    hooks: 0
+  };
+  const should = (type) => !filter || filter.includes(type);
+  if (should("agents")) {
+    installed.agents = installMdFiles(pack.agents, "agents", tools, projectDir);
+  }
+  if (should("commands")) {
+    installed.commands = installMdFiles(pack.commands, "commands", tools, projectDir);
+  }
+  if (should("rules")) {
+    installed.rules = installMdFiles(pack.rules, "rules", tools, projectDir, pack.name);
+  }
+  if (should("skills")) {
+    installed.skills = installSkills(pack.skills, tools, projectDir);
+  }
+  if (should("hooks")) {
+    installed.hooks = installHooks(pack.hooks, tools, projectDir);
+  }
+  return { pack: pack.name, tools, installed, files: [...trackedFiles] };
+}
+function removePack2(projectDir, files) {
+  let removed = 0;
+  for (const relFile of files) {
+    const absPath = path4.join(projectDir, relFile);
+    if (!fs5.existsSync(absPath) && !isSymlink(absPath)) continue;
+    if (isSymlink(absPath)) {
+      fs5.unlinkSync(absPath);
+    } else if (fs5.statSync(absPath).isDirectory()) {
+      fs5.rmSync(absPath, { recursive: true });
+    } else {
+      fs5.unlinkSync(absPath);
+    }
+    removed++;
+    let parent = path4.dirname(absPath);
+    while (parent !== projectDir && parent.length > projectDir.length) {
+      try {
+        const entries = fs5.readdirSync(parent);
+        if (entries.length === 0) {
+          fs5.rmdirSync(parent);
+        } else {
+          break;
+        }
+      } catch {
+        break;
+      }
+      parent = path4.dirname(parent);
+    }
+  }
+  return removed;
+}
+function isSymlink(p2) {
+  try {
+    return fs5.lstatSync(p2).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function getWrittenDirs(tools, hadSkills) {
+  const dirs = /* @__PURE__ */ new Set();
+  if (hadSkills) {
+    dirs.add(CANONICAL_SKILLS_DIR);
+  }
+  for (const toolId of tools) {
+    const config = TOOL_REGISTRY[toolId];
+    for (const dir of Object.values(config.components)) {
+      const topLevel = dir.split("/")[0];
+      dirs.add(topLevel);
+    }
+  }
+  return [...dirs];
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Interactive first-time setup").option("--cwd <dir>", "Project directory (for monorepo sub-packages)").action(async (opts) => {
+  p.intro(pc.bgCyan(pc.black(" ai-kit ")));
+  const projectDir = opts.cwd ? path5.resolve(opts.cwd) : process.cwd();
+  const existing = readConfig(projectDir);
+  if (existing) {
+    const action = await p.select({
+      message: "ai-kit is already configured. What would you like to do?",
+      options: [
+        { value: "reconfigure", label: "Reconfigure from scratch" },
+        { value: "add", label: "Add more packs" },
+        { value: "cancel", label: "Cancel" }
+      ]
+    });
+    if (p.isCancel(action) || action === "cancel") {
+      p.outro("Cancelled.");
+      return;
+    }
+    if (action === "add") {
+      p.outro(`Run ${pc.cyan("ai-kit add <pack>")} to add packs.`);
+      return;
+    }
+  }
+  const toolSelection = await p.multiselect({
+    message: "Which AI coding tools do you use?",
+    options: TOOL_IDS.map((id) => ({
+      value: id,
+      label: TOOL_REGISTRY[id].label,
+      hint: TOOL_REGISTRY[id].hint
+    })),
+    required: true
+  });
+  if (p.isCancel(toolSelection)) {
+    p.outro("Cancelled.");
+    return;
+  }
+  const selectedTools = toolSelection;
+  let packs;
+  try {
+    packs = discoverPacks();
+  } catch {
+    p.log.error("Could not find marketplace.json. Is ai-kit installed correctly?");
+    p.outro("Setup failed.");
+    return;
+  }
+  const packSelection = await p.multiselect({
+    message: "What's your stack?",
+    options: packs.map((pack) => ({
+      value: pack.name,
+      label: pack.name,
+      hint: pack.description
+    })),
+    required: true
+  });
+  if (p.isCancel(packSelection)) {
+    p.outro("Cancelled.");
+    return;
+  }
+  const selectedPackNames = packSelection;
+  const componentChoice = await p.select({
+    message: "What components should be installed?",
+    options: [
+      { value: "all", label: "Everything", hint: "agents, skills, commands, rules, hooks" },
+      { value: "skills", label: "Skills only", hint: "auto-enforcing convention skills" },
+      { value: "pick", label: "Let me pick" }
+    ]
+  });
+  if (p.isCancel(componentChoice)) {
+    p.outro("Cancelled.");
+    return;
+  }
+  let filter;
+  if (componentChoice === "skills") {
+    filter = ["skills"];
+  } else if (componentChoice === "pick") {
+    const components = await p.multiselect({
+      message: "Select component types:",
+      options: [
+        { value: "agents", label: "Agents", hint: "specialized AI agents" },
+        { value: "skills", label: "Skills", hint: "auto-enforcing conventions" },
+        { value: "commands", label: "Commands", hint: "slash commands" },
+        { value: "rules", label: "Rules", hint: "path-specific rules" },
+        { value: "hooks", label: "Hooks", hint: "lifecycle hooks (Claude Code only)" }
+      ],
+      required: true
+    });
+    if (p.isCancel(components)) {
+      p.outro("Cancelled.");
+      return;
+    }
+    filter = components;
+  }
+  const s = p.spinner();
+  s.start("Installing packs...");
+  let config = createDefaultConfig(selectedTools);
+  const selectedPacks = packs.filter((p2) => selectedPackNames.includes(p2.name));
+  let hadSkills = false;
+  for (const pack of selectedPacks) {
+    const result = installPack({
+      pack,
+      tools: selectedTools,
+      filter,
+      projectDir
+    });
+    config = mergeInstall(config, result);
+    if (result.installed.skills > 0) hadSkills = true;
+  }
+  writeConfig(projectDir, config);
+  updateGitignore(projectDir, getWrittenDirs(selectedTools, hadSkills));
+  s.stop("Done!");
+  p.log.success(`Installed ${selectedPacks.length} pack(s) for ${selectedTools.length} tool(s):`);
+  for (const pack of selectedPacks) {
+    p.log.message(`  ${pc.green("+")} ${pack.name} ${pc.dim(`v${pack.version}`)}`);
+  }
+  p.outro(pc.dim("Config saved to .ai-kit.json"));
+});
+
+// src/commands/add.ts
+import { Command as Command2 } from "commander";
+import path6 from "path";
+import pc2 from "picocolors";
+var addCommand = new Command2("add").description("Add a pack to your project").argument("<pack>", "Pack name (e.g., django, nextjs)").option("--skills-only", "Only install skills").option("--agents-only", "Only install agents").option("--rules-only", "Only install rules").option("--commands-only", "Only install commands").option("--hooks-only", "Only install hooks").option("--tools <tools>", "Comma-separated tool IDs (overrides config)").option("--cwd <dir>", "Project directory (for monorepo sub-packages)").action(async (packName, opts) => {
+  const projectDir = opts.cwd ? path6.resolve(opts.cwd) : process.cwd();
+  const config = readConfig(projectDir);
+  if (!config) {
+    console.error(
+      pc2.red("No .ai-kit.json found. Run ") + pc2.cyan("ai-kit init") + pc2.red(" first.")
+    );
+    process.exit(1);
+  }
+  const pack = findPack(packName);
+  if (!pack) {
+    const available = discoverPacks().map((p2) => p2.name);
+    console.error(
+      pc2.red(`Pack "${packName}" not found.`) + "\nAvailable: " + available.join(", ")
+    );
+    process.exit(1);
+  }
+  const tools = opts.tools ? opts.tools.split(",").map((t) => t.trim()) : config.tools;
+  let filter;
+  if (opts.skillsOnly) filter = ["skills"];
+  else if (opts.agentsOnly) filter = ["agents"];
+  else if (opts.rulesOnly) filter = ["rules"];
+  else if (opts.commandsOnly) filter = ["commands"];
+  else if (opts.hooksOnly) filter = ["hooks"];
+  const result = installPack({ pack, tools, filter, projectDir });
+  const updated = mergeInstall(config, result);
+  updated.packs[pack.name].version = pack.version;
+  writeConfig(projectDir, updated);
+  updateGitignore(projectDir, getWrittenDirs(tools, result.installed.skills > 0));
+  const parts = [];
+  for (const [type, count] of Object.entries(result.installed)) {
+    if (count > 0) parts.push(`${count} ${type}`);
+  }
+  console.log(
+    pc2.green(`+ ${pack.name}`) + pc2.dim(` v${pack.version}`) + (parts.length ? ` (${parts.join(", ")})` : "")
+  );
+  console.log(pc2.dim(`  \u2192 ${tools.map((t) => t).join(", ")}`));
+});
+
+// src/commands/list.ts
+import { Command as Command3 } from "commander";
+import pc3 from "picocolors";
+var listCommand = new Command3("list").description("List available or installed packs").option("--installed", "Show only installed packs").option("--cwd <dir>", "Project directory").action((opts) => {
+  const projectDir = opts.cwd ? opts.cwd : process.cwd();
+  if (opts.installed) {
+    const config2 = readConfig(projectDir);
+    if (!config2 || Object.keys(config2.packs).length === 0) {
+      console.log(pc3.dim("No packs installed. Run ") + pc3.cyan("ai-kit init") + pc3.dim(" to get started."));
+      return;
+    }
+    console.log(pc3.bold("Installed packs:\n"));
+    for (const [name, pack] of Object.entries(config2.packs)) {
+      const parts = Object.entries(pack.components).filter(([, v]) => v && v.length > 0).map(([type, v]) => `${v[0].replace(" files", "")} ${type}`);
+      console.log(`  ${pc3.green(name)} ${pc3.dim(`v${pack.version}`)}  ${pc3.dim(parts.join(", "))}`);
+    }
+    console.log(`
+${pc3.dim(`Tools: ${config2.tools.join(", ")}`)}`);
+    return;
+  }
+  let packs;
+  try {
+    packs = discoverPacks();
+  } catch {
+    console.error(pc3.red("Could not find marketplace.json."));
+    process.exit(1);
+  }
+  const config = readConfig(projectDir);
+  const installedNames = config ? Object.keys(config.packs) : [];
+  console.log(pc3.bold("Available packs:\n"));
+  for (const pack of packs) {
+    const installed = installedNames.includes(pack.name);
+    const badge = installed ? pc3.green(" [installed]") : "";
+    const counts = [];
+    if (pack.agents.length) counts.push(`${pack.agents.length} agents`);
+    if (pack.skills.length) counts.push(`${pack.skills.length} skills`);
+    if (pack.commands.length) counts.push(`${pack.commands.length} commands`);
+    if (pack.rules.length) counts.push(`${pack.rules.length} rules`);
+    if (pack.hooks.length) counts.push(`${pack.hooks.length} hooks`);
+    console.log(
+      `  ${pc3.cyan(pack.name)}${badge} ${pc3.dim(`v${pack.version}`)}
+    ${pack.description}
+    ${pc3.dim(counts.join(", "))}`
+    );
+  }
+  console.log(`
+${pc3.dim(`${packs.length} packs available`)}`);
+});
+
+// src/commands/remove.ts
+import { Command as Command4 } from "commander";
+import path7 from "path";
+import pc4 from "picocolors";
+var removeCommand = new Command4("remove").description("Remove a pack from your project").argument("<pack>", "Pack name to remove").option("--cwd <dir>", "Project directory").action((packName, opts) => {
+  const projectDir = opts.cwd ? path7.resolve(opts.cwd) : process.cwd();
+  const config = readConfig(projectDir);
+  if (!config) {
+    console.error(pc4.red("No .ai-kit.json found."));
+    process.exit(1);
+  }
+  const packConfig = config.packs[packName];
+  if (!packConfig) {
+    console.error(
+      pc4.red(`Pack "${packName}" is not installed.`) + "\nInstalled: " + Object.keys(config.packs).join(", ")
+    );
+    process.exit(1);
+  }
+  const files = packConfig.files ?? [];
+  if (files.length === 0) {
+    console.log(pc4.yellow(`No tracked files for "${packName}". Removing from config only.`));
+  } else {
+    const removed = removePack2(projectDir, files);
+    console.log(pc4.green(`Removed ${removed} file(s) for ${packName}`));
+  }
+  const updated = removePack(config, packName);
+  writeConfig(projectDir, updated);
+  console.log(pc4.dim("Config updated."));
+});
+
+// src/commands/update.ts
+import { Command as Command5 } from "commander";
+import path8 from "path";
+import pc5 from "picocolors";
+var updateCommand = new Command5("update").description("Update installed packs").argument("[pack]", "Pack name (omit to update all)").option("--cwd <dir>", "Project directory").action((packName, opts) => {
+  const projectDir = opts.cwd ? path8.resolve(opts.cwd) : process.cwd();
+  const config = readConfig(projectDir);
+  if (!config) {
+    console.error(pc5.red("No .ai-kit.json found. Run ") + pc5.cyan("ai-kit init") + pc5.red(" first."));
+    process.exit(1);
+  }
+  const packsToUpdate = packName ? [packName] : Object.keys(config.packs);
+  if (packsToUpdate.length === 0) {
+    console.log(pc5.dim("No packs installed."));
+    return;
+  }
+  let updated = 0;
+  let skipped = 0;
+  let hadSkills = false;
+  for (const name of packsToUpdate) {
+    const installed = config.packs[name];
+    if (!installed) {
+      console.log(pc5.yellow(`"${name}" is not installed, skipping.`));
+      skipped++;
+      continue;
+    }
+    const available = findPack(name);
+    if (!available) {
+      console.log(pc5.yellow(`"${name}" not found in marketplace, skipping.`));
+      skipped++;
+      continue;
+    }
+    if (available.version === installed.version) {
+      console.log(pc5.dim(`  ${name} v${installed.version} \u2014 already up to date`));
+      skipped++;
+      continue;
+    }
+    if (installed.files && installed.files.length > 0) {
+      removePack2(projectDir, installed.files);
+    }
+    const result = installPack({
+      pack: available,
+      tools: config.tools,
+      projectDir
+    });
+    const merged = mergeInstall(config, result);
+    merged.packs[name].version = available.version;
+    Object.assign(config, merged);
+    if (result.installed.skills > 0) hadSkills = true;
+    console.log(
+      pc5.green(`  ${name}`) + ` ${pc5.dim(installed.version)} \u2192 ${pc5.cyan(available.version)}`
+    );
+    updated++;
+  }
+  writeConfig(projectDir, config);
+  updateGitignore(projectDir, getWrittenDirs(config.tools, hadSkills));
+  if (updated > 0) {
+    console.log(pc5.green(`
+Updated ${updated} pack(s).`));
+  }
+  if (skipped > 0 && updated === 0) {
+    console.log(pc5.dim("\nAll packs are up to date."));
+  }
+});
+
+// src/index.ts
+var program = new Command6().name("ai-kit").description("AI coding tool pack manager").version("0.0.1");
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(listCommand);
+program.addCommand(removeCommand);
+program.addCommand(updateCommand);
+program.parse();

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@smicolon/ai-kit",
+  "version": "0.0.1",
+  "description": "AI coding tool pack manager for Smicolon standards",
+  "type": "module",
+  "bin": {
+    "ai-kit": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": ["dist", "packs"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "commander": "^14.0.3",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}