@mikulgohil/ai-kit 1.0.0 → 1.1.0

package/dist/index.js

@@ -13,19 +13,31 @@ var TEMPLATES_DIR = path.join(PACKAGE_ROOT, "templates");
 var COMMANDS_DIR = path.join(PACKAGE_ROOT, "commands");
 var GUIDES_DIR = path.join(PACKAGE_ROOT, "guides");
 var DOCS_SCAFFOLDS_DIR = path.join(PACKAGE_ROOT, "docs-scaffolds");
-var VERSION = "1.0.0";
+var VERSION = "1.1.0";
 var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
 var GENERATED_FILES = {
   claudeMd: "CLAUDE.md",
   cursorRules: ".cursorrules",
   cursorMdcDir: ".cursor/rules",
   claudeSettings: ".claude/settings.json",
-  claudeCommands: ".claude/commands"
+  claudeCommands: ".claude/commands",
+  claudeSkills: ".claude/skills",
+  cursorSkills: ".cursor/skills"
 };
+var TEMPLATE_FRAGMENTS = [
+  "base",
+  "nextjs-app-router",
+  "nextjs-pages-router",
+  "sitecore-xmc",
+  "tailwind",
+  "typescript",
+  "monorepo",
+  "figma"
+];
 
 // src/commands/init.ts
 import path15 from "path";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 import { select, confirm } from "@inquirer/prompts";
 import ora from "ora";
 
@@ -388,8 +400,7 @@ function detectMcpServers(projectPath) {
     figma: combined.includes("figma"),
     github: combined.includes("github"),
     context7: combined.includes("context7"),
-    perplexity: combined.includes("perplexity"),
-    notion: combined.includes("notion")
+    perplexity: combined.includes("perplexity")
   };
 }
 
@@ -430,6 +441,7 @@ async function scanProject(projectPath) {
 
 // src/generator/assembler.ts
 import path11 from "path";
+import fs2 from "fs-extra";
 function readTemplate(relativePath) {
   const fullPath = path11.join(TEMPLATES_DIR, relativePath);
   const content = readFileSafe(fullPath);
@@ -438,21 +450,51 @@ function readTemplate(relativePath) {
   }
   return content.trim();
 }
-function assembleTemplate(subfolder, fragments, variables) {
+function loadCustomFragments(projectPath) {
+  const customDir = path11.join(projectPath, ".ai-kit", "fragments");
+  if (!fs2.existsSync(customDir)) return [];
+  try {
+    const files = fs2.readdirSync(customDir).filter((f) => f.endsWith(".md"));
+    return files.map((f) => {
+      const content = fs2.readFileSync(path11.join(customDir, f), "utf-8");
+      return content.trim();
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function assembleTemplate(subfolder, fragments, variables, options) {
   const versionComment = `<!-- Generated by ai-kit v${VERSION} -->`;
   const header = readTemplate("header.md");
   const body = fragments.map((name) => readTemplate(`${subfolder}/${name}.md`)).join("\n\n---\n\n");
+  const strictnessNote = options?.strictness && options.strictness !== "standard" ? `
+
+---
+
+> **Strictness Level: ${options.strictness}**
+> ${getStrictnessDescription(options.strictness)}` : "";
+  const customSection = options?.customFragments?.length ? "\n\n---\n\n" + options.customFragments.join("\n\n---\n\n") : "";
   const full = `${versionComment}
 ${header}
 
 ---
 
-${body}`;
+${body}${strictnessNote}${customSection}`;
   const replaced = replacePlaceholders(full, variables);
   return `<!-- AI-KIT:START -->
 ${replaced}
 <!-- AI-KIT:END -->`;
 }
+function getStrictnessDescription(level) {
+  switch (level) {
+    case "strict":
+      return "Enforce all rules strictly. No exceptions without explicit approval. All PRs must pass every check. Zero tolerance for `any` types, missing tests, or accessibility gaps.";
+    case "relaxed":
+      return "Rules are guidelines, not hard requirements. Prioritize shipping speed over perfection. Skip non-critical checks when under time pressure. Use best judgment.";
+    default:
+      return "Standard enforcement. Follow rules by default, use judgment for edge cases.";
+  }
+}
 function replacePlaceholders(content, variables) {
   let result = content;
   for (const [key, value] of Object.entries(variables)) {
@@ -489,10 +531,13 @@ function selectFragments(scan) {
   }
   return fragments;
 }
-function generateClaudeMd(scan) {
+function generateClaudeMd(scan, options) {
   const fragments = selectFragments(scan);
   const variables = buildVariables(scan);
-  return assembleTemplate("claude-md", fragments, variables);
+  return assembleTemplate("claude-md", fragments, variables, {
+    customFragments: options?.customFragments,
+    strictness: options?.strictness
+  });
 }
 function buildVariables(scan) {
   const techStack = [];
@@ -526,10 +571,13 @@ function buildVariables(scan) {
 }
 
 // src/generator/cursorrules.ts
-function generateCursorRules(scan) {
+function generateCursorRules(scan, options) {
   const fragments = selectFragments(scan);
   const variables = buildCursorVariables(scan);
-  return assembleTemplate("cursorrules", fragments, variables);
+  return assembleTemplate("cursorrules", fragments, variables, {
+    customFragments: options?.customFragments,
+    strictness: options?.strictness
+  });
 }
 function buildCursorVariables(scan) {
   const techStack = [];
@@ -619,21 +667,23 @@ ${replaced}`
 }
 
 // src/generator/config.ts
-function generateConfig(scan, templates, commands, guides) {
+function generateConfig(scan, templates, commands, guides, options) {
   return {
     version: VERSION,
     scanResult: scan,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     templates,
     commands,
-    guides
+    guides,
+    strictness: options?.strictness || "standard",
+    customFragments: options?.customFragments || []
   };
 }
 
-// src/copier/commands.ts
+// src/copier/skills.ts
 import path12 from "path";
-import fs2 from "fs-extra";
-var AVAILABLE_COMMANDS = [
+import fs3 from "fs-extra";
+var AVAILABLE_SKILLS = [
   "prompt-help",
   "review",
   "fix-bug",
@@ -659,26 +709,94 @@ var AVAILABLE_COMMANDS = [
   "sitecore-debug",
   "responsive-check",
   "document",
-  "token-tips"
+  "token-tips",
+  // New skills (v1.1.0)
+  "perf-audit",
+  "bundle-check",
+  "i18n-check",
+  "schema-gen",
+  "docker-debug",
+  "ci-fix",
+  "changelog",
+  "release",
+  "storybook-gen",
+  "visual-diff",
+  "db-migrate",
+  "dependency-graph"
 ];
-async function copyCommands(targetDir) {
-  const commandsTarget = path12.join(targetDir, ".claude", "commands");
-  await fs2.ensureDir(commandsTarget);
+var SKILL_DESCRIPTIONS = {
+  "prompt-help": "Help developers write effective AI prompts with structured context",
+  "review": "Deep code review following project coding standards",
+  "fix-bug": "Systematic debugging workflow with root cause analysis and regression testing",
+  "new-component": "Scaffold new React components with types, tests, and documentation",
+  "new-page": "Scaffold new Next.js pages/routes with proper file structure",
+  "understand": "Explain code architecture, data flow, and design decisions",
+  "test": "Generate unit and integration tests with React Testing Library",
+  "optimize": "Analyze and fix performance issues in components and pages",
+  "figma-to-code": "Implement Figma designs using project design tokens",
+  "design-tokens": "Audit and manage design token systems",
+  "accessibility-audit": "WCAG 2.1 AA accessibility compliance audit",
+  "security-check": "Scan for XSS, injection, secrets, and OWASP Top 10 vulnerabilities",
+  "refactor": "Restructure code to improve readability without changing behavior",
+  "api-route": "Scaffold Next.js API routes with validation, typing, and error handling",
+  "pre-pr": "Pre-pull-request checklist covering types, a11y, security, tests, and more",
+  "migrate": "Guide framework and library migrations step by step",
+  "error-boundary": "Generate error boundaries, loading states, and fallback UI",
+  "type-fix": "Fix TypeScript issues \u2014 replace any types, add null checks, tighten types",
+  "extract-hook": "Extract component logic into reusable custom React hooks",
+  "dep-check": "Audit dependencies for unused, outdated, vulnerable, and bloated packages",
+  "env-setup": "Generate .env.example, validate environment variables, check for leaked secrets",
+  "commit-msg": "Generate conventional commit messages from staged git changes",
+  "sitecore-debug": "Debug Sitecore XM Cloud integration issues",
+  "responsive-check": "Audit responsive design \u2014 breakpoints, touch targets, overflow",
+  "document": "Generate documentation for existing components and utilities",
+  "token-tips": "Token usage optimization strategies for AI coding assistants",
+  // New skills (v1.1.0)
+  "perf-audit": "Lighthouse-style performance audit covering Core Web Vitals, resource loading, and caching",
+  "bundle-check": "Analyze bundle size, find heavy imports, suggest tree-shaking and code splitting",
+  "i18n-check": "Find hardcoded strings, missing translation keys, and internationalization gaps",
+  "schema-gen": "Generate TypeScript types and Zod schemas from API responses, JSON, or GraphQL",
+  "docker-debug": "Analyze Dockerfiles for security, efficiency, and best practice violations",
+  "ci-fix": "Debug CI/CD pipeline failures, optimize caching, and improve build performance",
+  "changelog": "Generate formatted changelogs from git history following Keep a Changelog format",
+  "release": "Guided release workflow with versioning, changelog, tagging, and release notes",
+  "storybook-gen": "Generate Storybook stories with controls, play functions, and visual tests",
+  "visual-diff": "Visual regression testing plan for changed components and pages",
+  "db-migrate": "Create safe database migrations with rollback strategies for Prisma, Drizzle, or SQL",
+  "dependency-graph": "Map module dependencies, find circular imports, and analyze coupling metrics"
+};
+async function copySkills(targetDir) {
   const copied = [];
-  for (const cmd of AVAILABLE_COMMANDS) {
-    const src = path12.join(COMMANDS_DIR, `${cmd}.md`);
-    const dest = path12.join(commandsTarget, `${cmd}.md`);
-    if (await fs2.pathExists(src)) {
-      await fs2.copy(src, dest, { overwrite: true });
-      copied.push(cmd);
-    }
+  for (const skill of AVAILABLE_SKILLS) {
+    const src = path12.join(COMMANDS_DIR, `${skill}.md`);
+    if (!await fs3.pathExists(src)) continue;
+    const content = await fs3.readFile(src, "utf-8");
+    const description = SKILL_DESCRIPTIONS[skill] || skill;
+    const claudeSkillDir = path12.join(targetDir, ".claude", "skills", skill);
+    await fs3.ensureDir(claudeSkillDir);
+    await fs3.writeFile(
+      path12.join(claudeSkillDir, "SKILL.md"),
+      content,
+      "utf-8"
+    );
+    const cursorSkillDir = path12.join(targetDir, ".cursor", "skills", skill);
+    await fs3.ensureDir(cursorSkillDir);
+    await fs3.writeFile(
+      path12.join(cursorSkillDir, "SKILL.md"),
+      content,
+      "utf-8"
+    );
+    const legacyDir = path12.join(targetDir, ".claude", "commands");
+    await fs3.ensureDir(legacyDir);
+    await fs3.copy(src, path12.join(legacyDir, `${skill}.md`), { overwrite: true });
+    copied.push(skill);
   }
   return copied;
 }
 
 // src/copier/guides.ts
 import path13 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 var AVAILABLE_GUIDES = [
   "getting-started",
   "prompt-playbook",
@@ -688,13 +806,13 @@ var AVAILABLE_GUIDES = [
 ];
 async function copyGuides(targetDir) {
   const guidesTarget = path13.join(targetDir, "ai-kit", "guides");
-  await fs3.ensureDir(guidesTarget);
+  await fs4.ensureDir(guidesTarget);
   const copied = [];
   for (const guide of AVAILABLE_GUIDES) {
     const src = path13.join(GUIDES_DIR, `${guide}.md`);
     const dest = path13.join(guidesTarget, `${guide}.md`);
-    if (await fs3.pathExists(src)) {
-      await fs3.copy(src, dest, { overwrite: true });
+    if (await fs4.pathExists(src)) {
+      await fs4.copy(src, dest, { overwrite: true });
       copied.push(guide);
     }
   }
@@ -703,20 +821,20 @@ async function copyGuides(targetDir) {
 
 // src/copier/docs.ts
 import path14 from "path";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 var DOC_SCAFFOLDS = ["mistakes-log", "decisions-log", "time-log"];
 async function scaffoldDocs(targetDir) {
   const docsTarget = path14.join(targetDir, "docs");
-  await fs4.ensureDir(docsTarget);
+  await fs5.ensureDir(docsTarget);
   const created = [];
   for (const doc of DOC_SCAFFOLDS) {
     const src = path14.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
     const dest = path14.join(docsTarget, `${doc}.md`);
-    if (await fs4.pathExists(dest)) {
+    if (await fs5.pathExists(dest)) {
       continue;
     }
-    if (await fs4.pathExists(src)) {
-      await fs4.copy(src, dest);
+    if (await fs5.pathExists(src)) {
+      await fs5.copy(src, dest);
       created.push(doc);
     }
   }
@@ -759,16 +877,18 @@ async function initCommand(targetPath) {
   const clarifications = await askClarifications(scan);
   scan = applyClarifications(scan, clarifications);
   const tools = await selectTools();
+  const strictness = await selectStrictness();
+  const customFragments = loadCustomFragments(projectDir);
   const conflict = await selectConflictStrategy(projectDir);
   logSection("Generating Files");
-  const results = await generate(projectDir, scan, tools, conflict);
+  const results = await generate(projectDir, scan, tools, conflict, { strictness, customFragments });
   logSection("Setup Complete");
   if (results.claudeMd) logSuccess(`CLAUDE.md generated`);
   if (results.cursorRules) logSuccess(`.cursorrules generated`);
   if (results.cursorMdcFiles > 0)
     logSuccess(`${results.cursorMdcFiles} .cursor/rules/*.mdc files generated`);
   if (results.commands.length > 0)
-    logSuccess(`${results.commands.length} slash commands copied`);
+    logSuccess(`${results.commands.length} skills generated (.claude/skills/ + .cursor/skills/)`);
   if (results.guides.length > 0)
     logSuccess(`${results.guides.length} guides added to ai-kit/guides/`);
   if (results.docs.length > 0)
@@ -822,6 +942,17 @@ async function selectTools() {
     cursor: tool === "both" || tool === "cursor"
   };
 }
+async function selectStrictness() {
+  return select({
+    message: "How strictly should AI enforce these rules?",
+    choices: [
+      { name: "Standard \u2014 follow rules by default, use judgment for edge cases", value: "standard" },
+      { name: "Strict \u2014 enforce all rules, no exceptions without approval", value: "strict" },
+      { name: "Relaxed \u2014 rules are guidelines, prioritize shipping speed", value: "relaxed" }
+    ],
+    default: "standard"
+  });
+}
 async function selectConflictStrategy(projectDir) {
   const hasExisting = fileExists(path15.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path15.join(projectDir, GENERATED_FILES.cursorRules));
   if (!hasExisting) return "overwrite";
@@ -840,7 +971,7 @@ async function selectConflictStrategy(projectDir) {
     default: "overwrite"
   });
 }
-async function generate(projectDir, scan, tools, conflict) {
+async function generate(projectDir, scan, tools, conflict, opts) {
   const result = {
     claudeMd: false,
     cursorRules: false,
@@ -852,29 +983,28 @@ async function generate(projectDir, scan, tools, conflict) {
   if (tools.claude) {
     const claudeMdPath = path15.join(projectDir, GENERATED_FILES.claudeMd);
     if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
-      const content = generateClaudeMd(scan);
-      await fs5.writeFile(claudeMdPath, content, "utf-8");
+      const content = generateClaudeMd(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
+      await fs6.writeFile(claudeMdPath, content, "utf-8");
       result.claudeMd = true;
     } else {
       logWarning("CLAUDE.md exists, skipping");
     }
-    result.commands = await copyCommands(projectDir);
-    await fs5.ensureDir(path15.join(projectDir, ".claude", "commands"));
+    result.commands = await copySkills(projectDir);
   }
   if (tools.cursor) {
     const cursorPath = path15.join(projectDir, GENERATED_FILES.cursorRules);
     if (conflict === "overwrite" || !fileExists(cursorPath)) {
-      const content = generateCursorRules(scan);
-      await fs5.writeFile(cursorPath, content, "utf-8");
+      const content = generateCursorRules(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
+      await fs6.writeFile(cursorPath, content, "utf-8");
       result.cursorRules = true;
     } else {
       logWarning(".cursorrules exists, skipping");
     }
     const mdcDir = path15.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs5.ensureDir(mdcDir);
+    await fs6.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs5.writeFile(path15.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs6.writeFile(path15.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     result.cursorMdcFiles = mdcFiles.length;
   }
@@ -883,8 +1013,8 @@ async function generate(projectDir, scan, tools, conflict) {
   const templates = [];
   if (result.claudeMd) templates.push("CLAUDE.md");
   if (result.cursorRules) templates.push(".cursorrules");
-  const config = generateConfig(scan, templates, result.commands, result.guides);
-  await fs5.writeJson(
+  const config = generateConfig(scan, templates, result.commands, result.guides, { strictness: opts?.strictness, customFragments: opts?.customFragments });
+  await fs6.writeJson(
     path15.join(projectDir, AI_KIT_CONFIG_FILE),
     config,
     { spaces: 2 }
@@ -962,7 +1092,7 @@ function showRecommendations(scan) {
 
 // src/commands/update.ts
 import path16 from "path";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import ora2 from "ora";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function updateCommand(targetPath) {
@@ -993,44 +1123,47 @@ async function updateCommand(targetPath) {
   const scan = await scanProject(projectDir);
   spinner.succeed("Project re-scanned");
   logSection("Updating Files");
+  const strictness = existingConfig.strictness || "standard";
+  const customFragments = loadCustomFragments(projectDir);
+  const genOpts = { strictness, customFragments };
   const templates = [];
   if (existingConfig.templates.includes("CLAUDE.md") || fileExists(path16.join(projectDir, GENERATED_FILES.claudeMd))) {
     const claudeMdPath = path16.join(projectDir, GENERATED_FILES.claudeMd);
-    const newContent = generateClaudeMd(scan);
+    const newContent = generateClaudeMd(scan, genOpts);
     const existing = readFileSafe(claudeMdPath);
     if (existing) {
-      await fs6.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs7.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs6.writeFile(claudeMdPath, newContent, "utf-8");
+      await fs7.writeFile(claudeMdPath, newContent, "utf-8");
     }
     templates.push("CLAUDE.md");
     logSuccess("CLAUDE.md updated");
   }
   if (existingConfig.templates.includes(".cursorrules") || fileExists(path16.join(projectDir, GENERATED_FILES.cursorRules))) {
     const cursorRulesPath = path16.join(projectDir, GENERATED_FILES.cursorRules);
-    const newContent = generateCursorRules(scan);
+    const newContent = generateCursorRules(scan, genOpts);
     const existing = readFileSafe(cursorRulesPath);
     if (existing) {
-      await fs6.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs7.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs6.writeFile(cursorRulesPath, newContent, "utf-8");
+      await fs7.writeFile(cursorRulesPath, newContent, "utf-8");
     }
     templates.push(".cursorrules");
     logSuccess(".cursorrules updated");
     const mdcDir = path16.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs6.ensureDir(mdcDir);
+    await fs7.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs6.writeFile(path16.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs7.writeFile(path16.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
   }
-  const commands = await copyCommands(projectDir);
-  logSuccess(`${commands.length} slash commands updated`);
+  const commands = await copySkills(projectDir);
+  logSuccess(`${commands.length} skills updated (.claude/skills/ + .cursor/skills/)`);
   const guides = await copyGuides(projectDir);
   logSuccess(`${guides.length} guides updated`);
-  const config = generateConfig(scan, templates, commands, guides);
-  await fs6.writeJson(configPath, config, { spaces: 2 });
+  const config = generateConfig(scan, templates, commands, guides, genOpts);
+  await fs7.writeJson(configPath, config, { spaces: 2 });
   logSuccess("ai-kit.config.json updated");
   console.log("");
   logInfo("All AI configs refreshed with latest project scan.");
@@ -1038,7 +1171,7 @@ async function updateCommand(targetPath) {
 
 // src/commands/reset.ts
 import path17 from "path";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function resetCommand(targetPath) {
   const projectDir = path17.resolve(targetPath || process.cwd());
@@ -1048,6 +1181,8 @@ async function resetCommand(targetPath) {
   logInfo(`  - ${GENERATED_FILES.cursorRules}`);
   logInfo(`  - ${GENERATED_FILES.cursorMdcDir}/`);
   logInfo(`  - ${GENERATED_FILES.claudeCommands}/`);
+  logInfo(`  - ${GENERATED_FILES.claudeSkills}/`);
+  logInfo(`  - ${GENERATED_FILES.cursorSkills}/`);
   logInfo(`  - ai-kit/`);
   logInfo(`  - ${AI_KIT_CONFIG_FILE}`);
   console.log("");
@@ -1062,32 +1197,42 @@ async function resetCommand(targetPath) {
   const removed = [];
   const claudeMdPath = path17.join(projectDir, GENERATED_FILES.claudeMd);
   if (fileExists(claudeMdPath)) {
-    await fs7.remove(claudeMdPath);
+    await fs8.remove(claudeMdPath);
     removed.push(GENERATED_FILES.claudeMd);
   }
   const cursorPath = path17.join(projectDir, GENERATED_FILES.cursorRules);
   if (fileExists(cursorPath)) {
-    await fs7.remove(cursorPath);
+    await fs8.remove(cursorPath);
     removed.push(GENERATED_FILES.cursorRules);
   }
   const cursorMdcDir = path17.join(projectDir, GENERATED_FILES.cursorMdcDir);
   if (fileExists(cursorMdcDir)) {
-    await fs7.remove(cursorMdcDir);
+    await fs8.remove(cursorMdcDir);
     removed.push(GENERATED_FILES.cursorMdcDir);
   }
   const commandsDir = path17.join(projectDir, GENERATED_FILES.claudeCommands);
   if (fileExists(commandsDir)) {
-    await fs7.remove(commandsDir);
+    await fs8.remove(commandsDir);
     removed.push(GENERATED_FILES.claudeCommands);
   }
+  const claudeSkillsDir = path17.join(projectDir, GENERATED_FILES.claudeSkills);
+  if (fileExists(claudeSkillsDir)) {
+    await fs8.remove(claudeSkillsDir);
+    removed.push(GENERATED_FILES.claudeSkills);
+  }
+  const cursorSkillsDir = path17.join(projectDir, GENERATED_FILES.cursorSkills);
+  if (fileExists(cursorSkillsDir)) {
+    await fs8.remove(cursorSkillsDir);
+    removed.push(GENERATED_FILES.cursorSkills);
+  }
   const aiKitDir = path17.join(projectDir, "ai-kit");
   if (fileExists(aiKitDir)) {
-    await fs7.remove(aiKitDir);
+    await fs8.remove(aiKitDir);
     removed.push("ai-kit/");
   }
   const configPath = path17.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
-    await fs7.remove(configPath);
+    await fs8.remove(configPath);
     removed.push(AI_KIT_CONFIG_FILE);
   }
   logSection("Reset Complete");
@@ -1100,7 +1245,7 @@ async function resetCommand(targetPath) {
 
 // src/commands/tokens.ts
 import path18 from "path";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import chalk2 from "chalk";
 import ora3 from "ora";
 import os from "os";
@@ -1111,11 +1256,11 @@ var PRICING = {
 var PLAN_BUDGET = 20;
 function findSessionFiles() {
   const claudeDir = path18.join(os.homedir(), ".claude", "projects");
-  if (!fs8.existsSync(claudeDir)) return [];
+  if (!fs9.existsSync(claudeDir)) return [];
   const files = [];
   function walkDir(dir) {
     try {
-      const entries = fs8.readdirSync(dir, { withFileTypes: true });
+      const entries = fs9.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const full = path18.join(dir, entry.name);
         if (entry.isDirectory()) {
@@ -1132,7 +1277,7 @@ function findSessionFiles() {
 }
 function parseSessionFile(filePath) {
   try {
-    const content = fs8.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const usage = {
       inputTokens: 0,
@@ -1169,17 +1314,19 @@ function parseSessionFile(filePath) {
     }
     if (usage.inputTokens === 0 && usage.outputTokens === 0) return null;
     if (!sessionDate) {
-      const stat = fs8.statSync(filePath);
+      const stat = fs9.statSync(filePath);
       sessionDate = stat.mtime.toISOString().slice(0, 10);
     }
     const sessionId = path18.basename(filePath, ".jsonl");
+    const projectName = path18.basename(path18.dirname(filePath));
     return {
       sessionId,
       filePath,
       date: sessionDate,
       usage,
       model,
-      messageCount
+      messageCount,
+      projectName
     };
   } catch {
     return null;
@@ -1255,8 +1402,70 @@ ${chalk2.bold(label)}`);
   console.log(`  Cache read:    ${chalk2.white(fmt(usage.cacheReadTokens))}`);
   console.log(`  Estimated cost: ${chalk2.yellow("~" + fmtCost(cost))}`);
 }
+function printProjectBreakdown(sessions) {
+  const projectMap = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const existing = projectMap.get(s.projectName) || { sessions: 0, cost: 0 };
+    existing.sessions++;
+    existing.cost += calculateCost(s.usage, s.model);
+    projectMap.set(s.projectName, existing);
+  }
+  const sorted = Array.from(projectMap.entries()).sort((a, b) => b[1].cost - a[1].cost);
+  console.log(`
+${chalk2.bold("Per-Project Breakdown")}`);
+  for (const [name, data] of sorted.slice(0, 10)) {
+    const bar = progressBar(data.cost / sumCost(sessions) * 100, 15);
+    console.log(`  ${bar} ${chalk2.yellow(fmtCost(data.cost))} ${chalk2.dim(`(${data.sessions} sessions)`)} ${name}`);
+  }
+}
+function printTrendAnalysis(sessions) {
+  const today = /* @__PURE__ */ new Date();
+  const thisWeekStart = new Date(today);
+  thisWeekStart.setDate(today.getDate() - today.getDay() + (today.getDay() === 0 ? -6 : 1));
+  const thisWeekStr = thisWeekStart.toISOString().slice(0, 10);
+  const lastWeekStart = new Date(thisWeekStart);
+  lastWeekStart.setDate(lastWeekStart.getDate() - 7);
+  const lastWeekEnd = new Date(thisWeekStart);
+  lastWeekEnd.setDate(lastWeekEnd.getDate() - 1);
+  const lastWeekStartStr = lastWeekStart.toISOString().slice(0, 10);
+  const lastWeekEndStr = lastWeekEnd.toISOString().slice(0, 10);
+  const todayStr = today.toISOString().slice(0, 10);
+  const thisWeekSessions = filterDateRange(sessions, thisWeekStr, todayStr);
+  const lastWeekSessions = filterDateRange(sessions, lastWeekStartStr, lastWeekEndStr);
+  const thisWeekCost = sumCost(thisWeekSessions);
+  const lastWeekCost = sumCost(lastWeekSessions);
+  if (lastWeekCost > 0) {
+    const change = (thisWeekCost - lastWeekCost) / lastWeekCost * 100;
+    const arrow = change > 0 ? chalk2.red("\u2191") : change < 0 ? chalk2.green("\u2193") : chalk2.dim("\u2192");
+    const changeStr = change > 0 ? `+${change.toFixed(0)}%` : `${change.toFixed(0)}%`;
+    console.log(`
+${chalk2.bold("Week-over-Week Trend")}`);
+    console.log(`  Last week: ${chalk2.yellow(fmtCost(lastWeekCost))} (${lastWeekSessions.length} sessions)`);
+    console.log(`  This week: ${chalk2.yellow(fmtCost(thisWeekCost))} (${thisWeekSessions.length} sessions)`);
+    console.log(`  Change: ${arrow} ${changeStr}`);
+  }
+}
+function printRoiEstimate(sessions, monthCost) {
+  const AVG_MINUTES_SAVED_PER_SESSION = 15;
+  const DEVELOPER_HOURLY_RATE = 75;
+  const totalSessions = sessions.length;
+  const minutesSaved = totalSessions * AVG_MINUTES_SAVED_PER_SESSION;
+  const hoursSaved = minutesSaved / 60;
+  const valueSaved = hoursSaved * DEVELOPER_HOURLY_RATE;
+  const roi = monthCost > 0 ? (valueSaved - monthCost) / monthCost * 100 : 0;
+  console.log(`
+${chalk2.bold("ROI Estimate")} ${chalk2.dim("(based on ~15 min saved per session)")}`);
+  console.log(`  Sessions this month: ${chalk2.cyan(String(totalSessions))}`);
+  console.log(`  Estimated time saved: ${chalk2.cyan(`${hoursSaved.toFixed(1)} hours`)} (${minutesSaved} min)`);
+  console.log(`  Estimated value saved: ${chalk2.green(fmtCost(valueSaved))} (at $${DEVELOPER_HOURLY_RATE}/hr)`);
+  console.log(`  AI cost: ${chalk2.yellow(fmtCost(monthCost))}`);
+  if (roi > 0) {
+    console.log(`  ROI: ${chalk2.green(`${roi.toFixed(0)}%`)}`);
+  }
+}
 async function tokensCommand(options = {}) {
   logSection("AI Kit \u2014 Token Usage");
+  const budget = options.budget || PLAN_BUDGET;
   const spinner = ora3("Scanning Claude Code session logs...").start();
   const sessionFiles = findSessionFiles();
   if (sessionFiles.length === 0) {
@@ -1289,7 +1498,7 @@ async function tokensCommand(options = {}) {
   printPeriodSummary("This Week", weekSessions);
   printPeriodSummary("This Month", monthSessions);
   const monthCost = sumCost(monthSessions);
-  const budgetPercent = Math.min(monthCost / PLAN_BUDGET * 100, 100);
+  const budgetPercent = Math.min(monthCost / budget * 100, 100);
   const daysInMonth = new Date(
     (/* @__PURE__ */ new Date()).getFullYear(),
     (/* @__PURE__ */ new Date()).getMonth() + 1,
@@ -1298,16 +1507,37 @@ async function tokensCommand(options = {}) {
   const dayOfMonth = (/* @__PURE__ */ new Date()).getDate();
   const daysRemaining = daysInMonth - dayOfMonth;
   const dailyAvg = dayOfMonth > 0 ? monthCost / dayOfMonth : 0;
-  const estimatedDaysLeft = dailyAvg > 0 ? Math.floor((PLAN_BUDGET - monthCost) / dailyAvg) : daysRemaining;
+  const estimatedDaysLeft = dailyAvg > 0 ? Math.floor((budget - monthCost) / dailyAvg) : daysRemaining;
   console.log(`
-${chalk2.bold(`$${PLAN_BUDGET} Plan Budget`)}`);
+${chalk2.bold(`$${budget} Plan Budget`)}`);
   console.log(
-    `  ${progressBar(budgetPercent)} ${Math.round(budgetPercent)}% used (~${fmtCost(monthCost)} of ${fmtCost(PLAN_BUDGET)})`
+    `  ${progressBar(budgetPercent)} ${Math.round(budgetPercent)}% used (~${fmtCost(monthCost)} of ${fmtCost(budget)})`
   );
   console.log(
     `  Estimated days remaining at this rate: ${chalk2.cyan(String(Math.max(estimatedDaysLeft, 0)))} days`
   );
   console.log(`  Daily average: ${chalk2.yellow(fmtCost(dailyAvg))}`);
+  if (budgetPercent >= 90) {
+    console.log(chalk2.red.bold("\n  \u26A0 ALERT: Over 90% of monthly budget used!"));
+  } else if (budgetPercent >= 75) {
+    console.log(chalk2.yellow("\n  \u26A0 Warning: Over 75% of monthly budget used."));
+  } else if (budgetPercent >= 50) {
+    console.log(chalk2.blue("\n  \u2139 Note: Over 50% of monthly budget used."));
+  }
+  const opusSessions = monthSessions.filter((s) => s.model === "opus");
+  const sonnetSessions = monthSessions.filter((s) => s.model === "sonnet");
+  const opusCost = sumCost(opusSessions);
+  const sonnetCost = sumCost(sonnetSessions);
+  if (opusCost > sonnetCost * 2 && opusSessions.length > 5) {
+    console.log(`
+${chalk2.bold("Model Recommendation")}`);
+    console.log(`  Opus usage: ${chalk2.yellow(fmtCost(opusCost))} (${opusSessions.length} sessions)`);
+    console.log(`  Sonnet usage: ${chalk2.yellow(fmtCost(sonnetCost))} (${sonnetSessions.length} sessions)`);
+    console.log(chalk2.dim("  Tip: Use Sonnet for routine tasks (reviews, tests, docs) and Opus for complex tasks (architecture, debugging)."));
+  }
+  printProjectBreakdown(monthSessions);
+  printTrendAnalysis(sessions);
+  printRoiEstimate(monthSessions, monthCost);
   console.log(
     `
 ${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
@@ -1316,6 +1546,16 @@ ${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
     chalk2.dim("     it's cheaper than a failed implementation attempt.")
   );
   console.log("");
+  if (options.csv) {
+    const csvPath = path18.join(process.cwd(), "token-usage.csv");
+    const csvHeader = "Date,Sessions,Input Tokens,Output Tokens,Cache Tokens,Cost\n";
+    const daily = aggregateByDate(sessions);
+    const csvRows = daily.map(
+      (d) => `${d.date},${d.sessions},${d.usage.inputTokens},${d.usage.outputTokens},${d.usage.cacheReadTokens},${d.cost.toFixed(2)}`
+    ).join("\n");
+    await fs9.writeFile(csvPath, csvHeader + csvRows, "utf-8");
+    logSuccess(`CSV exported to ${csvPath}`);
+  }
   if (options.export) {
     await exportDashboard(sessions, todaySessions, weekSessions, monthSessions);
   }
@@ -1353,10 +1593,10 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
   const dataPath = path18.join(outputDir, "token-data.json");
   const dashboardSrc = path18.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
   const dashboardDest = path18.join(outputDir, "token-dashboard.html");
-  await fs8.writeJson(dataPath, exportData, { spaces: 2 });
+  await fs9.writeJson(dataPath, exportData, { spaces: 2 });
   logInfo(`Token data written to ${dataPath}`);
-  if (await fs8.pathExists(dashboardSrc)) {
-    await fs8.copy(dashboardSrc, dashboardDest, { overwrite: true });
+  if (await fs9.pathExists(dashboardSrc)) {
+    await fs9.copy(dashboardSrc, dashboardDest, { overwrite: true });
     logInfo(`Dashboard copied to ${dashboardDest}`);
   } else {
     logWarning("Dashboard template not found. Skipping HTML export.");
@@ -1372,6 +1612,739 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
   }
 }
 
+// src/commands/doctor.ts
+import path19 from "path";
+import chalk3 from "chalk";
+import ora4 from "ora";
+async function doctorCommand(targetPath) {
+  const projectDir = path19.resolve(targetPath || process.cwd());
+  const configPath = path19.join(projectDir, AI_KIT_CONFIG_FILE);
+  let passed = 0;
+  let warnings = 0;
+  let issues = 0;
+  logSection("AI Kit \u2014 Doctor");
+  console.log("");
+  if (!fileExists(configPath)) {
+    logError("ai-kit.config.json not found. Run `ai-kit init` first.");
+    issues++;
+    showSummary(passed, warnings, issues);
+    return;
+  }
+  const config = readJsonSafe(configPath);
+  if (!config) {
+    logError("ai-kit.config.json is corrupted or unreadable. Run `ai-kit init` to re-initialize.");
+    issues++;
+    showSummary(passed, warnings, issues);
+    return;
+  }
+  logSuccess(`ai-kit.config.json found (v${config.version})`);
+  passed++;
+  if (config.version !== VERSION) {
+    logWarning(
+      `Config version mismatch \u2014 config is v${config.version}, CLI is v${VERSION}. Run \`ai-kit update\` to sync.`
+    );
+    warnings++;
+  } else {
+    logSuccess(`Version matches CLI (v${VERSION})`);
+    passed++;
+  }
+  for (const template of config.templates) {
+    const templateFile = template === "CLAUDE.md" ? GENERATED_FILES.claudeMd : template === ".cursorrules" ? GENERATED_FILES.cursorRules : template;
+    const templatePath = path19.join(projectDir, templateFile);
+    if (fileExists(templatePath)) {
+      logSuccess(`${template} exists and in sync`);
+      passed++;
+    } else {
+      logError(`${template} is listed in config but missing from disk`);
+      issues++;
+    }
+  }
+  const missingSkills = [];
+  for (const skill of config.commands) {
+    const claudeSkillPath = path19.join(projectDir, GENERATED_FILES.claudeSkills, skill);
+    const cursorSkillPath = path19.join(projectDir, GENERATED_FILES.cursorSkills, skill);
+    if (!fileExists(claudeSkillPath) && !fileExists(cursorSkillPath)) {
+      missingSkills.push(skill);
+    }
+  }
+  if (missingSkills.length === 0) {
+    logSuccess(`${config.commands.length}/${config.commands.length} skills present`);
+    passed++;
+  } else {
+    logError(
+      `${config.commands.length - missingSkills.length}/${config.commands.length} skills present \u2014 missing: ${missingSkills.join(", ")}`
+    );
+    issues++;
+  }
+  const guidesDir = path19.join(projectDir, "ai-kit", "guides");
+  const missingGuides = [];
+  for (const guide of config.guides) {
+    const guidePath = path19.join(guidesDir, guide);
+    if (!fileExists(guidePath)) {
+      missingGuides.push(guide);
+    }
+  }
+  if (missingGuides.length === 0) {
+    logSuccess(`${config.guides.length}/${config.guides.length} guides present`);
+    passed++;
+  } else {
+    logError(
+      `${config.guides.length - missingGuides.length}/${config.guides.length} guides present \u2014 missing: ${missingGuides.join(", ")}`
+    );
+    issues++;
+  }
+  const spinner = ora4("Running fresh project scan...").start();
+  let freshScan;
+  try {
+    freshScan = await scanProject(projectDir);
+    spinner.succeed("Project re-scanned");
+  } catch (err) {
+    spinner.fail("Failed to scan project");
+    logWarning(`Could not run staleness check: ${String(err)}`);
+    warnings++;
+    freshScan = config.scanResult;
+  }
+  const stalenessWarnings = compareScanResults(config.scanResult, freshScan);
+  if (stalenessWarnings.length === 0) {
+    logSuccess("Config is up to date with project state");
+    passed++;
+  } else {
+    for (const warning of stalenessWarnings) {
+      logWarning(warning);
+      warnings++;
+    }
+  }
+  const mcpChecks = [
+    { name: "Playwright MCP", key: "playwright" },
+    { name: "Context7 MCP", key: "context7" },
+    { name: "GitHub MCP", key: "github" },
+    { name: "Perplexity MCP", key: "perplexity" },
+    { name: "Figma MCP", key: "figma" }
+  ];
+  for (const mcp of mcpChecks) {
+    if (freshScan.mcpServers[mcp.key]) {
+      logSuccess(`${mcp.name} configured`);
+      passed++;
+    } else {
+      logWarning(`${mcp.name} not configured`);
+      warnings++;
+    }
+  }
+  const toolChecks = [
+    { name: "Playwright", key: "playwright", hint: "npm install -D @playwright/test" },
+    { name: "ESLint", key: "eslint", hint: "npm install -D eslint" },
+    { name: "Prettier", key: "prettier", hint: "npm install -D prettier" },
+    { name: "axe-core", key: "axeCore", hint: "npm install -D @axe-core/playwright" },
+    { name: "Knip", key: "knip", hint: "npm install -D knip" },
+    { name: "Bundle Analyzer", key: "bundleAnalyzer", hint: "npm install -D @next/bundle-analyzer" }
+  ];
+  for (const tool of toolChecks) {
+    if (freshScan.tools[tool.key]) {
+      logSuccess(`${tool.name} detected`);
+      passed++;
+    } else {
+      logError(`${tool.name} not found \u2014 recommend installing: ${tool.hint}`);
+      issues++;
+    }
+  }
+  console.log("");
+  showSummary(passed, warnings, issues);
+}
+function showSummary(passed, warnings, issues) {
+  const parts = [];
+  parts.push(chalk3.green(`${passed} passed`));
+  if (warnings > 0) parts.push(chalk3.yellow(`${warnings} warnings`));
+  if (issues > 0) parts.push(chalk3.red(`${issues} issues`));
+  console.log(chalk3.bold(`Summary: ${parts.join(", ")}`));
+}
+function compareScanResults(previous, current) {
+  const warnings = [];
+  if (previous.framework !== current.framework) {
+    warnings.push(
+      `Stack may have changed \u2014 framework was ${previous.framework}, now ${current.framework}`
+    );
+  }
+  if (previous.nextjsVersion && current.nextjsVersion && previous.nextjsVersion !== current.nextjsVersion) {
+    warnings.push(
+      `Next.js version changed: ${previous.nextjsVersion} \u2192 ${current.nextjsVersion}`
+    );
+  }
+  if (previous.routerType && current.routerType && previous.routerType !== current.routerType) {
+    warnings.push(
+      `Router type changed: ${previous.routerType} \u2192 ${current.routerType}`
+    );
+  }
+  const prevStyles = new Set(previous.styling);
+  const currStyles = new Set(current.styling);
+  for (const style of currStyles) {
+    if (!prevStyles.has(style)) {
+      warnings.push(`Stack may have changed \u2014 detected new styling: ${style}`);
+    }
+  }
+  for (const style of prevStyles) {
+    if (!currStyles.has(style)) {
+      warnings.push(`Stack may have changed \u2014 styling removed: ${style}`);
+    }
+  }
+  if (previous.typescript !== current.typescript) {
+    warnings.push(
+      `TypeScript ${current.typescript ? "detected (was not before)" : "no longer detected"}`
+    );
+  }
+  if (previous.monorepo !== current.monorepo) {
+    warnings.push(
+      `Monorepo ${current.monorepo ? "detected (was not before)" : "no longer detected"}`
+    );
+  }
+  if (previous.packageManager !== current.packageManager) {
+    warnings.push(
+      `Package manager changed: ${previous.packageManager} \u2192 ${current.packageManager}`
+    );
+  }
+  const toolKeys = Object.keys(current.tools);
+  for (const key of toolKeys) {
+    if (current.tools[key] && !previous.tools[key]) {
+      warnings.push(`Stack may have changed \u2014 detected new tool: ${key}`);
+    }
+    if (!current.tools[key] && previous.tools[key]) {
+      warnings.push(`Stack may have changed \u2014 tool removed: ${key}`);
+    }
+  }
+  if (previous.cms !== current.cms) {
+    warnings.push(`CMS changed: ${previous.cms} \u2192 ${current.cms}`);
+  }
+  return warnings;
+}
+
+// src/commands/diff.ts
+import path20 from "path";
+import fs10 from "fs-extra";
+import chalk4 from "chalk";
+import ora5 from "ora";
+async function diffCommand(targetPath) {
+  const projectDir = path20.resolve(targetPath || process.cwd());
+  const configPath = path20.join(projectDir, AI_KIT_CONFIG_FILE);
+  console.log(chalk4.bold("AI Kit \u2014 Diff (dry run)\n"));
+  if (!fileExists(configPath)) {
+    logError("No ai-kit.config.json found. Run `ai-kit init` first.");
+    return;
+  }
+  const existingConfig = readJsonSafe(configPath);
+  if (!existingConfig) {
+    logError("Could not read ai-kit.config.json. Run `ai-kit init` to re-initialize.");
+    return;
+  }
+  const existingMajor = parseInt(existingConfig.version.split(".")[0], 10);
+  const currentMajor = parseInt(VERSION.split(".")[0], 10);
+  if (existingMajor !== currentMajor) {
+    logWarning(
+      `Config was generated with ai-kit v${existingConfig.version}, but you're running v${VERSION}. Consider running \`ai-kit init\` to re-initialize.`
+    );
+  }
+  const spinner = ora5("Scanning project...").start();
+  const newScan = await scanProject(projectDir);
+  spinner.succeed("Project scanned");
+  const oldScan = existingConfig.scanResult;
+  logSection("Stack Changes");
+  const stackChanges = diffStack(oldScan, newScan);
+  if (stackChanges.length === 0) {
+    console.log(chalk4.dim("  No stack changes detected"));
+  } else {
+    for (const change of stackChanges) {
+      if (change.type === "added") {
+        console.log(chalk4.green(`  + ${change.label}`));
+      } else if (change.type === "modified") {
+        console.log(chalk4.yellow(`  ~ ${change.label}`));
+      } else {
+        console.log(chalk4.red(`  - ${change.label}`));
+      }
+    }
+  }
+  logSection("File Changes");
+  const oldFragments = selectFragments(oldScan);
+  const newFragments = selectFragments(newScan);
+  let modified = 0;
+  let added = 0;
+  let unchanged = 0;
+  const claudeMdStatus = diffGeneratedFile(
+    projectDir,
+    GENERATED_FILES.claudeMd,
+    existingConfig,
+    () => generateClaudeMd(newScan),
+    oldFragments,
+    newFragments
+  );
+  logFileChange(claudeMdStatus);
+  if (claudeMdStatus.status === "modified") modified++;
+  else if (claudeMdStatus.status === "added") added++;
+  else unchanged++;
+  const cursorRulesStatus = diffGeneratedFile(
+    projectDir,
+    GENERATED_FILES.cursorRules,
+    existingConfig,
+    () => generateCursorRules(newScan),
+    oldFragments,
+    newFragments
+  );
+  logFileChange(cursorRulesStatus);
+  if (cursorRulesStatus.status === "modified") modified++;
+  else if (cursorRulesStatus.status === "added") added++;
+  else unchanged++;
+  const skillsDir = path20.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillCount = countFilesInDir(skillsDir);
+  console.log(chalk4.dim(`  unchanged ${GENERATED_FILES.claudeSkills}/ (${skillCount} skills)`));
+  unchanged++;
+  const guidesDir = path20.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
+  const guideCount = existingConfig.guides?.length || 0;
+  console.log(chalk4.dim(`  unchanged ai-kit/guides/ (${guideCount} guides)`));
+  unchanged++;
+  console.log("");
+  const parts = [];
+  if (modified > 0) parts.push(`${modified} files would be modified`);
+  if (added > 0) parts.push(`${added} added`);
+  const removed = 0;
+  parts.push(`${removed} removed`);
+  logInfo(`Summary: ${parts.join(", ")}`);
+  logInfo("Run `ai-kit update` to apply these changes.");
+}
+var AI_KIT_FOLDER_NAME = "ai-kit";
+function diffStack(oldScan, newScan) {
+  const changes = [];
+  if (oldScan.framework === newScan.framework && newScan.framework === "nextjs") {
+    if (oldScan.nextjsVersion !== newScan.nextjsVersion) {
+      changes.push({
+        type: "modified",
+        label: `Next.js version: ${oldScan.nextjsVersion || "unknown"} \u2192 ${newScan.nextjsVersion || "unknown"}`
+      });
+    }
+  } else if (oldScan.framework !== newScan.framework) {
+    if (oldScan.framework !== "unknown") {
+      changes.push({ type: "removed", label: `${oldScan.framework} no longer detected` });
+    }
+    if (newScan.framework !== "unknown") {
+      changes.push({ type: "added", label: `${newScan.framework} detected` });
+    }
+  }
+  if (oldScan.routerType !== newScan.routerType && newScan.framework === "nextjs") {
+    changes.push({
+      type: "modified",
+      label: `Router type: ${oldScan.routerType || "unknown"} \u2192 ${newScan.routerType || "unknown"}`
+    });
+  }
+  if (!oldScan.typescript && newScan.typescript) {
+    changes.push({ type: "added", label: "TypeScript detected" });
+  } else if (oldScan.typescript && !newScan.typescript) {
+    changes.push({ type: "removed", label: "TypeScript no longer detected" });
+  }
+  const oldStyles = new Set(oldScan.styling);
+  const newStyles = new Set(newScan.styling);
+  for (const style of newStyles) {
+    if (!oldStyles.has(style)) {
+      changes.push({ type: "added", label: `${style} detected (styling)` });
+    }
+  }
+  for (const style of oldStyles) {
+    if (!newStyles.has(style)) {
+      changes.push({ type: "removed", label: `${style} no longer detected` });
+    }
+  }
+  if (oldScan.styling.includes("tailwind") && newScan.styling.includes("tailwind") && oldScan.tailwindVersion !== newScan.tailwindVersion) {
+    changes.push({
+      type: "modified",
+      label: `Tailwind version: ${oldScan.tailwindVersion || "unknown"} \u2192 ${newScan.tailwindVersion || "unknown"}`
+    });
+  }
+  if (!oldScan.monorepo && newScan.monorepo) {
+    changes.push({
+      type: "added",
+      label: `monorepo detected${newScan.monorepoTool ? ` (${newScan.monorepoTool})` : ""}`
+    });
+  } else if (oldScan.monorepo && !newScan.monorepo) {
+    changes.push({ type: "removed", label: "monorepo no longer detected" });
+  } else if (oldScan.monorepoTool !== newScan.monorepoTool && newScan.monorepo) {
+    changes.push({
+      type: "modified",
+      label: `monorepo tool: ${oldScan.monorepoTool || "unknown"} \u2192 ${newScan.monorepoTool || "unknown"}`
+    });
+  }
+  if (oldScan.cms !== newScan.cms) {
+    if (oldScan.cms !== "none") {
+      changes.push({ type: "removed", label: `${oldScan.cms} no longer detected` });
+    }
+    if (newScan.cms !== "none") {
+      changes.push({ type: "added", label: `${newScan.cms} detected (CMS)` });
+    }
+  }
+  if (oldScan.packageManager !== newScan.packageManager) {
+    changes.push({
+      type: "modified",
+      label: `Package manager: ${oldScan.packageManager} \u2192 ${newScan.packageManager}`
+    });
+  }
+  if (!oldScan.figma?.detected && newScan.figma?.detected) {
+    changes.push({ type: "added", label: "Figma integration detected" });
+  } else if (oldScan.figma?.detected && !newScan.figma?.detected) {
+    changes.push({ type: "removed", label: "Figma integration no longer detected" });
+  }
+  if (oldScan.tools && newScan.tools) {
+    const toolNames = Object.keys(newScan.tools);
+    for (const tool of toolNames) {
+      if (!oldScan.tools[tool] && newScan.tools[tool]) {
+        changes.push({ type: "added", label: `${tool} detected (tooling)` });
+      }
+    }
+    const oldToolNames = Object.keys(oldScan.tools);
+    for (const tool of oldToolNames) {
+      if (oldScan.tools[tool] && !newScan.tools[tool]) {
+        changes.push({ type: "removed", label: `${tool} no longer detected` });
+      }
+    }
+  }
+  return changes;
+}
+function diffGeneratedFile(projectDir, filename, config, generate2, oldFragments, newFragments) {
+  const filePath = path20.join(projectDir, filename);
+  const currentContent = readFileSafe(filePath);
+  const newContent = generate2();
+  if (!currentContent) {
+    if (config.templates.includes(filename)) {
+      return { filename, status: "added", detail: "file missing, would be created" };
+    }
+    return { filename, status: "unchanged", detail: "not configured" };
+  }
+  if (currentContent.trim() === newContent.trim()) {
+    return { filename, status: "unchanged" };
+  }
+  const addedFragments = newFragments.filter((f) => !oldFragments.includes(f));
+  const removedFragments = oldFragments.filter((f) => !newFragments.includes(f));
+  const fragmentDetails = [];
+  if (addedFragments.length > 0) {
+    fragmentDetails.push(`+${addedFragments.join(", +")}`);
+  }
+  if (removedFragments.length > 0) {
+    fragmentDetails.push(`-${removedFragments.join(", -")}`);
+  }
+  const detail = fragmentDetails.length > 0 ? `template fragments changed: ${fragmentDetails.join(", ")}` : "content changed";
+  return { filename, status: "modified", detail };
+}
+function logFileChange(result) {
+  if (result.status === "added") {
+    console.log(chalk4.green(`  added     ${result.filename}`) + (result.detail ? chalk4.dim(` (${result.detail})`) : ""));
+  } else if (result.status === "modified") {
+    console.log(
+      chalk4.yellow(`  modified  ${result.filename}`) + (result.detail ? chalk4.dim(` (${result.detail})`) : "")
+    );
+  } else {
+    console.log(chalk4.dim(`  unchanged ${result.filename}`));
+  }
+}
+function countFilesInDir(dirPath) {
+  try {
+    if (!fs10.existsSync(dirPath)) return 0;
+    const entries = fs10.readdirSync(dirPath);
+    return entries.filter((e) => !e.startsWith(".")).length;
+  } catch {
+    return 0;
+  }
+}
+
+// src/commands/export.ts
+import path21 from "path";
+import fs11 from "fs-extra";
+import ora6 from "ora";
+import { select as select2 } from "@inquirer/prompts";
+var EXPORT_TARGETS = {
+  windsurf: { file: ".windsurfrules", label: "Windsurf" },
+  aider: { file: ".aider.conf.yml", label: "Aider" },
+  cline: { file: ".clinerules", label: "Cline" }
+};
+function stripMarkers(content) {
+  return content.replace("<!-- AI-KIT:START -->\n", "").replace("\n<!-- AI-KIT:END -->", "").replace(/<!-- Generated by ai-kit v[\d.]+ -->\n?/, "");
+}
+function toWindsurf(content) {
+  const stripped = stripMarkers(content);
+  return `# Windsurf Rules
+# Exported from ai-kit CLAUDE.md
+
+${stripped}`;
+}
+function toAider(content) {
+  const stripped = stripMarkers(content);
+  const indented = stripped.split("\n").map((line) => line.length > 0 ? `  ${line}` : "").join("\n");
+  return `# Aider configuration
+# Exported from ai-kit CLAUDE.md
+
+conventions: |
+${indented}
+`;
+}
+function toCline(content) {
+  const stripped = stripMarkers(content);
+  return `# Cline Rules
+# Exported from ai-kit CLAUDE.md
+
+${stripped}`;
+}
+async function exportCommand(targetPath, options) {
+  const projectDir = path21.resolve(targetPath || process.cwd());
+  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
+  const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
+  logSection("AI Kit \u2014 Export");
+  if (!fileExists(configPath) && !fileExists(claudeMdPath)) {
+    logError("No ai-kit.config.json or CLAUDE.md found. Run `ai-kit init` first.");
+    return;
+  }
+  const claudeContent = readFileSafe(claudeMdPath);
+  if (!claudeContent) {
+    logError("Could not read CLAUDE.md. Run `ai-kit init` or `ai-kit update` first.");
+    return;
+  }
+  let format;
+  if (options?.format) {
+    const f = options.format.toLowerCase();
+    if (f === "windsurf" || f === "aider" || f === "cline" || f === "all") {
+      format = f;
+    } else {
+      logError(`Unknown format "${options.format}". Use: windsurf, aider, cline, or all.`);
+      return;
+    }
+  } else {
+    format = await select2({
+      message: "Which format do you want to export to?",
+      choices: [
+        { name: "Windsurf (.windsurfrules)", value: "windsurf" },
+        { name: "Aider (.aider.conf.yml)", value: "aider" },
+        { name: "Cline (.clinerules)", value: "cline" },
+        { name: "All of the above", value: "all" }
+      ]
+    });
+  }
+  const formats = format === "all" ? ["windsurf", "aider", "cline"] : [format];
+  const spinner = ora6("Exporting rules to other AI tools...").start();
+  const transformers = {
+    windsurf: toWindsurf,
+    aider: toAider,
+    cline: toCline
+  };
+  let exported = 0;
+  for (const fmt2 of formats) {
+    const target = EXPORT_TARGETS[fmt2];
+    const transformer = transformers[fmt2];
+    const outputPath = path21.join(projectDir, target.file);
+    const transformed = transformer(claudeContent);
+    await fs11.writeFile(outputPath, transformed, "utf-8");
+    exported++;
+  }
+  spinner.succeed("Export complete");
+  console.log("");
+  for (const fmt2 of formats) {
+    const target = EXPORT_TARGETS[fmt2];
+    logSuccess(`${target.file} generated (${target.label})`);
+  }
+  console.log("");
+  logInfo(
+    `${exported} file${exported !== 1 ? "s" : ""} exported. These contain the same rules as your CLAUDE.md.`
+  );
+}
+
+// src/commands/stats.ts
+import path22 from "path";
+import chalk5 from "chalk";
+var SKILL_CATEGORIES = {
+  "Getting Started": ["prompt-help", "understand"],
+  "Building": [
+    "new-component",
+    "new-page",
+    "api-route",
+    "error-boundary",
+    "extract-hook",
+    "figma-to-code",
+    "design-tokens"
+  ],
+  "Quality & Review": [
+    "review",
+    "test",
+    "accessibility-audit",
+    "security-check",
+    "responsive-check",
+    "type-fix",
+    "pre-pr"
+  ],
+  "Maintenance": [
+    "optimize",
+    "refactor",
+    "dep-check",
+    "bundle-check",
+    "migrate",
+    "env-setup"
+  ],
+  "Workflow": ["fix-bug", "commit-msg", "document", "token-tips"]
+};
+function getComplexityLabel(score) {
+  if (score >= 10) return "Enterprise";
+  if (score >= 7) return "Complex";
+  if (score >= 4) return "Moderate";
+  return "Simple";
+}
+function calculateComplexity(config) {
+  const scan = config.scanResult;
+  let score = 0;
+  const items = [];
+  const hasFramework = scan.framework !== "unknown";
+  if (hasFramework) score += 1;
+  const frameworkLabel = scan.framework === "nextjs" ? `Next.js ${scan.nextjsVersion || ""} (${scan.routerType === "app" ? "App Router" : scan.routerType === "pages" ? "Pages Router" : "Hybrid"})` : scan.framework === "react" ? "React" : "Unknown";
+  items.push({ label: frameworkLabel.trim(), active: hasFramework });
+  const hasCms = scan.cms !== "none";
+  if (hasCms) score += 2;
+  const cmsLabel = scan.cms === "sitecore-xmc" ? "Sitecore XM Cloud" : scan.cms === "sitecore-jss" ? "Sitecore JSS" : "CMS";
+  items.push({ label: cmsLabel, active: hasCms });
+  if (scan.typescript) score += 1;
+  items.push({
+    label: `TypeScript${scan.typescriptStrict ? " (strict)" : ""}`,
+    active: scan.typescript
+  });
+  for (const style of scan.styling) {
+    score += 1;
+    const styleLabel = style === "tailwind" ? `Tailwind CSS${scan.tailwindVersion ? ` v${scan.tailwindVersion}` : ""}` : style === "css-modules" ? "CSS Modules" : style === "styled-components" ? "Styled Components" : style === "scss" ? "SCSS" : style;
+    items.push({ label: styleLabel, active: true });
+  }
+  items.push({
+    label: scan.monorepo ? `Monorepo (${scan.monorepoTool || "detected"})` : "Monorepo",
+    active: scan.monorepo
+  });
+  if (scan.monorepo) score += 2;
+  items.push({ label: "Figma", active: scan.figma.detected });
+  if (scan.figma.detected) score += 1;
+  return { score, items };
+}
+function categorizeSkills(skills) {
+  const result = {};
+  const categorized = /* @__PURE__ */ new Set();
+  for (const [category, categorySkills] of Object.entries(SKILL_CATEGORIES)) {
+    const matched = skills.filter((s) => categorySkills.includes(s));
+    if (matched.length > 0) {
+      result[category] = matched;
+      matched.forEach((s) => categorized.add(s));
+    }
+  }
+  const uncategorized = skills.filter((s) => !categorized.has(s));
+  if (uncategorized.length > 0) {
+    result["Other"] = uncategorized;
+  }
+  return result;
+}
+var TOOL_DISPLAY_NAMES = {
+  playwright: "Playwright",
+  storybook: "Storybook",
+  eslint: "ESLint",
+  prettier: "Prettier",
+  axeCore: "axe-core",
+  snyk: "Snyk",
+  knip: "Knip",
+  bundleAnalyzer: "Bundle Analyzer"
+};
+var MCP_DISPLAY_NAMES = {
+  playwright: "Playwright",
+  figma: "Figma",
+  github: "GitHub",
+  context7: "Context7",
+  perplexity: "Perplexity"
+};
+async function statsCommand(targetPath) {
+  const projectDir = path22.resolve(targetPath || process.cwd());
+  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
+  logSection("AI Kit \u2014 Project Stats");
+  console.log("");
+  if (!fileExists(configPath)) {
+    logWarning(
+      "ai-kit.config.json not found. Run `ai-kit init` first."
+    );
+    return;
+  }
+  const config = readJsonSafe(configPath);
+  if (!config) {
+    logWarning(
+      "ai-kit.config.json is corrupted or unreadable. Run `ai-kit init` to re-initialize."
+    );
+    return;
+  }
+  const scan = config.scanResult;
+  console.log(`  Project:         ${chalk5.bold(scan.projectName)}`);
+  console.log(`  Version:         ai-kit v${config.version}`);
+  console.log(`  Generated:       ${config.generatedAt}`);
+  console.log(`  Package Manager: ${scan.packageManager}`);
+  console.log("");
+  const { score, items } = calculateComplexity(config);
+  const label = getComplexityLabel(score);
+  const maxScore = 10;
+  console.log(
+    `  ${chalk5.bold("Stack Complexity:")} ${score}/${maxScore} (${label})`
+  );
+  for (const item of items) {
+    if (item.active) {
+      console.log(`    ${chalk5.green("\u2713")} ${item.label}`);
+    } else {
+      console.log(`    ${chalk5.gray("\u2717")} ${chalk5.gray(item.label)}`);
+    }
+  }
+  console.log("");
+  const activeFragments = (config.templates || []).filter(
+    (t) => TEMPLATE_FRAGMENTS.includes(t)
+  );
+  const fragmentCount = activeFragments.length;
+  console.log(
+    `  ${chalk5.bold("Active Rules:")} ${fragmentCount} template fragment${fragmentCount !== 1 ? "s" : ""}`
+  );
+  if (fragmentCount > 0) {
+    console.log(`    ${activeFragments.join(", ")}`);
+  }
+  console.log("");
+  const skills = config.commands || [];
+  const totalSkills = skills.length;
+  const categorized = categorizeSkills(skills);
+  console.log(`  ${chalk5.bold("Skills:")} ${totalSkills} total`);
+  for (const [category, categorySkills] of Object.entries(categorized)) {
+    console.log(`    ${category}: ${categorySkills.length}`);
+  }
+  console.log("");
+  console.log(`  ${chalk5.bold("Tools:")}`);
+  const toolEntries = Object.entries(scan.tools);
+  const detectedTools = [];
+  const missingTools = [];
+  for (const [key, detected] of toolEntries) {
+    const displayName = TOOL_DISPLAY_NAMES[key] || key;
+    if (detected) {
+      detectedTools.push(`${chalk5.green("\u2713")} ${displayName}`);
+    } else {
+      missingTools.push(`${chalk5.yellow("\u2717")} ${displayName}`);
+    }
+  }
+  const allToolItems = [...detectedTools, ...missingTools];
+  for (let i = 0; i < allToolItems.length; i += 3) {
+    const row = allToolItems.slice(i, i + 3).map((item) => item.padEnd(22)).join("");
+    console.log(`    ${row}`);
+  }
+  console.log("");
+  console.log(`  ${chalk5.bold("MCP Servers:")}`);
+  const mcpEntries = Object.entries(scan.mcpServers);
+  const configuredMcps = [];
+  const missingMcps = [];
+  for (const [key, configured] of mcpEntries) {
+    const displayName = MCP_DISPLAY_NAMES[key] || key;
+    if (configured) {
+      configuredMcps.push(`${chalk5.green("\u2713")} ${displayName}`);
+    } else {
+      missingMcps.push(`${chalk5.yellow("\u2717")} ${displayName}`);
+    }
+  }
+  const allMcpItems = [...configuredMcps, ...missingMcps];
+  for (let i = 0; i < allMcpItems.length; i += 3) {
+    const row = allMcpItems.slice(i, i + 3).map((item) => item.padEnd(22)).join("");
+    console.log(`    ${row}`);
+  }
+  console.log("");
+}
+
 // src/index.ts
 var program = new Command();
 program.name("ai-kit").description(
@@ -1410,7 +2383,7 @@ program.command("reset").description("Remove all AI Kit generated files").argume
     process.exit(1);
   }
 });
-program.command("tokens").description("Show token usage summary and cost estimates").option("--export", "Export data and open HTML dashboard").action(async (opts) => {
+program.command("tokens").description("Show token usage summary and cost estimates").option("--export", "Export data and open HTML dashboard").option("--csv", "Export daily usage to CSV file").option("--budget <amount>", "Monthly budget in USD (default: $20)", parseFloat).action(async (opts) => {
   try {
     await tokensCommand(opts);
   } catch (err) {
@@ -1421,5 +2394,49 @@ program.command("tokens").description("Show token usage summary and cost estimat
     process.exit(1);
   }
 });
+program.command("doctor").description("Diagnose AI Kit setup and check for issues").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await doctorCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("diff").description("Show what would change on update (dry run)").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await diffCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("export").description("Export rules to other AI tools (Windsurf, Aider, Cline)").argument("[path]", "Project directory (defaults to current directory)").option("--format <format>", "Export format: windsurf, aider, cline, or all").action(async (targetPath, opts) => {
+  try {
+    await exportCommand(targetPath, opts);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("stats").description("Show project setup statistics and complexity").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await statsCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map