@mikulgohil/ai-kit 1.4.0 → 1.5.0

package/dist/index.js

@@ -15,7 +15,7 @@ var GUIDES_DIR = path.join(PACKAGE_ROOT, "guides");
 var DOCS_SCAFFOLDS_DIR = path.join(PACKAGE_ROOT, "docs-scaffolds");
 var AGENTS_DIR = path.join(PACKAGE_ROOT, "agents");
 var CONTEXTS_DIR = path.join(PACKAGE_ROOT, "contexts");
-var VERSION = "1.4.0";
+var VERSION = "1.5.0";
 var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
 var GENERATED_FILES = {
   claudeMd: "CLAUDE.md",
@@ -37,17 +37,18 @@ var TEMPLATE_FRAGMENTS = [
   "tailwind",
   "typescript",
   "monorepo",
-  "figma"
+  "figma",
+  "static-site"
 ];
 
 // src/commands/init.ts
-import path17 from "path";
-import fs8 from "fs-extra";
-import { select, confirm } from "@inquirer/prompts";
+import path20 from "path";
+import fs9 from "fs-extra";
+import { select } from "@inquirer/prompts";
 import ora from "ora";
 
 // src/scanner/index.ts
-import path10 from "path";
+import path13 from "path";
 
 // src/utils.ts
 import fs from "fs-extra";
@@ -423,12 +424,289 @@ function detectMcpServers(projectPath) {
   };
 }
 
+// src/scanner/design-tokens.ts
+import path10 from "path";
+function detectDesignTokens2(projectPath) {
+  const globalsCss = readFileSafe(
+    path10.join(projectPath, "src", "app", "globals.css")
+  );
+  if (globalsCss && globalsCss.includes("@theme")) {
+    return parseThemeInline(globalsCss);
+  }
+  const twConfigPaths = [
+    path10.join(projectPath, "tailwind.config.ts"),
+    path10.join(projectPath, "tailwind.config.js"),
+    path10.join(projectPath, "tailwind.config.mjs")
+  ];
+  for (const twPath of twConfigPaths) {
+    const content = readFileSafe(twPath);
+    if (content) {
+      return parseTailwindConfig(content);
+    }
+  }
+  if (globalsCss) {
+    return parseCssVariables(globalsCss);
+  }
+  return {
+    detected: false,
+    colors: [],
+    spacing: [],
+    fonts: [],
+    breakpoints: [],
+    source: "none"
+  };
+}
+function parseThemeInline(css) {
+  const colors = [];
+  const spacing = [];
+  const fonts = [];
+  const breakpoints = [];
+  const themeMatch = css.match(/@theme\s*\{([\s\S]*?)\}/);
+  if (!themeMatch) {
+    return { detected: false, colors: [], spacing: [], fonts: [], breakpoints: [], source: "none" };
+  }
+  const themeBody = themeMatch[1];
+  const lines = themeBody.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("/*")) continue;
+    const colorMatch = trimmed.match(/^--color-([^:]+):/);
+    if (colorMatch) {
+      colors.push(colorMatch[1].trim());
+      continue;
+    }
+    const spacingMatch = trimmed.match(/^--spacing-([^:]+):/);
+    if (spacingMatch) {
+      spacing.push(spacingMatch[1].trim());
+      continue;
+    }
+    const fontMatch = trimmed.match(/^--font-([^:]+):/);
+    if (fontMatch) {
+      fonts.push(fontMatch[1].trim());
+      continue;
+    }
+    const bpMatch = trimmed.match(/^--breakpoint-([^:]+):/);
+    if (bpMatch) {
+      breakpoints.push(bpMatch[1].trim());
+      continue;
+    }
+  }
+  return {
+    detected: colors.length > 0 || fonts.length > 0,
+    colors,
+    spacing,
+    fonts,
+    breakpoints,
+    source: "theme-inline"
+  };
+}
+function parseTailwindConfig(content) {
+  const colors = [];
+  const spacing = [];
+  const fonts = [];
+  const breakpoints = [];
+  const colorBlock = content.match(/colors\s*:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/);
+  if (colorBlock) {
+    const colorKeys = colorBlock[1].matchAll(/['"]?(\w[\w-]*)['"]?\s*:/g);
+    for (const match of colorKeys) {
+      if (!["DEFAULT", "transparent", "current", "inherit"].includes(match[1])) {
+        colors.push(match[1]);
+      }
+    }
+  }
+  const fontBlock = content.match(/fontFamily\s*:\s*\{([^}]*)\}/);
+  if (fontBlock) {
+    const fontKeys = fontBlock[1].matchAll(/['"]?(\w[\w-]*)['"]?\s*:/g);
+    for (const match of fontKeys) {
+      fonts.push(match[1]);
+    }
+  }
+  const spacingBlock = content.match(/spacing\s*:\s*\{([^}]*)\}/);
+  if (spacingBlock) {
+    const spacingKeys = spacingBlock[1].matchAll(/['"]?(\w[\w-]*)['"]?\s*:/g);
+    for (const match of spacingKeys) {
+      spacing.push(match[1]);
+    }
+  }
+  const screensBlock = content.match(/screens\s*:\s*\{([^}]*)\}/);
+  if (screensBlock) {
+    const bpKeys = screensBlock[1].matchAll(/['"]?(\w[\w-]*)['"]?\s*:/g);
+    for (const match of bpKeys) {
+      breakpoints.push(match[1]);
+    }
+  }
+  return {
+    detected: colors.length > 0 || fonts.length > 0,
+    colors: [...new Set(colors)],
+    spacing: [...new Set(spacing)],
+    fonts: [...new Set(fonts)],
+    breakpoints: [...new Set(breakpoints)],
+    source: "tailwind-config"
+  };
+}
+function parseCssVariables(css) {
+  const colors = [];
+  const spacing = [];
+  const fonts = [];
+  const varMatches = css.matchAll(/--([^:]+)\s*:/g);
+  for (const match of varMatches) {
+    const name = match[1].trim();
+    if (name.startsWith("color-") || name.includes("primary") || name.includes("secondary") || name.includes("accent") || name.includes("background") || name.includes("foreground")) {
+      colors.push(name);
+    } else if (name.startsWith("spacing-") || name.startsWith("space-") || name.includes("gap")) {
+      spacing.push(name);
+    } else if (name.startsWith("font-") || name.includes("family") || name.includes("text-")) {
+      fonts.push(name);
+    }
+  }
+  return {
+    detected: colors.length > 0,
+    colors: [...new Set(colors)],
+    spacing: [...new Set(spacing)],
+    fonts: [...new Set(fonts)],
+    breakpoints: [],
+    source: colors.length > 0 ? "css-variables" : "none"
+  };
+}
+
+// src/scanner/static-site.ts
+import path11 from "path";
+import fs2 from "fs-extra";
+function detectStaticSite(projectPath, pkg) {
+  const hasStaticExport = checkStaticExport(projectPath);
+  const hasGenerateStaticParams = checkGenerateStaticParams(projectPath);
+  const hasRevalidate = checkRevalidatePatterns(projectPath);
+  const hasServerActions = checkServerActions(projectPath);
+  const hasApiRoutes = checkApiRoutes(projectPath);
+  let outputMode;
+  if (hasStaticExport) {
+    outputMode = "export";
+  } else if (hasGenerateStaticParams && !hasServerActions && !hasApiRoutes) {
+    outputMode = hasRevalidate ? "isr" : "export";
+  } else if (hasServerActions || hasApiRoutes) {
+    outputMode = hasGenerateStaticParams ? "hybrid" : "ssr";
+  } else {
+    outputMode = "ssr";
+  }
+  const isStatic = outputMode === "export" || outputMode === "isr";
+  return {
+    isStatic,
+    outputMode,
+    hasGenerateStaticParams,
+    hasRevalidate,
+    hasStaticExport
+  };
+}
+function checkStaticExport(projectPath) {
+  const configPaths = [
+    path11.join(projectPath, "next.config.js"),
+    path11.join(projectPath, "next.config.ts"),
+    path11.join(projectPath, "next.config.mjs")
+  ];
+  for (const configPath of configPaths) {
+    const content = readFileSafe(configPath);
+    if (content && /output\s*:\s*['"]export['"]/.test(content)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkGenerateStaticParams(projectPath) {
+  const appDirs = [
+    path11.join(projectPath, "app"),
+    path11.join(projectPath, "src", "app")
+  ];
+  for (const appDir of appDirs) {
+    if (dirExists(appDir) && hasPatternInDir(appDir, /generateStaticParams/)) {
+      return true;
+    }
+  }
+  const pagesDirs = [
+    path11.join(projectPath, "pages"),
+    path11.join(projectPath, "src", "pages")
+  ];
+  for (const pagesDir of pagesDirs) {
+    if (dirExists(pagesDir) && hasPatternInDir(pagesDir, /getStaticPaths/)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkRevalidatePatterns(projectPath) {
+  const appDirs = [
+    path11.join(projectPath, "app"),
+    path11.join(projectPath, "src", "app")
+  ];
+  for (const appDir of appDirs) {
+    if (dirExists(appDir) && hasPatternInDir(appDir, /revalidate\s*[:=]/)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkServerActions(projectPath) {
+  const srcDirs = [
+    path11.join(projectPath, "app"),
+    path11.join(projectPath, "src")
+  ];
+  for (const srcDir of srcDirs) {
+    if (dirExists(srcDir) && hasPatternInDir(srcDir, /['"]use server['"]/)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkApiRoutes(projectPath) {
+  const appApiDirs = [
+    path11.join(projectPath, "app", "api"),
+    path11.join(projectPath, "src", "app", "api")
+  ];
+  for (const apiDir of appApiDirs) {
+    if (dirExists(apiDir)) return true;
+  }
+  const pagesApiDirs = [
+    path11.join(projectPath, "pages", "api"),
+    path11.join(projectPath, "src", "pages", "api")
+  ];
+  for (const apiDir of pagesApiDirs) {
+    if (dirExists(apiDir)) return true;
+  }
+  return false;
+}
+var SCAN_IGNORE = ["node_modules", ".next", ".git", "dist", "build", ".turbo"];
+function hasPatternInDir(dir, pattern, depth = 0) {
+  if (depth > 5) return false;
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (SCAN_IGNORE.includes(entry.name)) continue;
+      const full = path11.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (hasPatternInDir(full, pattern, depth + 1)) return true;
+      } else if (/\.(tsx?|jsx?|mjs)$/.test(entry.name)) {
+        const content = readFileSafe(full);
+        if (content && pattern.test(content)) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/scanner/aiignore.ts
+import path12 from "path";
+function loadAiIgnorePatterns(projectPath) {
+  const content = readFileSafe(path12.join(projectPath, ".aiignore"));
+  if (!content) return [];
+  return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+
 // src/scanner/index.ts
 async function scanProject(projectPath) {
-  const pkgPath = path10.join(projectPath, "package.json");
+  const pkgPath = path13.join(projectPath, "package.json");
   const pkg = readJsonSafe(pkgPath) || {};
   const scripts = pkg.scripts || {};
-  const projectName = pkg.name || path10.basename(projectPath);
+  const projectName = pkg.name || path13.basename(projectPath);
   const nextjsResult = detectNextjs(projectPath, pkg);
   const sitecoreResult = detectSitecore(pkg);
   const stylingResult = detectStyling(projectPath, pkg);
@@ -438,6 +716,9 @@ async function scanProject(projectPath) {
   const figmaResult = detectFigma(projectPath, pkg);
   const toolsResult = detectTools(projectPath, pkg);
   const mcpResult = detectMcpServers(projectPath);
+  const designTokensResult = detectDesignTokens2(projectPath);
+  const staticSiteResult = detectStaticSite(projectPath, pkg);
+  const aiIgnorePatterns = loadAiIgnorePatterns(projectPath);
   const figmaDetected = figmaResult.figmaMcp || figmaResult.figmaCodeCli || figmaResult.designTokens;
   return {
     ...nextjsResult,
@@ -449,6 +730,9 @@ async function scanProject(projectPath) {
       detected: figmaDetected,
       ...figmaResult
     },
+    designTokens: designTokensResult,
+    staticSite: staticSiteResult,
+    aiIgnorePatterns,
     tools: toolsResult,
     mcpServers: mcpResult,
     packageManager,
@@ -459,10 +743,10 @@ async function scanProject(projectPath) {
 }
 
 // src/generator/assembler.ts
-import path11 from "path";
-import fs2 from "fs-extra";
+import path14 from "path";
+import fs3 from "fs-extra";
 function readTemplate(relativePath) {
-  const fullPath = path11.join(TEMPLATES_DIR, relativePath);
+  const fullPath = path14.join(TEMPLATES_DIR, relativePath);
   const content = readFileSafe(fullPath);
   if (!content) {
     throw new Error(`Template not found: ${relativePath}`);
@@ -470,12 +754,12 @@ function readTemplate(relativePath) {
   return content.trim();
 }
 function loadCustomFragments(projectPath) {
-  const customDir = path11.join(projectPath, ".ai-kit", "fragments");
-  if (!fs2.existsSync(customDir)) return [];
+  const customDir = path14.join(projectPath, ".ai-kit", "fragments");
+  if (!fs3.existsSync(customDir)) return [];
   try {
-    const files = fs2.readdirSync(customDir).filter((f) => f.endsWith(".md"));
+    const files = fs3.readdirSync(customDir).filter((f) => f.endsWith(".md"));
     return files.map((f) => {
-      const content = fs2.readFileSync(path11.join(customDir, f), "utf-8");
+      const content = fs3.readFileSync(path14.join(customDir, f), "utf-8");
       return content.trim();
     }).filter(Boolean);
   } catch {
@@ -548,6 +832,9 @@ function selectFragments(scan) {
   if (scan.figma?.detected) {
     fragments.push("figma");
   }
+  if (scan.staticSite?.isStatic) {
+    fragments.push("static-site");
+  }
   return fragments;
 }
 function generateClaudeMd(scan, options) {
@@ -587,13 +874,34 @@ function buildVariables(scan) {
   const scripts = Object.entries(scan.scripts).filter(
     ([key]) => ["dev", "build", "start", "lint", "test", "type-check", "typecheck"].includes(key)
   ).map(([key, value]) => `- \`${scan.packageManager} run ${key}\` \u2192 \`${value}\``).join("\n");
+  let designTokenSummary = "";
+  if (scan.designTokens?.detected) {
+    const parts = [];
+    if (scan.designTokens.colors.length > 0) {
+      parts.push(`Colors: ${scan.designTokens.colors.slice(0, 15).join(", ")}${scan.designTokens.colors.length > 15 ? ` (+${scan.designTokens.colors.length - 15} more)` : ""}`);
+    }
+    if (scan.designTokens.fonts.length > 0) {
+      parts.push(`Fonts: ${scan.designTokens.fonts.join(", ")}`);
+    }
+    if (scan.designTokens.spacing.length > 0) {
+      parts.push(`Spacing: ${scan.designTokens.spacing.slice(0, 10).join(", ")}${scan.designTokens.spacing.length > 10 ? ` (+${scan.designTokens.spacing.length - 10} more)` : ""}`);
+    }
+    if (scan.designTokens.breakpoints.length > 0) {
+      parts.push(`Breakpoints: ${scan.designTokens.breakpoints.join(", ")}`);
+    }
+    designTokenSummary = parts.map((p) => `- ${p}`).join("\n");
+  }
+  const aiIgnoreSummary = scan.aiIgnorePatterns.length > 0 ? scan.aiIgnorePatterns.map((p) => `- \`${p}\``).join("\n") : "";
   return {
     projectName: scan.projectName,
     techStack: techStack.join(" \xB7 "),
     packageManager: scan.packageManager,
     routerType: scan.routerType || "unknown",
     scripts: scripts || "- No scripts detected",
-    framework: scan.framework
+    framework: scan.framework,
+    designTokens: designTokenSummary || "- No design tokens detected",
+    aiIgnorePatterns: aiIgnoreSummary || "- No .aiignore file",
+    outputMode: scan.staticSite?.outputMode || "ssr"
   };
 }
 
@@ -665,6 +973,10 @@ var MDC_CONFIG = {
   figma: {
     description: "Figma-to-code workflow and design token rules",
     globs: "src/components/**/*.{ts,tsx}, tokens/**/*"
+  },
+  "static-site": {
+    description: "Static site generation (SSG/ISR) rules and patterns",
+    globs: "app/**/*.{ts,tsx}, src/app/**/*.{ts,tsx}, next.config.*"
   }
 };
 function generateMdcFiles(scan) {
@@ -709,7 +1021,8 @@ function generateConfig(scan, templates, commands, guides, options) {
     hooks: options?.hooks || false,
     hookProfile: options?.hookProfile || "standard",
     strictness: options?.strictness || "standard",
-    customFragments: options?.customFragments || []
+    customFragments: options?.customFragments || [],
+    tools: options?.tools || { claude: true, cursor: true }
   };
 }
 
@@ -916,8 +1229,8 @@ function generateSettingsLocal(scan, profile = "standard") {
 }
 
 // src/copier/skills.ts
-import path12 from "path";
-import fs3 from "fs-extra";
+import path15 from "path";
+import fs4 from "fs-extra";
 var AVAILABLE_SKILLS = [
   "prompt-help",
   "review",
@@ -1015,35 +1328,35 @@ var SKILL_DESCRIPTIONS = {
 async function copySkills(targetDir) {
   const copied = [];
   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 src = path15.join(COMMANDS_DIR, `${skill}.md`);
+    if (!await fs4.pathExists(src)) continue;
+    const content = await fs4.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"),
+    const claudeSkillDir = path15.join(targetDir, ".claude", "skills", skill);
+    await fs4.ensureDir(claudeSkillDir);
+    await fs4.writeFile(
+      path15.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"),
+    const cursorSkillDir = path15.join(targetDir, ".cursor", "skills", skill);
+    await fs4.ensureDir(cursorSkillDir);
+    await fs4.writeFile(
+      path15.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 });
+    const legacyDir = path15.join(targetDir, ".claude", "commands");
+    await fs4.ensureDir(legacyDir);
+    await fs4.copy(src, path15.join(legacyDir, `${skill}.md`), { overwrite: true });
     copied.push(skill);
   }
   return copied;
 }
 
 // src/copier/guides.ts
-import path13 from "path";
-import fs4 from "fs-extra";
+import path16 from "path";
+import fs5 from "fs-extra";
 var AVAILABLE_GUIDES = [
   "getting-started",
   "prompt-playbook",
@@ -1053,14 +1366,14 @@ var AVAILABLE_GUIDES = [
   "hooks-and-agents"
 ];
 async function copyGuides(targetDir) {
-  const guidesTarget = path13.join(targetDir, "ai-kit", "guides");
-  await fs4.ensureDir(guidesTarget);
+  const guidesTarget = path16.join(targetDir, "ai-kit", "guides");
+  await fs5.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 fs4.pathExists(src)) {
-      await fs4.copy(src, dest, { overwrite: true });
+    const src = path16.join(GUIDES_DIR, `${guide}.md`);
+    const dest = path16.join(guidesTarget, `${guide}.md`);
+    if (await fs5.pathExists(src)) {
+      await fs5.copy(src, dest, { overwrite: true });
       copied.push(guide);
     }
   }
@@ -1068,21 +1381,21 @@ async function copyGuides(targetDir) {
 }
 
 // src/copier/docs.ts
-import path14 from "path";
-import fs5 from "fs-extra";
+import path17 from "path";
+import fs6 from "fs-extra";
 var DOC_SCAFFOLDS = ["mistakes-log", "decisions-log", "time-log"];
 async function scaffoldDocs(targetDir) {
-  const docsTarget = path14.join(targetDir, "docs");
-  await fs5.ensureDir(docsTarget);
+  const docsTarget = path17.join(targetDir, "docs");
+  await fs6.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 fs5.pathExists(dest)) {
+    const src = path17.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
+    const dest = path17.join(docsTarget, `${doc}.md`);
+    if (await fs6.pathExists(dest)) {
       continue;
     }
-    if (await fs5.pathExists(src)) {
-      await fs5.copy(src, dest);
+    if (await fs6.pathExists(src)) {
+      await fs6.copy(src, dest);
       created.push(doc);
     }
   }
@@ -1090,8 +1403,8 @@ async function scaffoldDocs(targetDir) {
 }
 
 // src/copier/agents.ts
-import path15 from "path";
-import fs6 from "fs-extra";
+import path18 from "path";
+import fs7 from "fs-extra";
 var UNIVERSAL_AGENTS = [
   "planner",
   "code-reviewer",
@@ -1116,22 +1429,22 @@ var CONDITIONAL_AGENTS = [
   }
 ];
 async function copyAgents(targetDir, scan) {
-  const agentsTarget = path15.join(targetDir, ".claude", "agents");
-  await fs6.ensureDir(agentsTarget);
+  const agentsTarget = path18.join(targetDir, ".claude", "agents");
+  await fs7.ensureDir(agentsTarget);
   const copied = [];
   for (const agent of UNIVERSAL_AGENTS) {
-    const src = path15.join(AGENTS_DIR, `${agent}.md`);
-    if (!await fs6.pathExists(src)) continue;
-    await fs6.copy(src, path15.join(agentsTarget, `${agent}.md`), {
+    const src = path18.join(AGENTS_DIR, `${agent}.md`);
+    if (!await fs7.pathExists(src)) continue;
+    await fs7.copy(src, path18.join(agentsTarget, `${agent}.md`), {
       overwrite: true
     });
     copied.push(agent);
   }
   for (const { name, condition } of CONDITIONAL_AGENTS) {
     if (!condition(scan)) continue;
-    const src = path15.join(AGENTS_DIR, `${name}.md`);
-    if (!await fs6.pathExists(src)) continue;
-    await fs6.copy(src, path15.join(agentsTarget, `${name}.md`), {
+    const src = path18.join(AGENTS_DIR, `${name}.md`);
+    if (!await fs7.pathExists(src)) continue;
+    await fs7.copy(src, path18.join(agentsTarget, `${name}.md`), {
       overwrite: true
     });
     copied.push(name);
@@ -1140,17 +1453,17 @@ async function copyAgents(targetDir, scan) {
 }
 
 // src/copier/contexts.ts
-import path16 from "path";
-import fs7 from "fs-extra";
+import path19 from "path";
+import fs8 from "fs-extra";
 var AVAILABLE_CONTEXTS = ["dev", "review", "research"];
 async function copyContexts(targetDir) {
-  const contextsTarget = path16.join(targetDir, ".claude", "contexts");
-  await fs7.ensureDir(contextsTarget);
+  const contextsTarget = path19.join(targetDir, ".claude", "contexts");
+  await fs8.ensureDir(contextsTarget);
   const copied = [];
   for (const context of AVAILABLE_CONTEXTS) {
-    const src = path16.join(CONTEXTS_DIR, `${context}.md`);
-    if (!await fs7.pathExists(src)) continue;
-    await fs7.copy(src, path16.join(contextsTarget, `${context}.md`), {
+    const src = path19.join(CONTEXTS_DIR, `${context}.md`);
+    if (!await fs8.pathExists(src)) continue;
+    await fs8.copy(src, path19.join(contextsTarget, `${context}.md`), {
       overwrite: true
     });
     copied.push(context);
@@ -1160,18 +1473,36 @@ async function copyContexts(targetDir) {
 
 // src/commands/init.ts
 async function initCommand(targetPath) {
-  const projectDir = path17.resolve(targetPath || process.cwd());
+  const projectDir = path20.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Project Setup");
   logInfo(`Scanning: ${projectDir}`);
-  const configPath = path17.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path20.join(projectDir, AI_KIT_CONFIG_FILE);
+  let savedConfig = null;
+  let reuseMode = false;
   if (fileExists(configPath)) {
-    const overwrite = await confirm({
-      message: "AI Kit is already configured in this project. Re-initialize?",
-      default: false
-    });
-    if (!overwrite) {
-      logInfo("Cancelled. Use `ai-kit update` to refresh configs.");
-      return;
+    savedConfig = readJsonSafe(configPath);
+    if (savedConfig) {
+      logSection("Existing Profile Found");
+      logInfo(`Tools: ${formatToolsLabel(savedConfig.tools)}`);
+      logInfo(`Strictness: ${savedConfig.strictness}`);
+      logInfo(`Hook Profile: ${savedConfig.hookProfile}`);
+      logInfo(`Generated: ${savedConfig.generatedAt}`);
+      logInfo(`Version: v${savedConfig.version}`);
+      console.log("");
+      const action = await select({
+        message: "What would you like to do?",
+        choices: [
+          { name: "Update \u2014 re-scan project, keep saved settings", value: "reuse" },
+          { name: "Re-configure \u2014 change settings from scratch", value: "fresh" },
+          { name: "Cancel", value: "cancel" }
+        ],
+        default: "reuse"
+      });
+      if (action === "cancel") {
+        logInfo("Cancelled.");
+        return;
+      }
+      reuseMode = action === "reuse";
     }
   }
   const spinner = ora("Scanning project...").start();
@@ -1192,13 +1523,24 @@ async function initCommand(targetPath) {
   logInfo(`Monorepo: ${scan.monorepo ? `Yes (${scan.monorepoTool})` : "No"}`);
   logInfo(`Package Manager: ${scan.packageManager}`);
   logInfo(`Formatter: ${scan.tools.biome ? "Biome" : scan.tools.prettier ? "Prettier" : "None detected"}`);
-  const clarifications = await askClarifications(scan);
-  scan = applyClarifications(scan, clarifications);
-  const tools = await selectTools();
-  const strictness = await selectStrictness();
-  const hookProfile = await selectHookProfile();
+  if (scan.staticSite?.isStatic) {
+    logInfo(`Static Site: Yes (${scan.staticSite.outputMode})`);
+  }
+  if (scan.designTokens?.detected) {
+    logInfo(`Design Tokens: ${scan.designTokens.colors.length} colors, ${scan.designTokens.fonts.length} fonts (${scan.designTokens.source})`);
+  }
+  if (scan.aiIgnorePatterns.length > 0) {
+    logInfo(`.aiignore: ${scan.aiIgnorePatterns.length} patterns loaded`);
+  }
+  if (!reuseMode) {
+    const clarifications = await askClarifications(scan);
+    scan = applyClarifications(scan, clarifications);
+  }
+  const tools = reuseMode && savedConfig?.tools ? savedConfig.tools : await selectTools();
+  const strictness = reuseMode && savedConfig?.strictness ? savedConfig.strictness : await selectStrictness();
+  const hookProfile = reuseMode && savedConfig?.hookProfile ? savedConfig.hookProfile : await selectHookProfile();
   const customFragments = loadCustomFragments(projectDir);
-  const conflict = await selectConflictStrategy(projectDir);
+  const conflict = reuseMode ? "overwrite" : await selectConflictStrategy(projectDir);
   logSection("Generating Files");
   const results = await generate(projectDir, scan, tools, conflict, {
     strictness,
@@ -1228,6 +1570,13 @@ async function initCommand(targetPath) {
   logInfo("Run `ai-kit audit` to check your AI agent configuration health.");
   logInfo("Check ai-kit/guides/getting-started.md to get started.");
 }
+function formatToolsLabel(tools) {
+  if (!tools) return "Unknown";
+  if (tools.claude && tools.cursor) return "Claude Code + Cursor";
+  if (tools.claude) return "Claude Code only";
+  if (tools.cursor) return "Cursor only";
+  return "None";
+}
 function formatFramework(scan) {
   if (scan.framework === "nextjs") {
     const version = scan.nextjsVersion ? ` ${scan.nextjsVersion}` : "";
@@ -1304,7 +1653,7 @@ async function selectHookProfile() {
   });
 }
 async function selectConflictStrategy(projectDir) {
-  const hasExisting = fileExists(path17.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path17.join(projectDir, GENERATED_FILES.cursorRules));
+  const hasExisting = fileExists(path20.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path20.join(projectDir, GENERATED_FILES.cursorRules));
   if (!hasExisting) return "overwrite";
   return select({
     message: "Existing AI config files detected. How should we handle conflicts?",
@@ -1334,10 +1683,10 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     docs: []
   };
   if (tools.claude) {
-    const claudeMdPath = path17.join(projectDir, GENERATED_FILES.claudeMd);
+    const claudeMdPath = path20.join(projectDir, GENERATED_FILES.claudeMd);
     if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
       const content = generateClaudeMd(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
-      await fs8.writeFile(claudeMdPath, content, "utf-8");
+      await fs9.writeFile(claudeMdPath, content, "utf-8");
       result.claudeMd = true;
     } else {
       logWarning("CLAUDE.md exists, skipping");
@@ -1346,26 +1695,26 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     result.agents = await copyAgents(projectDir, scan);
     result.contexts = await copyContexts(projectDir);
     const hookProfile = opts?.hookProfile || "standard";
-    const settingsLocalPath = path17.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path20.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs8.ensureDir(path17.dirname(settingsLocalPath));
-    await fs8.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+    await fs9.ensureDir(path20.dirname(settingsLocalPath));
+    await fs9.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     result.hooks = true;
   }
   if (tools.cursor) {
-    const cursorPath = path17.join(projectDir, GENERATED_FILES.cursorRules);
+    const cursorPath = path20.join(projectDir, GENERATED_FILES.cursorRules);
     if (conflict === "overwrite" || !fileExists(cursorPath)) {
       const content = generateCursorRules(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
-      await fs8.writeFile(cursorPath, content, "utf-8");
+      await fs9.writeFile(cursorPath, content, "utf-8");
       result.cursorRules = true;
     } else {
       logWarning(".cursorrules exists, skipping");
     }
-    const mdcDir = path17.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs8.ensureDir(mdcDir);
+    const mdcDir = path20.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs9.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs8.writeFile(path17.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs9.writeFile(path20.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     result.cursorMdcFiles = mdcFiles.length;
   }
@@ -1380,10 +1729,11 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     agents: result.agents,
     contexts: result.contexts,
     hooks: result.hooks,
-    hookProfile: opts?.hookProfile
+    hookProfile: opts?.hookProfile,
+    tools
   });
-  await fs8.writeJson(
-    path17.join(projectDir, AI_KIT_CONFIG_FILE),
+  await fs9.writeJson(
+    path20.join(projectDir, AI_KIT_CONFIG_FILE),
     config,
     { spaces: 2 }
   );
@@ -1459,13 +1809,13 @@ function showRecommendations(scan) {
 }
 
 // src/commands/update.ts
-import path18 from "path";
-import fs9 from "fs-extra";
+import path21 from "path";
+import fs10 from "fs-extra";
 import ora2 from "ora";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function updateCommand(targetPath) {
-  const projectDir = path18.resolve(targetPath || process.cwd());
-  const configPath = path18.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path21.resolve(targetPath || process.cwd());
+  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
     return;
@@ -1493,37 +1843,39 @@ async function updateCommand(targetPath) {
   logSection("Updating Files");
   const strictness = existingConfig.strictness || "standard";
   const hookProfile = existingConfig.hookProfile || "standard";
+  const tools = existingConfig.tools || { claude: true, cursor: true };
   const customFragments = loadCustomFragments(projectDir);
   const genOpts = { strictness, customFragments };
+  logInfo(`Using saved profile \u2014 Tools: ${tools.claude && tools.cursor ? "Claude Code + Cursor" : tools.claude ? "Claude Code" : "Cursor"} \xB7 Strictness: ${strictness} \xB7 Hooks: ${hookProfile}`);
   const templates = [];
-  if (existingConfig.templates.includes("CLAUDE.md") || fileExists(path18.join(projectDir, GENERATED_FILES.claudeMd))) {
-    const claudeMdPath = path18.join(projectDir, GENERATED_FILES.claudeMd);
+  if (tools.claude && (existingConfig.templates.includes("CLAUDE.md") || fileExists(path21.join(projectDir, GENERATED_FILES.claudeMd)))) {
+    const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
     const newContent = generateClaudeMd(scan, genOpts);
     const existing = readFileSafe(claudeMdPath);
     if (existing) {
-      await fs9.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs10.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs9.writeFile(claudeMdPath, newContent, "utf-8");
+      await fs10.writeFile(claudeMdPath, newContent, "utf-8");
     }
     templates.push("CLAUDE.md");
     logSuccess("CLAUDE.md updated");
   }
-  if (existingConfig.templates.includes(".cursorrules") || fileExists(path18.join(projectDir, GENERATED_FILES.cursorRules))) {
-    const cursorRulesPath = path18.join(projectDir, GENERATED_FILES.cursorRules);
+  if (tools.cursor && (existingConfig.templates.includes(".cursorrules") || fileExists(path21.join(projectDir, GENERATED_FILES.cursorRules)))) {
+    const cursorRulesPath = path21.join(projectDir, GENERATED_FILES.cursorRules);
     const newContent = generateCursorRules(scan, genOpts);
     const existing = readFileSafe(cursorRulesPath);
     if (existing) {
-      await fs9.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
+      await fs10.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
     } else {
-      await fs9.writeFile(cursorRulesPath, newContent, "utf-8");
+      await fs10.writeFile(cursorRulesPath, newContent, "utf-8");
     }
     templates.push(".cursorrules");
     logSuccess(".cursorrules updated");
-    const mdcDir = path18.join(projectDir, GENERATED_FILES.cursorMdcDir);
-    await fs9.ensureDir(mdcDir);
+    const mdcDir = path21.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs10.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs9.writeFile(path18.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs10.writeFile(path21.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
   }
@@ -1534,10 +1886,10 @@ async function updateCommand(targetPath) {
   const contexts = await copyContexts(projectDir);
   logSuccess(`${contexts.length} context modes updated (.claude/contexts/)`);
   if (existingConfig.hooks !== false) {
-    const settingsLocalPath = path18.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path21.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs9.ensureDir(path18.dirname(settingsLocalPath));
-    await fs9.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+    await fs10.ensureDir(path21.dirname(settingsLocalPath));
+    await fs10.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     logSuccess(`Hooks updated (profile: ${hookProfile})`);
   }
   const guides = await copyGuides(projectDir);
@@ -1547,20 +1899,21 @@ async function updateCommand(targetPath) {
     agents,
     contexts,
     hooks: existingConfig.hooks !== false,
-    hookProfile
+    hookProfile,
+    tools
   });
-  await fs9.writeJson(configPath, config, { spaces: 2 });
+  await fs10.writeJson(configPath, config, { spaces: 2 });
   logSuccess("ai-kit.config.json updated");
   console.log("");
   logInfo("All AI configs refreshed with latest project scan.");
 }
 
 // src/commands/reset.ts
-import path19 from "path";
-import fs10 from "fs-extra";
+import path22 from "path";
+import fs11 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function resetCommand(targetPath) {
-  const projectDir = path19.resolve(targetPath || process.cwd());
+  const projectDir = path22.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Reset");
   logWarning("This will remove all AI Kit generated files:");
   logInfo(`  - ${GENERATED_FILES.claudeMd}`);
@@ -1569,7 +1922,7 @@ async function resetCommand(targetPath) {
   logInfo(`  - ${GENERATED_FILES.claudeCommands}/`);
   logInfo(`  - ${GENERATED_FILES.claudeSkills}/`);
   logInfo(`  - ${GENERATED_FILES.cursorSkills}/`);
-  logInfo(`  - ai-kit/`);
+  logInfo(`  - ai-kit/ (includes component-registry, patterns, guides)`);
   logInfo(`  - ${AI_KIT_CONFIG_FILE}`);
   console.log("");
   const proceed = await confirm3({
@@ -1581,44 +1934,44 @@ async function resetCommand(targetPath) {
     return;
   }
   const removed = [];
-  const claudeMdPath = path19.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path22.join(projectDir, GENERATED_FILES.claudeMd);
   if (fileExists(claudeMdPath)) {
-    await fs10.remove(claudeMdPath);
+    await fs11.remove(claudeMdPath);
     removed.push(GENERATED_FILES.claudeMd);
   }
-  const cursorPath = path19.join(projectDir, GENERATED_FILES.cursorRules);
+  const cursorPath = path22.join(projectDir, GENERATED_FILES.cursorRules);
   if (fileExists(cursorPath)) {
-    await fs10.remove(cursorPath);
+    await fs11.remove(cursorPath);
     removed.push(GENERATED_FILES.cursorRules);
   }
-  const cursorMdcDir = path19.join(projectDir, GENERATED_FILES.cursorMdcDir);
+  const cursorMdcDir = path22.join(projectDir, GENERATED_FILES.cursorMdcDir);
   if (fileExists(cursorMdcDir)) {
-    await fs10.remove(cursorMdcDir);
+    await fs11.remove(cursorMdcDir);
     removed.push(GENERATED_FILES.cursorMdcDir);
   }
-  const commandsDir = path19.join(projectDir, GENERATED_FILES.claudeCommands);
+  const commandsDir = path22.join(projectDir, GENERATED_FILES.claudeCommands);
   if (fileExists(commandsDir)) {
-    await fs10.remove(commandsDir);
+    await fs11.remove(commandsDir);
     removed.push(GENERATED_FILES.claudeCommands);
   }
-  const claudeSkillsDir = path19.join(projectDir, GENERATED_FILES.claudeSkills);
+  const claudeSkillsDir = path22.join(projectDir, GENERATED_FILES.claudeSkills);
   if (fileExists(claudeSkillsDir)) {
-    await fs10.remove(claudeSkillsDir);
+    await fs11.remove(claudeSkillsDir);
     removed.push(GENERATED_FILES.claudeSkills);
   }
-  const cursorSkillsDir = path19.join(projectDir, GENERATED_FILES.cursorSkills);
+  const cursorSkillsDir = path22.join(projectDir, GENERATED_FILES.cursorSkills);
   if (fileExists(cursorSkillsDir)) {
-    await fs10.remove(cursorSkillsDir);
+    await fs11.remove(cursorSkillsDir);
     removed.push(GENERATED_FILES.cursorSkills);
   }
-  const aiKitDir = path19.join(projectDir, "ai-kit");
+  const aiKitDir = path22.join(projectDir, "ai-kit");
   if (fileExists(aiKitDir)) {
-    await fs10.remove(aiKitDir);
+    await fs11.remove(aiKitDir);
     removed.push("ai-kit/");
   }
-  const configPath = path19.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
-    await fs10.remove(configPath);
+    await fs11.remove(configPath);
     removed.push(AI_KIT_CONFIG_FILE);
   }
   logSection("Reset Complete");
@@ -1630,8 +1983,8 @@ async function resetCommand(targetPath) {
 }
 
 // src/commands/tokens.ts
-import path20 from "path";
-import fs11 from "fs-extra";
+import path23 from "path";
+import fs12 from "fs-extra";
 import chalk2 from "chalk";
 import ora3 from "ora";
 import os from "os";
@@ -1641,14 +1994,14 @@ var PRICING = {
 };
 var PLAN_BUDGET = 20;
 function findSessionFiles() {
-  const claudeDir = path20.join(os.homedir(), ".claude", "projects");
-  if (!fs11.existsSync(claudeDir)) return [];
+  const claudeDir = path23.join(os.homedir(), ".claude", "projects");
+  if (!fs12.existsSync(claudeDir)) return [];
   const files = [];
   function walkDir(dir) {
     try {
-      const entries = fs11.readdirSync(dir, { withFileTypes: true });
+      const entries = fs12.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path20.join(dir, entry.name);
+        const full = path23.join(dir, entry.name);
         if (entry.isDirectory()) {
           walkDir(full);
         } else if (entry.name.endsWith(".jsonl")) {
@@ -1663,7 +2016,7 @@ function findSessionFiles() {
 }
 function parseSessionFile(filePath) {
   try {
-    const content = fs11.readFileSync(filePath, "utf-8");
+    const content = fs12.readFileSync(filePath, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     const usage = {
       inputTokens: 0,
@@ -1700,11 +2053,11 @@ function parseSessionFile(filePath) {
     }
     if (usage.inputTokens === 0 && usage.outputTokens === 0) return null;
     if (!sessionDate) {
-      const stat = fs11.statSync(filePath);
+      const stat = fs12.statSync(filePath);
       sessionDate = stat.mtime.toISOString().slice(0, 10);
     }
-    const sessionId = path20.basename(filePath, ".jsonl");
-    const projectName = path20.basename(path20.dirname(filePath));
+    const sessionId = path23.basename(filePath, ".jsonl");
+    const projectName = path23.basename(path23.dirname(filePath));
     return {
       sessionId,
       filePath,
@@ -1933,13 +2286,13 @@ ${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
   );
   console.log("");
   if (options.csv) {
-    const csvPath = path20.join(process.cwd(), "token-usage.csv");
+    const csvPath = path23.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 fs11.writeFile(csvPath, csvHeader + csvRows, "utf-8");
+    await fs12.writeFile(csvPath, csvHeader + csvRows, "utf-8");
     logSuccess(`CSV exported to ${csvPath}`);
   }
   if (options.export) {
@@ -1976,13 +2329,13 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
     }
   };
   const outputDir = process.cwd();
-  const dataPath = path20.join(outputDir, "token-data.json");
-  const dashboardSrc = path20.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
-  const dashboardDest = path20.join(outputDir, "token-dashboard.html");
-  await fs11.writeJson(dataPath, exportData, { spaces: 2 });
+  const dataPath = path23.join(outputDir, "token-data.json");
+  const dashboardSrc = path23.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
+  const dashboardDest = path23.join(outputDir, "token-dashboard.html");
+  await fs12.writeJson(dataPath, exportData, { spaces: 2 });
   logInfo(`Token data written to ${dataPath}`);
-  if (await fs11.pathExists(dashboardSrc)) {
-    await fs11.copy(dashboardSrc, dashboardDest, { overwrite: true });
+  if (await fs12.pathExists(dashboardSrc)) {
+    await fs12.copy(dashboardSrc, dashboardDest, { overwrite: true });
     logInfo(`Dashboard copied to ${dashboardDest}`);
   } else {
     logWarning("Dashboard template not found. Skipping HTML export.");
@@ -1999,12 +2352,12 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
 }
 
 // src/commands/doctor.ts
-import path21 from "path";
+import path24 from "path";
 import chalk3 from "chalk";
 import ora4 from "ora";
 async function doctorCommand(targetPath) {
-  const projectDir = path21.resolve(targetPath || process.cwd());
-  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path24.resolve(targetPath || process.cwd());
+  const configPath = path24.join(projectDir, AI_KIT_CONFIG_FILE);
   let passed = 0;
   let warnings = 0;
   let issues = 0;
@@ -2036,7 +2389,7 @@ async function doctorCommand(targetPath) {
   }
   for (const template of config.templates) {
     const templateFile = template === "CLAUDE.md" ? GENERATED_FILES.claudeMd : template === ".cursorrules" ? GENERATED_FILES.cursorRules : template;
-    const templatePath = path21.join(projectDir, templateFile);
+    const templatePath = path24.join(projectDir, templateFile);
     if (fileExists(templatePath)) {
       logSuccess(`${template} exists and in sync`);
       passed++;
@@ -2047,8 +2400,8 @@ async function doctorCommand(targetPath) {
   }
   const missingSkills = [];
   for (const skill of config.commands) {
-    const claudeSkillPath = path21.join(projectDir, GENERATED_FILES.claudeSkills, skill);
-    const cursorSkillPath = path21.join(projectDir, GENERATED_FILES.cursorSkills, skill);
+    const claudeSkillPath = path24.join(projectDir, GENERATED_FILES.claudeSkills, skill);
+    const cursorSkillPath = path24.join(projectDir, GENERATED_FILES.cursorSkills, skill);
     if (!fileExists(claudeSkillPath) && !fileExists(cursorSkillPath)) {
       missingSkills.push(skill);
     }
@@ -2062,10 +2415,10 @@ async function doctorCommand(targetPath) {
     );
     issues++;
   }
-  const guidesDir = path21.join(projectDir, "ai-kit", "guides");
+  const guidesDir = path24.join(projectDir, "ai-kit", "guides");
   const missingGuides = [];
   for (const guide of config.guides) {
-    const guidePath = path21.join(guidesDir, guide);
+    const guidePath = path24.join(guidesDir, guide);
     if (!fileExists(guidePath)) {
       missingGuides.push(guide);
     }
@@ -2203,13 +2556,13 @@ function compareScanResults(previous, current) {
 }
 
 // src/commands/diff.ts
-import path22 from "path";
-import fs12 from "fs-extra";
+import path25 from "path";
+import fs13 from "fs-extra";
 import chalk4 from "chalk";
 import ora5 from "ora";
 async function diffCommand(targetPath) {
-  const projectDir = path22.resolve(targetPath || process.cwd());
-  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path25.resolve(targetPath || process.cwd());
+  const configPath = path25.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.");
@@ -2276,11 +2629,11 @@ async function diffCommand(targetPath) {
   if (cursorRulesStatus.status === "modified") modified++;
   else if (cursorRulesStatus.status === "added") added++;
   else unchanged++;
-  const skillsDir = path22.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path25.join(projectDir, GENERATED_FILES.claudeSkills);
   const skillCount = countFilesInDir(skillsDir);
   console.log(chalk4.dim(`  unchanged ${GENERATED_FILES.claudeSkills}/ (${skillCount} skills)`));
   unchanged++;
-  const guidesDir = path22.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
+  const guidesDir = path25.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
   const guideCount = existingConfig.guides?.length || 0;
   console.log(chalk4.dim(`  unchanged ai-kit/guides/ (${guideCount} guides)`));
   unchanged++;
@@ -2389,7 +2742,7 @@ function diffStack(oldScan, newScan) {
   return changes;
 }
 function diffGeneratedFile(projectDir, filename, config, generate2, oldFragments, newFragments) {
-  const filePath = path22.join(projectDir, filename);
+  const filePath = path25.join(projectDir, filename);
   const currentContent = readFileSafe(filePath);
   const newContent = generate2();
   if (!currentContent) {
@@ -2426,8 +2779,8 @@ function logFileChange(result) {
 }
 function countFilesInDir(dirPath) {
   try {
-    if (!fs12.existsSync(dirPath)) return 0;
-    const entries = fs12.readdirSync(dirPath);
+    if (!fs13.existsSync(dirPath)) return 0;
+    const entries = fs13.readdirSync(dirPath);
     return entries.filter((e) => !e.startsWith(".")).length;
   } catch {
     return 0;
@@ -2435,8 +2788,8 @@ function countFilesInDir(dirPath) {
 }
 
 // src/commands/export.ts
-import path23 from "path";
-import fs13 from "fs-extra";
+import path26 from "path";
+import fs14 from "fs-extra";
 import ora6 from "ora";
 import { select as select2 } from "@inquirer/prompts";
 var EXPORT_TARGETS = {
@@ -2472,9 +2825,9 @@ function toCline(content) {
 ${stripped}`;
 }
 async function exportCommand(targetPath, options) {
-  const projectDir = path23.resolve(targetPath || process.cwd());
-  const configPath = path23.join(projectDir, AI_KIT_CONFIG_FILE);
-  const claudeMdPath = path23.join(projectDir, GENERATED_FILES.claudeMd);
+  const projectDir = path26.resolve(targetPath || process.cwd());
+  const configPath = path26.join(projectDir, AI_KIT_CONFIG_FILE);
+  const claudeMdPath = path26.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.");
@@ -2516,9 +2869,9 @@ async function exportCommand(targetPath, options) {
   for (const fmt2 of formats) {
     const target = EXPORT_TARGETS[fmt2];
     const transformer = transformers[fmt2];
-    const outputPath = path23.join(projectDir, target.file);
+    const outputPath = path26.join(projectDir, target.file);
     const transformed = transformer(claudeContent);
-    await fs13.writeFile(outputPath, transformed, "utf-8");
+    await fs14.writeFile(outputPath, transformed, "utf-8");
     exported++;
   }
   spinner.succeed("Export complete");
@@ -2534,7 +2887,7 @@ async function exportCommand(targetPath, options) {
 }
 
 // src/commands/stats.ts
-import path24 from "path";
+import path27 from "path";
 import chalk5 from "chalk";
 var SKILL_CATEGORIES = {
   "Getting Started": ["prompt-help", "understand"],
@@ -2637,8 +2990,8 @@ var MCP_DISPLAY_NAMES = {
   perplexity: "Perplexity"
 };
 async function statsCommand(targetPath) {
-  const projectDir = path24.resolve(targetPath || process.cwd());
-  const configPath = path24.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path27.resolve(targetPath || process.cwd());
+  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
   logSection("AI Kit \u2014 Project Stats");
   console.log("");
   if (!fileExists(configPath)) {
@@ -2732,21 +3085,21 @@ async function statsCommand(targetPath) {
 }
 
 // src/commands/audit.ts
-import path25 from "path";
-import fs14 from "fs-extra";
+import path28 from "path";
+import fs15 from "fs-extra";
 import chalk6 from "chalk";
 async function auditCommand(targetPath) {
-  const projectDir = path25.resolve(targetPath || process.cwd());
+  const projectDir = path28.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Security & Configuration Audit");
   logInfo(`Auditing: ${projectDir}`);
   const checks = [];
-  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path28.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
     checks.push({ name: "Config file", status: "pass", message: "ai-kit.config.json found" });
   } else {
     checks.push({ name: "Config file", status: "fail", message: "ai-kit.config.json missing \u2014 run `ai-kit init`" });
   }
-  const claudeMdPath = path25.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path28.join(projectDir, GENERATED_FILES.claudeMd);
   const claudeMd = readFileSafe(claudeMdPath);
   if (claudeMd) {
     if (claudeMd.includes("AI-KIT:START") && claudeMd.includes("AI-KIT:END")) {
@@ -2771,7 +3124,7 @@ async function auditCommand(targetPath) {
       checks.push({ name: "Secrets in CLAUDE.md", status: "pass", message: "No secrets detected" });
     }
   }
-  const settingsLocalPath = path25.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+  const settingsLocalPath = path28.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
   if (fileExists(settingsLocalPath)) {
     const settings2 = readJsonSafe(settingsLocalPath);
     if (settings2?.hooks) {
@@ -2782,14 +3135,14 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Hooks", status: "warn", message: "No hooks configured \u2014 run `ai-kit init` to generate" });
   }
-  const agentsDir = path25.join(projectDir, GENERATED_FILES.claudeAgents);
-  if (await fs14.pathExists(agentsDir)) {
-    const agentFiles = (await fs14.readdir(agentsDir)).filter((f) => f.endsWith(".md"));
+  const agentsDir = path28.join(projectDir, GENERATED_FILES.claudeAgents);
+  if (await fs15.pathExists(agentsDir)) {
+    const agentFiles = (await fs15.readdir(agentsDir)).filter((f) => f.endsWith(".md"));
     if (agentFiles.length > 0) {
       checks.push({ name: "Agents", status: "pass", message: `${agentFiles.length} agent(s) configured` });
       let invalidAgents = 0;
       for (const file of agentFiles) {
-        const content = readFileSafe(path25.join(agentsDir, file));
+        const content = readFileSafe(path28.join(agentsDir, file));
         if (content && !content.startsWith("---")) {
           invalidAgents++;
         }
@@ -2803,18 +3156,18 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Agents", status: "warn", message: "No agents directory \u2014 run `ai-kit init` to generate" });
   }
-  const contextsDir = path25.join(projectDir, GENERATED_FILES.claudeContexts);
-  if (await fs14.pathExists(contextsDir)) {
-    const contextFiles = (await fs14.readdir(contextsDir)).filter((f) => f.endsWith(".md"));
+  const contextsDir = path28.join(projectDir, GENERATED_FILES.claudeContexts);
+  if (await fs15.pathExists(contextsDir)) {
+    const contextFiles = (await fs15.readdir(contextsDir)).filter((f) => f.endsWith(".md"));
     checks.push({ name: "Contexts", status: contextFiles.length > 0 ? "pass" : "warn", message: `${contextFiles.length} context mode(s) available` });
   } else {
     checks.push({ name: "Contexts", status: "warn", message: "No contexts directory" });
   }
-  const skillsDir = path25.join(projectDir, GENERATED_FILES.claudeSkills);
-  if (await fs14.pathExists(skillsDir)) {
-    const skillDirs = (await fs14.readdir(skillsDir)).filter(async (f) => {
+  const skillsDir = path28.join(projectDir, GENERATED_FILES.claudeSkills);
+  if (await fs15.pathExists(skillsDir)) {
+    const skillDirs = (await fs15.readdir(skillsDir)).filter(async (f) => {
       try {
-        return (await fs14.stat(path25.join(skillsDir, f))).isDirectory();
+        return (await fs15.stat(path28.join(skillsDir, f))).isDirectory();
       } catch {
         return false;
       }
@@ -2823,7 +3176,7 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Skills", status: "warn", message: "No skills directory" });
   }
-  const gitignorePath = path25.join(projectDir, ".gitignore");
+  const gitignorePath = path28.join(projectDir, ".gitignore");
   const gitignore = readFileSafe(gitignorePath);
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
@@ -2839,7 +3192,7 @@ async function auditCommand(targetPath) {
       checks.push({ name: "Settings gitignore", status: "warn", message: "settings.local.json not in .gitignore \u2014 may leak local config" });
     }
   }
-  const settingsPath = path25.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path28.join(projectDir, ".claude", "settings.json");
   const settings = readFileSafe(settingsPath);
   if (settings) {
     const hasEnvVarsInSettings = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settings);
@@ -2872,8 +3225,8 @@ async function auditCommand(targetPath) {
 }
 
 // src/commands/health.ts
-import path26 from "path";
-import fs15 from "fs-extra";
+import path29 from "path";
+import fs16 from "fs-extra";
 import chalk7 from "chalk";
 import ora7 from "ora";
 function gradeFromScore(score) {
@@ -2914,7 +3267,7 @@ function checkSetup(projectDir, config) {
       detail: `config v${config.version} \u2260 CLI v${VERSION} \u2014 run \`ai-kit update\``
     });
   }
-  const claudeMd = readFileSafe(path26.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
   if (claudeMd && claudeMd.includes("AI-KIT:START")) {
     checks.push({ name: "CLAUDE.md", status: "pass", detail: "Present with markers" });
   } else if (claudeMd) {
@@ -2922,22 +3275,22 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "CLAUDE.md", status: "fail", detail: "Not found" });
   }
-  if (fileExists(path26.join(projectDir, GENERATED_FILES.cursorRules))) {
+  if (fileExists(path29.join(projectDir, GENERATED_FILES.cursorRules))) {
     checks.push({ name: ".cursorrules", status: "pass", detail: "Present" });
   } else {
     checks.push({ name: ".cursorrules", status: "warn", detail: "Not generated" });
   }
-  const skillsDir = path26.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path29.join(projectDir, GENERATED_FILES.claudeSkills);
   if (dirExists(skillsDir)) {
     const count = config.commands.length;
     checks.push({ name: "Skills", status: "pass", detail: `${count} installed` });
   } else {
     checks.push({ name: "Skills", status: "warn", detail: "No skills directory" });
   }
-  const agentsDir = path26.join(projectDir, GENERATED_FILES.claudeAgents);
+  const agentsDir = path29.join(projectDir, GENERATED_FILES.claudeAgents);
   if (dirExists(agentsDir)) {
     try {
-      const agentFiles = fs15.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
+      const agentFiles = fs16.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
       checks.push({ name: "Agents", status: "pass", detail: `${agentFiles.length} configured` });
     } catch {
       checks.push({ name: "Agents", status: "warn", detail: "Could not read agents" });
@@ -2945,7 +3298,7 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "Agents", status: "warn", detail: "Not configured" });
   }
-  const settingsLocal = readFileSafe(path26.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
+  const settingsLocal = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
   if (settingsLocal && settingsLocal.includes('"hooks"')) {
     checks.push({ name: "Hooks", status: "pass", detail: "Configured" });
   } else {
@@ -2955,7 +3308,7 @@ function checkSetup(projectDir, config) {
 }
 function checkSecurity(projectDir) {
   const checks = [];
-  const claudeMd = readFileSafe(path26.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
   if (claudeMd) {
     const secretPatterns = [
       /(?:api[_-]?key|secret|token|password|credential)\s*[:=]\s*['"][^'"]+['"]/i,
@@ -2970,7 +3323,7 @@ function checkSecurity(projectDir) {
       detail: hasSecrets ? "Potential secrets detected \u2014 remove immediately" : "Clean"
     });
   }
-  const gitignore = readFileSafe(path26.join(projectDir, ".gitignore"));
+  const gitignore = readFileSafe(path29.join(projectDir, ".gitignore"));
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
     checks.push({
@@ -2979,7 +3332,7 @@ function checkSecurity(projectDir) {
       detail: envIgnored ? "Protected" : "NOT gitignored \u2014 add .env to .gitignore"
     });
   }
-  const settingsJson = readFileSafe(path26.join(projectDir, ".claude", "settings.json"));
+  const settingsJson = readFileSafe(path29.join(projectDir, ".claude", "settings.json"));
   if (settingsJson) {
     const hasHardcoded = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settingsJson);
     checks.push({
@@ -3018,6 +3371,33 @@ function checkStack(config) {
       detail: scan.monorepoTool || "Detected"
     });
   }
+  if (scan.staticSite?.isStatic) {
+    checks.push({
+      name: "Static Site",
+      status: "pass",
+      detail: `${scan.staticSite.outputMode} mode`
+    });
+  }
+  if (scan.designTokens?.detected) {
+    checks.push({
+      name: "Design Tokens",
+      status: "pass",
+      detail: `${scan.designTokens.colors.length} colors, ${scan.designTokens.fonts.length} fonts (${scan.designTokens.source})`
+    });
+  } else if (scan.styling.includes("tailwind")) {
+    checks.push({
+      name: "Design Tokens",
+      status: "warn",
+      detail: "Tailwind detected but no custom tokens found \u2014 AI may use arbitrary values"
+    });
+  }
+  if (scan.aiIgnorePatterns?.length > 0) {
+    checks.push({
+      name: ".aiignore",
+      status: "pass",
+      detail: `${scan.aiIgnorePatterns.length} patterns loaded`
+    });
+  }
   return { title: "Stack Detection", checks };
 }
 function checkTools(scan) {
@@ -3061,7 +3441,7 @@ function checkDocs(projectDir) {
     { name: "Time Log", path: "docs/time-log.md" }
   ];
   for (const doc of docsToCheck) {
-    const content = readFileSafe(path26.join(projectDir, doc.path));
+    const content = readFileSafe(path29.join(projectDir, doc.path));
     if (content) {
       const hasEntries = content.includes("## 20") || content.split("---").length > 2;
       checks.push({
@@ -3076,8 +3456,8 @@ function checkDocs(projectDir) {
   return { title: "Documentation", checks };
 }
 async function healthCommand(targetPath) {
-  const projectDir = path26.resolve(targetPath || process.cwd());
-  const configPath = path26.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path29.resolve(targetPath || process.cwd());
+  const configPath = path29.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Project Health");
   console.log(chalk7.dim(`  ${projectDir}`));
@@ -3161,8 +3541,8 @@ async function healthCommand(targetPath) {
 }
 
 // src/commands/patterns.ts
-import path27 from "path";
-import fs16 from "fs-extra";
+import path30 from "path";
+import fs17 from "fs-extra";
 import chalk8 from "chalk";
 import ora8 from "ora";
 function buildPatternCategories() {
@@ -3246,9 +3626,9 @@ var IGNORE_DIRS = [
 ];
 function walkTsFiles(dir, files) {
   try {
-    const entries = fs16.readdirSync(dir, { withFileTypes: true });
+    const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path27.join(dir, entry.name);
+      const full = path30.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.includes(entry.name)) continue;
         walkTsFiles(full, files);
@@ -3260,8 +3640,8 @@ function walkTsFiles(dir, files) {
   }
 }
 async function patternsCommand(targetPath) {
-  const projectDir = path27.resolve(targetPath || process.cwd());
-  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path30.resolve(targetPath || process.cwd());
+  const configPath = path30.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Pattern Library");
   console.log(chalk8.dim(`  ${projectDir}`));
@@ -3272,7 +3652,7 @@ async function patternsCommand(targetPath) {
   }
   const spinner = ora8("Scanning for code patterns...").start();
   const files = [];
-  const srcDir = path27.join(projectDir, "src");
+  const srcDir = path30.join(projectDir, "src");
   if (dirExists(srcDir)) {
     walkTsFiles(srcDir, files);
   } else {
@@ -3294,7 +3674,7 @@ async function patternsCommand(targetPath) {
           if (pattern.regex.test(lines2[i])) {
             pattern.matches.push({
               pattern: pattern.label,
-              file: path27.relative(projectDir, file),
+              file: path30.relative(projectDir, file),
               line: i + 1
             });
           }
@@ -3322,9 +3702,9 @@ async function patternsCommand(targetPath) {
     logInfo("No recognizable patterns found.");
     return;
   }
-  const outputDir = path27.join(projectDir, "ai-kit");
-  fs16.ensureDirSync(outputDir);
-  const outputPath = path27.join(outputDir, "patterns.md");
+  const outputDir = path30.join(projectDir, "ai-kit");
+  fs17.ensureDirSync(outputDir);
+  const outputPath = path30.join(outputDir, "patterns.md");
   const lines = [
     "# Code Patterns",
     "",
@@ -3357,7 +3737,7 @@ async function patternsCommand(targetPath) {
       lines.push("");
     }
   }
-  fs16.writeFileSync(outputPath, lines.join("\n"), "utf-8");
+  fs17.writeFileSync(outputPath, lines.join("\n"), "utf-8");
   console.log("");
   logSuccess(`Pattern library written to ${chalk8.cyan("ai-kit/patterns.md")}`);
   logInfo(`Total: ${chalk8.bold(String(totalPatterns))} pattern occurrences across ${chalk8.bold(String(files.length))} files`);
@@ -3365,14 +3745,14 @@ async function patternsCommand(targetPath) {
 }
 
 // src/commands/dead-code.ts
-import path29 from "path";
-import fs18 from "fs-extra";
+import path32 from "path";
+import fs19 from "fs-extra";
 import chalk9 from "chalk";
 import ora9 from "ora";
 
 // src/scanner/components.ts
-import path28 from "path";
-import fs17 from "fs-extra";
+import path31 from "path";
+import fs18 from "fs-extra";
 var COMPONENT_DIRS = [
   "src/components",
   "src/Components",
@@ -3399,7 +3779,7 @@ function findComponentFiles(projectPath) {
   const files = [];
   const directories = /* @__PURE__ */ new Set();
   for (const dir of COMPONENT_DIRS) {
-    const fullDir = path28.join(projectPath, dir);
+    const fullDir = path31.join(projectPath, dir);
     if (dirExists(fullDir)) {
       walkForComponents(fullDir, files, directories);
     }
@@ -3408,9 +3788,9 @@ function findComponentFiles(projectPath) {
 }
 function walkForComponents(dir, files, directories) {
   try {
-    const entries = fs17.readdirSync(dir, { withFileTypes: true });
+    const entries = fs18.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path28.join(dir, entry.name);
+      const full = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_PATTERNS.includes(entry.name)) continue;
         walkForComponents(full, files, directories);
@@ -3450,7 +3830,7 @@ function extractComponentName(filePath, content) {
     /export\s+(?:const|function)\s+(\w+)/
   );
   if (namedExport) return namedExport[1];
-  return path28.basename(filePath, ".tsx");
+  return path31.basename(filePath, ".tsx");
 }
 function extractExportType(content) {
   const hasDefault = /export\s+default\s/.test(content);
@@ -3539,7 +3919,7 @@ function extractDependencies(content) {
   for (const match of imports) {
     const importPath = match[1];
     if (importPath.startsWith(".") || importPath.startsWith("..")) {
-      const basename = path28.basename(importPath).replace(/\.\w+$/, "");
+      const basename = path31.basename(importPath).replace(/\.\w+$/, "");
       if (/^[A-Z]/.test(basename)) {
         deps.push(basename);
       }
@@ -3548,33 +3928,33 @@ function extractDependencies(content) {
   return deps;
 }
 function checkForTests(componentPath, componentName) {
-  const dir = path28.dirname(componentPath);
-  const base = path28.basename(componentPath, ".tsx");
+  const dir = path31.dirname(componentPath);
+  const base = path31.basename(componentPath, ".tsx");
   for (const suffix of TEST_SUFFIXES) {
-    if (fs17.existsSync(path28.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
   }
-  const testsDir = path28.join(dir, "__tests__");
+  const testsDir = path31.join(dir, "__tests__");
   if (dirExists(testsDir)) {
     for (const suffix of TEST_SUFFIXES) {
-      if (fs17.existsSync(path28.join(testsDir, base + suffix))) return true;
-      if (fs17.existsSync(path28.join(testsDir, componentName + suffix))) return true;
+      if (fs18.existsSync(path31.join(testsDir, base + suffix))) return true;
+      if (fs18.existsSync(path31.join(testsDir, componentName + suffix))) return true;
     }
   }
   return false;
 }
 function checkForStory(componentPath, componentName) {
-  const dir = path28.dirname(componentPath);
-  const base = path28.basename(componentPath, ".tsx");
+  const dir = path31.dirname(componentPath);
+  const base = path31.basename(componentPath, ".tsx");
   for (const suffix of STORY_SUFFIXES) {
-    if (fs17.existsSync(path28.join(dir, base + suffix))) return true;
-    if (fs17.existsSync(path28.join(dir, componentName + suffix))) return true;
+    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path31.join(dir, componentName + suffix))) return true;
   }
   return false;
 }
 function checkForAiDoc(componentPath) {
-  const dir = path28.dirname(componentPath);
-  const base = path28.basename(componentPath, ".tsx");
-  return fs17.existsSync(path28.join(dir, `${base}.ai.md`)) || fs17.existsSync(path28.join(dir, "component.ai.md"));
+  const dir = path31.dirname(componentPath);
+  const base = path31.basename(componentPath, ".tsx");
+  return fs18.existsSync(path31.join(dir, `${base}.ai.md`)) || fs18.existsSync(path31.join(dir, "component.ai.md"));
 }
 function categorizeComponent(relativePath) {
   const lower = relativePath.toLowerCase();
@@ -3592,7 +3972,7 @@ function parseComponent(filePath, projectPath) {
   const content = readFileSafe(filePath);
   if (!content) return null;
   const name = extractComponentName(filePath, content);
-  const relativePath = path28.relative(projectPath, filePath);
+  const relativePath = path31.relative(projectPath, filePath);
   return {
     name,
     filePath,
@@ -3638,9 +4018,9 @@ var IGNORE_DIRS2 = [
 ];
 function collectAllFiles(dir, files) {
   try {
-    const entries = fs18.readdirSync(dir, { withFileTypes: true });
+    const entries = fs19.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path29.join(dir, entry.name);
+      const full = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS2.includes(entry.name)) continue;
         collectAllFiles(full, files);
@@ -3652,12 +4032,12 @@ function collectAllFiles(dir, files) {
   }
 }
 function isTestOrStoryFile(filePath) {
-  const name = path29.basename(filePath).toLowerCase();
+  const name = path32.basename(filePath).toLowerCase();
   return name.includes(".test.") || name.includes(".spec.") || name.includes(".stories.") || name.includes("__tests__") || name.includes("__mocks__");
 }
 async function deadCodeCommand(targetPath) {
-  const projectDir = path29.resolve(targetPath || process.cwd());
-  const configPath = path29.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path32.resolve(targetPath || process.cwd());
+  const configPath = path32.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Dead Code Report");
   console.log(chalk9.dim(`  ${projectDir}`));
@@ -3674,8 +4054,8 @@ async function deadCodeCommand(targetPath) {
   }
   spinner.text = `Found ${scanResult.components.length} components. Checking imports...`;
   const allFiles = [];
-  const srcDir = path29.join(projectDir, "src");
-  if (fs18.existsSync(srcDir)) {
+  const srcDir = path32.join(projectDir, "src");
+  if (fs19.existsSync(srcDir)) {
     collectAllFiles(srcDir, allFiles);
   } else {
     collectAllFiles(projectDir, allFiles);
@@ -3698,7 +4078,7 @@ async function deadCodeCommand(targetPath) {
       `(?:import|from)\\s+.*['"][^'"]*(?:/|\\b)${escapeRegex(component.name)}(?:[/'"]|\\b)`
     );
     for (const [file, content] of fileContents) {
-      if (path29.resolve(file) === path29.resolve(componentFile)) continue;
+      if (path32.resolve(file) === path32.resolve(componentFile)) continue;
       if (namePattern.test(content)) {
         importCount++;
         if (isTestOrStoryFile(file)) {
@@ -3777,8 +4157,8 @@ function escapeRegex(str) {
 }
 
 // src/commands/drift.ts
-import path30 from "path";
-import fs19 from "fs-extra";
+import path33 from "path";
+import fs20 from "fs-extra";
 import chalk10 from "chalk";
 import ora10 from "ora";
 function parseAiDocFrontmatter(content) {
@@ -3814,14 +4194,14 @@ function parseAiDocFrontmatter(content) {
   return { props, fields };
 }
 function findAiDocPath(componentPath) {
-  const dir = path30.dirname(componentPath);
-  const base = path30.basename(componentPath, ".tsx");
+  const dir = path33.dirname(componentPath);
+  const base = path33.basename(componentPath, ".tsx");
   const candidates = [
-    path30.join(dir, `${base}.ai.md`),
-    path30.join(dir, "component.ai.md")
+    path33.join(dir, `${base}.ai.md`),
+    path33.join(dir, "component.ai.md")
   ];
   for (const candidate of candidates) {
-    if (fs19.existsSync(candidate)) return candidate;
+    if (fs20.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -3862,8 +4242,8 @@ function analyzeDrift(component, projectDir) {
   };
 }
 async function driftCommand(targetPath) {
-  const projectDir = path30.resolve(targetPath || process.cwd());
-  const configPath = path30.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path33.resolve(targetPath || process.cwd());
+  const configPath = path33.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Component Drift Detector");
   console.log(chalk10.dim(`  ${projectDir}`));
@@ -3964,6 +4344,144 @@ async function driftCommand(targetPath) {
   console.log("");
 }
 
+// src/commands/component-registry.ts
+import path34 from "path";
+import fs22 from "fs-extra";
+import chalk11 from "chalk";
+import ora11 from "ora";
+
+// src/generator/component-docs.ts
+import fs21 from "fs-extra";
+function calculateHealthScore(component) {
+  let score = 0;
+  const max = 100;
+  if (component.props.length > 0) score += 15;
+  if (component.hasTests) score += 25;
+  if (component.hasStory) score += 20;
+  if (component.hasAiDoc) score += 15;
+  const sc = component.sitecore;
+  if (sc.datasourceFields.length > 0 || sc.renderingParams.length > 0 || sc.placeholders.length > 0) {
+    score += 10;
+  }
+  if (component.dependencies.length > 0) score += 5;
+  if (component.exportType === "default" || component.exportType === "both") score += 10;
+  return Math.min(score, max);
+}
+
+// src/commands/component-registry.ts
+async function componentRegistryCommand(targetPath) {
+  const projectDir = path34.resolve(targetPath || process.cwd());
+  console.log("");
+  logSection("AI Kit \u2014 Component Registry");
+  console.log(chalk11.dim(`  ${projectDir}`));
+  console.log("");
+  if (!fileExists(path34.join(projectDir, AI_KIT_CONFIG_FILE))) {
+    logWarning("ai-kit.config.json not found. Run `ai-kit init` first.");
+    return;
+  }
+  const spinner = ora11("Scanning components...").start();
+  const scanResult = scanComponents(projectDir);
+  if (scanResult.components.length === 0) {
+    spinner.fail("No components found.");
+    return;
+  }
+  spinner.succeed(`Found ${scanResult.components.length} components in ${scanResult.directories.length} directories`);
+  const entries = scanResult.components.map((c) => ({
+    name: c.name,
+    path: c.relativePath,
+    category: c.category,
+    props: c.props,
+    exportType: c.exportType,
+    dependencies: c.dependencies,
+    sitecore: {
+      datasourceFields: c.sitecore.datasourceFields,
+      renderingParams: c.sitecore.renderingParams,
+      placeholders: c.sitecore.placeholders
+    },
+    health: {
+      score: calculateHealthScore(c),
+      hasTests: c.hasTests,
+      hasStory: c.hasStory,
+      hasAiDoc: c.hasAiDoc
+    }
+  }));
+  const categories = {};
+  for (const entry of entries) {
+    categories[entry.category] = (categories[entry.category] || 0) + 1;
+  }
+  const pkgPath = path34.join(projectDir, "package.json");
+  const pkg = fs22.readJsonSync(pkgPath, { throws: false }) || {};
+  const registry = {
+    version: "1.0.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectName: pkg.name || path34.basename(projectDir),
+    totalComponents: entries.length,
+    categories,
+    components: entries
+  };
+  const outputPath = path34.join(projectDir, "ai-kit", "component-registry.json");
+  await fs22.ensureDir(path34.dirname(outputPath));
+  await fs22.writeJson(outputPath, registry, { spaces: 2 });
+  const mdPath = path34.join(projectDir, "ai-kit", "component-registry.md");
+  const md = generateRegistryMarkdown(registry);
+  await fs22.writeFile(mdPath, md, "utf-8");
+  console.log("");
+  console.log(`  ${chalk11.bold("Categories:")}`);
+  for (const [cat, count] of Object.entries(categories).sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${chalk11.cyan(String(count).padStart(3))} ${cat}`);
+  }
+  const avgHealth = Math.round(entries.reduce((sum, e) => sum + e.health.score, 0) / entries.length);
+  const withTests = entries.filter((e) => e.health.hasTests).length;
+  const withStories = entries.filter((e) => e.health.hasStory).length;
+  const withDocs = entries.filter((e) => e.health.hasAiDoc).length;
+  console.log("");
+  console.log(`  ${chalk11.bold("Health:")}`);
+  console.log(`    Average score: ${chalk11.cyan(String(avgHealth))}/100`);
+  console.log(`    With tests: ${chalk11.cyan(String(withTests))}/${entries.length}`);
+  console.log(`    With stories: ${chalk11.cyan(String(withStories))}/${entries.length}`);
+  console.log(`    With .ai.md docs: ${chalk11.cyan(String(withDocs))}/${entries.length}`);
+  console.log("");
+  logSuccess(`Registry written to ${chalk11.cyan("ai-kit/component-registry.json")}`);
+  logSuccess(`Summary written to ${chalk11.cyan("ai-kit/component-registry.md")}`);
+  logInfo("AI agents can use this registry to discover existing components before creating new ones.");
+  console.log("");
+}
+function generateRegistryMarkdown(registry) {
+  const lines = [
+    "# Component Registry",
+    "",
+    `> Auto-generated by ai-kit on ${registry.generatedAt.split("T")[0]}`,
+    `> ${registry.totalComponents} components in ${registry.projectName}`,
+    "",
+    "## How to Use",
+    "",
+    "Before creating a new component, check this registry to see if one already exists.",
+    "AI agents should reference this file to avoid duplicating components.",
+    ""
+  ];
+  const grouped = /* @__PURE__ */ new Map();
+  for (const comp of registry.components) {
+    const list = grouped.get(comp.category) || [];
+    list.push(comp);
+    grouped.set(comp.category, list);
+  }
+  for (const [category, components] of grouped) {
+    lines.push(`## ${category.charAt(0).toUpperCase() + category.slice(1)} (${components.length})`);
+    lines.push("");
+    lines.push("| Component | Path | Props | Tests | Story | Health |");
+    lines.push("|-----------|------|-------|-------|-------|--------|");
+    for (const comp of components) {
+      const propsCount = comp.props.length;
+      const tests = comp.health.hasTests ? "Yes" : "No";
+      const story = comp.health.hasStory ? "Yes" : "No";
+      const health = `${comp.health.score}/100`;
+      lines.push(`| ${comp.name} | \`${comp.path}\` | ${propsCount} | ${tests} | ${story} | ${health} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
 // src/index.ts
 var program = new Command();
 program.name("ai-kit").description(
@@ -4112,5 +4630,16 @@ program.command("drift").description("Detect drift between component code and .a
     process.exit(1);
   }
 });
+program.command("component-registry").description("Generate a component registry for AI agent discovery").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await componentRegistryCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
 program.parse();
 //# sourceMappingURL=index.js.map