npm - @mikulgohil/ai-kit - Versions diffs - 1.10.0 → 1.11.0 - Mend

@mikulgohil/ai-kit 1.10.0 → 1.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/README.md +33 -9
package/dist/index.js +581 -240
package/dist/index.js.map +1 -1
package/guides/getting-started.md +25 -1
package/package.json +7 -3

package/dist/index.js CHANGED Viewed

@@ -15,8 +15,9 @@ 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.10.0";
+var VERSION = "1.11.0";
 var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
+var BACKUP_DIR = ".ai-kit/backups";
 var GENERATED_FILES = {
   claudeMd: "CLAUDE.md",
   cursorRules: ".cursorrules",
@@ -43,16 +44,17 @@ var TEMPLATE_FRAGMENTS = [
 ];
 // src/commands/init.ts
-import path20 from "path";
+import path21 from "path";
 import fs9 from "fs-extra";
 import { select } from "@inquirer/prompts";
 import ora from "ora";
 // src/scanner/index.ts
-import path13 from "path";
+import path14 from "path";
 // src/utils.ts
 import fs from "fs-extra";
+import path2 from "path";
 import chalk from "chalk";
 function readJsonSafe(filePath) {
   try {
@@ -105,9 +107,91 @@ function mergeWithMarkers(existingContent, newGenerated) {
   const after = existingContent.substring(endIdx + AI_KIT_END.length);
   return `${before}${newGenerated}${after}`;
 }
+async function backupFiles(projectDir, files) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupDir = path2.join(projectDir, BACKUP_DIR, timestamp);
+  await fs.ensureDir(backupDir);
+  let backedUp = 0;
+  for (const file of files) {
+    const fullPath = path2.join(projectDir, file);
+    if (await fs.pathExists(fullPath)) {
+      const dest = path2.join(backupDir, file);
+      await fs.ensureDir(path2.dirname(dest));
+      await fs.copy(fullPath, dest);
+      backedUp++;
+    }
+  }
+  if (backedUp === 0) {
+    await fs.remove(backupDir);
+    return "";
+  }
+  return backupDir;
+}
+async function listBackups(projectDir) {
+  const backupsRoot = path2.join(projectDir, BACKUP_DIR);
+  if (!await fs.pathExists(backupsRoot)) return [];
+  const entries = await fs.readdir(backupsRoot);
+  return entries.filter((e) => /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/.test(e)).sort().reverse();
+}
+async function restoreBackup(projectDir, backupName) {
+  const backupDir = path2.join(projectDir, BACKUP_DIR, backupName);
+  if (!await fs.pathExists(backupDir)) {
+    throw new Error(`Backup not found: ${backupName}`);
+  }
+  const restored = [];
+  async function walk(dir, rel) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryRel = rel ? `${rel}/${entry.name}` : entry.name;
+      const srcPath = path2.join(dir, entry.name);
+      const destPath = path2.join(projectDir, entryRel);
+      if (entry.isDirectory()) {
+        await walk(srcPath, entryRel);
+      } else {
+        await fs.ensureDir(path2.dirname(destPath));
+        await fs.copy(srcPath, destPath, { overwrite: true });
+        restored.push(entryRel);
+      }
+    }
+  }
+  await walk(backupDir, "");
+  return restored;
+}
+function parseSections(markdown) {
+  const lines = markdown.split("\n");
+  const sections = [];
+  let current = null;
+  const contentLines = [];
+  function flush() {
+    if (current) {
+      current.content = contentLines.join("\n").trim();
+      current.raw = `${"#".repeat(current.level)} ${current.heading}
+${current.content}`.trim();
+      sections.push(current);
+      contentLines.length = 0;
+    }
+  }
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (match) {
+      flush();
+      current = {
+        heading: match[2].trim(),
+        level: match[1].length,
+        content: "",
+        raw: ""
+      };
+    } else if (current) {
+      contentLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
 // src/scanner/nextjs.ts
-import path2 from "path";
+import path3 from "path";
 function detectNextjs(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -119,8 +203,8 @@ function detectNextjs(projectPath, pkg) {
   }
   const nextjsVersion = deps.next.replace(/[\^~>=<]/g, "");
   const nextjsMajorVersion = parseInt(nextjsVersion.split(".")[0], 10) || void 0;
-  const hasAppDir = dirExists(path2.join(projectPath, "app")) || dirExists(path2.join(projectPath, "src", "app"));
-  const hasPagesDir = dirExists(path2.join(projectPath, "pages")) || dirExists(path2.join(projectPath, "src", "pages"));
+  const hasAppDir = dirExists(path3.join(projectPath, "app")) || dirExists(path3.join(projectPath, "src", "app"));
+  const hasPagesDir = dirExists(path3.join(projectPath, "pages")) || dirExists(path3.join(projectPath, "src", "pages"));
   let routerType;
   if (hasAppDir && hasPagesDir) routerType = "hybrid";
   else if (hasAppDir) routerType = "app";
@@ -206,7 +290,7 @@ function detectOptimizely(pkg) {
 }
 // src/scanner/styling.ts
-import path3 from "path";
+import path4 from "path";
 function detectStyling(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -218,7 +302,7 @@ function detectStyling(projectPath, pkg) {
     styling.push("tailwind");
     tailwindVersion = (deps.tailwindcss || deps["@tailwindcss/postcss"] || "").replace(/[\^~>=<]/g, "");
   }
-  const hasTailwindConfig = fileExists(path3.join(projectPath, "tailwind.config.js")) || fileExists(path3.join(projectPath, "tailwind.config.ts")) || fileExists(path3.join(projectPath, "tailwind.config.mjs"));
+  const hasTailwindConfig = fileExists(path4.join(projectPath, "tailwind.config.js")) || fileExists(path4.join(projectPath, "tailwind.config.ts")) || fileExists(path4.join(projectPath, "tailwind.config.mjs"));
   if (hasTailwindConfig && !styling.includes("tailwind")) {
     styling.push("tailwind");
   }
@@ -231,9 +315,9 @@ function detectStyling(projectPath, pkg) {
 }
 // src/scanner/typescript.ts
-import path4 from "path";
+import path5 from "path";
 function detectTypescript(projectPath) {
-  const tsconfigPath = path4.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path5.join(projectPath, "tsconfig.json");
   if (!fileExists(tsconfigPath)) {
     return { typescript: false };
   }
@@ -245,18 +329,18 @@ function detectTypescript(projectPath) {
 }
 // src/scanner/monorepo.ts
-import path5 from "path";
+import path6 from "path";
 function detectMonorepo(projectPath, pkg) {
-  if (fileExists(path5.join(projectPath, "turbo.json"))) {
+  if (fileExists(path6.join(projectPath, "turbo.json"))) {
     return { monorepo: true, monorepoTool: "turborepo" };
   }
-  if (fileExists(path5.join(projectPath, "nx.json"))) {
+  if (fileExists(path6.join(projectPath, "nx.json"))) {
     return { monorepo: true, monorepoTool: "nx" };
   }
-  if (fileExists(path5.join(projectPath, "lerna.json"))) {
+  if (fileExists(path6.join(projectPath, "lerna.json"))) {
     return { monorepo: true, monorepoTool: "lerna" };
   }
-  if (fileExists(path5.join(projectPath, "pnpm-workspace.yaml"))) {
+  if (fileExists(path6.join(projectPath, "pnpm-workspace.yaml"))) {
     return { monorepo: true, monorepoTool: "pnpm-workspaces" };
   }
   if (pkg.workspaces) {
@@ -266,10 +350,10 @@ function detectMonorepo(projectPath, pkg) {
 }
 // src/scanner/package-manager.ts
-import path6 from "path";
+import path7 from "path";
 function detectPackageManager(projectPath) {
   const pkg = readJsonSafe(
-    path6.join(projectPath, "package.json")
+    path7.join(projectPath, "package.json")
   );
   if (pkg?.packageManager) {
     if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
@@ -277,15 +361,15 @@ function detectPackageManager(projectPath) {
     if (pkg.packageManager.startsWith("bun")) return "bun";
     return "npm";
   }
-  if (fileExists(path6.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (fileExists(path6.join(projectPath, "yarn.lock"))) return "yarn";
-  if (fileExists(path6.join(projectPath, "bun.lockb"))) return "bun";
-  if (fileExists(path6.join(projectPath, "bun.lock"))) return "bun";
+  if (fileExists(path7.join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (fileExists(path7.join(projectPath, "yarn.lock"))) return "yarn";
+  if (fileExists(path7.join(projectPath, "bun.lockb"))) return "bun";
+  if (fileExists(path7.join(projectPath, "bun.lock"))) return "bun";
   return "npm";
 }
 // src/scanner/figma.ts
-import path7 from "path";
+import path8 from "path";
 function detectFigma(projectPath, pkg) {
   return {
     figmaMcp: detectFigmaMcp(projectPath),
@@ -297,9 +381,9 @@ function detectFigma(projectPath, pkg) {
 }
 function detectFigmaMcp(projectPath) {
   const settingsPaths = [
-    path7.join(projectPath, ".claude", "settings.json"),
-    path7.join(projectPath, ".claude", "settings.local.json"),
-    path7.join(projectPath, ".mcp.json")
+    path8.join(projectPath, ".claude", "settings.json"),
+    path8.join(projectPath, ".claude", "settings.local.json"),
+    path8.join(projectPath, ".mcp.json")
   ];
   for (const settingsPath of settingsPaths) {
     const content = readFileSafe(settingsPath);
@@ -320,28 +404,28 @@ function detectFigmaCodeCli(pkg) {
 }
 function detectDesignTokens(projectPath) {
   const tokenPaths = [
-    path7.join(projectPath, "tokens.json"),
-    path7.join(projectPath, "tokens"),
-    path7.join(projectPath, "design-tokens.json"),
-    path7.join(projectPath, "src", "tokens")
+    path8.join(projectPath, "tokens.json"),
+    path8.join(projectPath, "tokens"),
+    path8.join(projectPath, "design-tokens.json"),
+    path8.join(projectPath, "src", "tokens")
   ];
   for (const tokenPath of tokenPaths) {
     if (fileExists(tokenPath)) return true;
   }
   const globalsCss = readFileSafe(
-    path7.join(projectPath, "src", "app", "globals.css")
+    path8.join(projectPath, "src", "app", "globals.css")
   );
   if (globalsCss && globalsCss.includes("@theme")) return true;
   return false;
 }
 function detectTokenFormat(projectPath) {
   const globalsCss = readFileSafe(
-    path7.join(projectPath, "src", "app", "globals.css")
+    path8.join(projectPath, "src", "app", "globals.css")
   );
   if (globalsCss && globalsCss.includes("@theme")) return "tailwind-v4";
   const twConfigPaths = [
-    path7.join(projectPath, "tailwind.config.ts"),
-    path7.join(projectPath, "tailwind.config.js")
+    path8.join(projectPath, "tailwind.config.ts"),
+    path8.join(projectPath, "tailwind.config.js")
   ];
   for (const twPath of twConfigPaths) {
     const content = readFileSafe(twPath);
@@ -356,12 +440,12 @@ function detectVisualTests(projectPath, pkg) {
     ...pkg.devDependencies
   };
   const hasPlaywright = "@playwright/test" in deps || "playwright" in deps;
-  const hasPlaywrightConfig = fileExists(path7.join(projectPath, "playwright.config.ts")) || fileExists(path7.join(projectPath, "playwright.config.js"));
+  const hasPlaywrightConfig = fileExists(path8.join(projectPath, "playwright.config.ts")) || fileExists(path8.join(projectPath, "playwright.config.js"));
   return hasPlaywright || hasPlaywrightConfig;
 }
 // src/scanner/tools.ts
-import path8 from "path";
+import path9 from "path";
 function detectTools(projectPath, pkg) {
   const deps = {
     ...pkg.dependencies,
@@ -381,13 +465,13 @@ function detectTools(projectPath, pkg) {
 }
 function detectPlaywright(projectPath, deps) {
   if ("@playwright/test" in deps) return true;
-  if (fileExists(path8.join(projectPath, "playwright.config.ts"))) return true;
-  if (fileExists(path8.join(projectPath, "playwright.config.js"))) return true;
+  if (fileExists(path9.join(projectPath, "playwright.config.ts"))) return true;
+  if (fileExists(path9.join(projectPath, "playwright.config.js"))) return true;
   return false;
 }
 function detectStorybook(projectPath, deps) {
   if ("@storybook/react" in deps) return true;
-  if (dirExists(path8.join(projectPath, ".storybook"))) return true;
+  if (dirExists(path9.join(projectPath, ".storybook"))) return true;
   return false;
 }
 function detectEslint(projectPath, deps) {
@@ -405,7 +489,7 @@ function detectEslint(projectPath, deps) {
     "eslint.config.ts"
   ];
   for (const config of eslintConfigs) {
-    if (fileExists(path8.join(projectPath, config))) return true;
+    if (fileExists(path9.join(projectPath, config))) return true;
   }
   return false;
 }
@@ -424,14 +508,14 @@ function detectPrettier(projectPath, deps) {
     "prettier.config.ts"
   ];
   for (const config of prettierConfigs) {
-    if (fileExists(path8.join(projectPath, config))) return true;
+    if (fileExists(path9.join(projectPath, config))) return true;
   }
   return false;
 }
 function detectBiome(projectPath, deps) {
   if ("@biomejs/biome" in deps) return true;
-  if (fileExists(path8.join(projectPath, "biome.json"))) return true;
-  if (fileExists(path8.join(projectPath, "biome.jsonc"))) return true;
+  if (fileExists(path9.join(projectPath, "biome.json"))) return true;
+  if (fileExists(path9.join(projectPath, "biome.jsonc"))) return true;
   return false;
 }
 function detectAxeCore(deps) {
@@ -439,13 +523,13 @@ function detectAxeCore(deps) {
 }
 function detectSnyk(projectPath, deps) {
   if ("snyk" in deps) return true;
-  if (fileExists(path8.join(projectPath, ".snyk"))) return true;
+  if (fileExists(path9.join(projectPath, ".snyk"))) return true;
   return false;
 }
 function detectKnip(projectPath, deps) {
   if ("knip" in deps) return true;
-  if (fileExists(path8.join(projectPath, "knip.json"))) return true;
-  if (fileExists(path8.join(projectPath, "knip.config.ts"))) return true;
+  if (fileExists(path9.join(projectPath, "knip.json"))) return true;
+  if (fileExists(path9.join(projectPath, "knip.config.ts"))) return true;
   return false;
 }
 function detectBundleAnalyzer(deps) {
@@ -453,12 +537,12 @@ function detectBundleAnalyzer(deps) {
 }
 // src/scanner/mcp.ts
-import path9 from "path";
+import path10 from "path";
 function detectMcpServers(projectPath) {
   const settingsPaths = [
-    path9.join(projectPath, ".claude", "settings.json"),
-    path9.join(projectPath, ".claude", "settings.local.json"),
-    path9.join(projectPath, ".mcp.json")
+    path10.join(projectPath, ".claude", "settings.json"),
+    path10.join(projectPath, ".claude", "settings.local.json"),
+    path10.join(projectPath, ".mcp.json")
   ];
   let combined = "";
   for (const settingsPath of settingsPaths) {
@@ -477,18 +561,18 @@ function detectMcpServers(projectPath) {
 }
 // src/scanner/design-tokens.ts
-import path10 from "path";
+import path11 from "path";
 function detectDesignTokens2(projectPath) {
   const globalsCss = readFileSafe(
-    path10.join(projectPath, "src", "app", "globals.css")
+    path11.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")
+    path11.join(projectPath, "tailwind.config.ts"),
+    path11.join(projectPath, "tailwind.config.js"),
+    path11.join(projectPath, "tailwind.config.mjs")
   ];
   for (const twPath of twConfigPaths) {
     const content = readFileSafe(twPath);
@@ -622,7 +706,7 @@ function parseCssVariables(css) {
 }
 // src/scanner/static-site.ts
-import path11 from "path";
+import path12 from "path";
 import fs2 from "fs-extra";
 function detectStaticSite(projectPath, pkg) {
   const hasStaticExport = checkStaticExport(projectPath);
@@ -651,9 +735,9 @@ function detectStaticSite(projectPath, pkg) {
 }
 function checkStaticExport(projectPath) {
   const configPaths = [
-    path11.join(projectPath, "next.config.js"),
-    path11.join(projectPath, "next.config.ts"),
-    path11.join(projectPath, "next.config.mjs")
+    path12.join(projectPath, "next.config.js"),
+    path12.join(projectPath, "next.config.ts"),
+    path12.join(projectPath, "next.config.mjs")
   ];
   for (const configPath of configPaths) {
     const content = readFileSafe(configPath);
@@ -665,8 +749,8 @@ function checkStaticExport(projectPath) {
 }
 function checkGenerateStaticParams(projectPath) {
   const appDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src", "app")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src", "app")
   ];
   for (const appDir of appDirs) {
     if (dirExists(appDir) && hasPatternInDir(appDir, /generateStaticParams/)) {
@@ -674,8 +758,8 @@ function checkGenerateStaticParams(projectPath) {
     }
   }
   const pagesDirs = [
-    path11.join(projectPath, "pages"),
-    path11.join(projectPath, "src", "pages")
+    path12.join(projectPath, "pages"),
+    path12.join(projectPath, "src", "pages")
   ];
   for (const pagesDir of pagesDirs) {
     if (dirExists(pagesDir) && hasPatternInDir(pagesDir, /getStaticPaths/)) {
@@ -686,8 +770,8 @@ function checkGenerateStaticParams(projectPath) {
 }
 function checkRevalidatePatterns(projectPath) {
   const appDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src", "app")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src", "app")
   ];
   for (const appDir of appDirs) {
     if (dirExists(appDir) && hasPatternInDir(appDir, /revalidate\s*[:=]/)) {
@@ -698,8 +782,8 @@ function checkRevalidatePatterns(projectPath) {
 }
 function checkServerActions(projectPath) {
   const srcDirs = [
-    path11.join(projectPath, "app"),
-    path11.join(projectPath, "src")
+    path12.join(projectPath, "app"),
+    path12.join(projectPath, "src")
   ];
   for (const srcDir of srcDirs) {
     if (dirExists(srcDir) && hasPatternInDir(srcDir, /['"]use server['"]/)) {
@@ -710,15 +794,15 @@ function checkServerActions(projectPath) {
 }
 function checkApiRoutes(projectPath) {
   const appApiDirs = [
-    path11.join(projectPath, "app", "api"),
-    path11.join(projectPath, "src", "app", "api")
+    path12.join(projectPath, "app", "api"),
+    path12.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")
+    path12.join(projectPath, "pages", "api"),
+    path12.join(projectPath, "src", "pages", "api")
   ];
   for (const apiDir of pagesApiDirs) {
     if (dirExists(apiDir)) return true;
@@ -732,7 +816,7 @@ function hasPatternInDir(dir, pattern, depth = 0) {
     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);
+      const full = path12.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (hasPatternInDir(full, pattern, depth + 1)) return true;
       } else if (/\.(tsx?|jsx?|mjs)$/.test(entry.name)) {
@@ -746,19 +830,19 @@ function hasPatternInDir(dir, pattern, depth = 0) {
 }
 // src/scanner/aiignore.ts
-import path12 from "path";
+import path13 from "path";
 function loadAiIgnorePatterns(projectPath) {
-  const content = readFileSafe(path12.join(projectPath, ".aiignore"));
+  const content = readFileSafe(path13.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 = path13.join(projectPath, "package.json");
+  const pkgPath = path14.join(projectPath, "package.json");
   const pkg = readJsonSafe(pkgPath) || {};
   const scripts = pkg.scripts || {};
-  const projectName = pkg.name || path13.basename(projectPath);
+  const projectName = pkg.name || path14.basename(projectPath);
   const nextjsResult = detectNextjs(projectPath, pkg);
   const sitecoreResult = detectSitecore(pkg);
   const optimizelyResult = detectOptimizely(pkg);
@@ -801,10 +885,10 @@ async function scanProject(projectPath) {
 }
 // src/generator/assembler.ts
-import path14 from "path";
+import path15 from "path";
 import fs3 from "fs-extra";
 function readTemplate(relativePath) {
-  const fullPath = path14.join(TEMPLATES_DIR, relativePath);
+  const fullPath = path15.join(TEMPLATES_DIR, relativePath);
   const content = readFileSafe(fullPath);
   if (!content) {
     throw new Error(`Template not found: ${relativePath}`);
@@ -812,12 +896,12 @@ function readTemplate(relativePath) {
   return content.trim();
 }
 function loadCustomFragments(projectPath) {
-  const customDir = path14.join(projectPath, ".ai-kit", "fragments");
+  const customDir = path15.join(projectPath, ".ai-kit", "fragments");
   if (!fs3.existsSync(customDir)) return [];
   try {
     const files = fs3.readdirSync(customDir).filter((f) => f.endsWith(".md"));
     return files.map((f) => {
-      const content = fs3.readFileSync(path14.join(customDir, f), "utf-8");
+      const content = fs3.readFileSync(path15.join(customDir, f), "utf-8");
       return content.trim();
     }).filter(Boolean);
   } catch {
@@ -1138,10 +1222,33 @@ function generateConfig(scan, templates, commands, guides, options) {
 // src/generator/hooks.ts
 function generateHooks(scan, profile = "standard") {
   const hooks = {};
+  const sessionStart = [];
   const preToolUse = [];
   const postToolUse = [];
   const postCompact = [];
   const stop = [];
+  const stackParts = [
+    scan.framework === "nextjs" ? `Next.js ${scan.nextjsVersion || ""}`.trim() : scan.framework,
+    scan.routerType ? `(${scan.routerType} router)` : "",
+    scan.cms !== "none" ? scan.cms : "",
+    scan.styling.length > 0 ? scan.styling.join(", ") : ""
+  ].filter(Boolean);
+  const scriptNames = Object.keys(scan.scripts).slice(0, 8).join(", ");
+  const stackStr = stackParts.join(" + ");
+  sessionStart.push({
+    matcher: "",
+    hooks: [
+      {
+        type: "command",
+        command: [
+          `echo "\u{1F4CB} ai-kit v${VERSION} | Stack: ${stackStr}"`,
+          `echo "   PM: ${scan.packageManager} | Scripts: ${scriptNames}"`,
+          scan.monorepo ? `echo "   Monorepo: ${scan.monorepoTool || "yes"}"` : "",
+          `if [ -f "ai-kit.config.json" ]; then SCAN_DATE=$(node -e "try{const c=JSON.parse(require('fs').readFileSync('ai-kit.config.json','utf8'));console.log(c.generatedAt?.split('T')[0]||'unknown')}catch{console.log('unknown')}" 2>/dev/null); echo "   Last scan: $SCAN_DATE"; fi`
+        ].filter(Boolean).join("\n")
+      }
+    ]
+  });
   preToolUse.push({
     matcher: "Bash(git push*)",
     hooks: [
@@ -1345,6 +1452,7 @@ function generateHooks(scan, profile = "standard") {
       ]
     });
   }
+  if (sessionStart.length > 0) hooks.SessionStart = sessionStart;
   if (preToolUse.length > 0) hooks.PreToolUse = preToolUse;
   if (postToolUse.length > 0) hooks.PostToolUse = postToolUse;
   if (postCompact.length > 0) hooks.PostCompact = postCompact;
@@ -1359,7 +1467,7 @@ function generateSettingsLocal(scan, profile = "standard") {
 }
 // src/copier/skills.ts
-import path15 from "path";
+import path16 from "path";
 import fs4 from "fs-extra";
 var AVAILABLE_SKILLS = [
   "prompt-help",
@@ -1468,34 +1576,34 @@ var SKILL_DESCRIPTIONS = {
 async function copySkills(targetDir) {
   const copied = [];
   for (const skill of AVAILABLE_SKILLS) {
-    const src = path15.join(COMMANDS_DIR, `${skill}.md`);
+    const src = path16.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 = path15.join(targetDir, ".claude", "skills", skill);
+    const claudeSkillDir = path16.join(targetDir, ".claude", "skills", skill);
     await fs4.ensureDir(claudeSkillDir);
     await fs4.writeFile(
-      path15.join(claudeSkillDir, "SKILL.md"),
+      path16.join(claudeSkillDir, "SKILL.md"),
       content,
       "utf-8"
     );
-    const cursorSkillDir = path15.join(targetDir, ".cursor", "skills", skill);
+    const cursorSkillDir = path16.join(targetDir, ".cursor", "skills", skill);
     await fs4.ensureDir(cursorSkillDir);
     await fs4.writeFile(
-      path15.join(cursorSkillDir, "SKILL.md"),
+      path16.join(cursorSkillDir, "SKILL.md"),
       content,
       "utf-8"
     );
-    const legacyDir = path15.join(targetDir, ".claude", "commands");
+    const legacyDir = path16.join(targetDir, ".claude", "commands");
     await fs4.ensureDir(legacyDir);
-    await fs4.copy(src, path15.join(legacyDir, `${skill}.md`), { overwrite: true });
+    await fs4.copy(src, path16.join(legacyDir, `${skill}.md`), { overwrite: true });
     copied.push(skill);
   }
   return copied;
 }
 // src/copier/guides.ts
-import path16 from "path";
+import path17 from "path";
 import fs5 from "fs-extra";
 var AVAILABLE_GUIDES = [
   "getting-started",
@@ -1506,12 +1614,12 @@ var AVAILABLE_GUIDES = [
   "hooks-and-agents"
 ];
 async function copyGuides(targetDir) {
-  const guidesTarget = path16.join(targetDir, "ai-kit", "guides");
+  const guidesTarget = path17.join(targetDir, "ai-kit", "guides");
   await fs5.ensureDir(guidesTarget);
   const copied = [];
   for (const guide of AVAILABLE_GUIDES) {
-    const src = path16.join(GUIDES_DIR, `${guide}.md`);
-    const dest = path16.join(guidesTarget, `${guide}.md`);
+    const src = path17.join(GUIDES_DIR, `${guide}.md`);
+    const dest = path17.join(guidesTarget, `${guide}.md`);
     if (await fs5.pathExists(src)) {
       await fs5.copy(src, dest, { overwrite: true });
       copied.push(guide);
@@ -1521,16 +1629,16 @@ async function copyGuides(targetDir) {
 }
 // src/copier/docs.ts
-import path17 from "path";
+import path18 from "path";
 import fs6 from "fs-extra";
 var DOC_SCAFFOLDS = ["mistakes-log", "decisions-log", "time-log"];
 async function scaffoldDocs(targetDir) {
-  const docsTarget = path17.join(targetDir, "docs");
+  const docsTarget = path18.join(targetDir, "docs");
   await fs6.ensureDir(docsTarget);
   const created = [];
   for (const doc of DOC_SCAFFOLDS) {
-    const src = path17.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
-    const dest = path17.join(docsTarget, `${doc}.md`);
+    const src = path18.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
+    const dest = path18.join(docsTarget, `${doc}.md`);
     if (await fs6.pathExists(dest)) {
       continue;
     }
@@ -1543,7 +1651,7 @@ async function scaffoldDocs(targetDir) {
 }
 // src/copier/agents.ts
-import path18 from "path";
+import path19 from "path";
 import fs7 from "fs-extra";
 var UNIVERSAL_AGENTS = [
   "planner",
@@ -1575,22 +1683,22 @@ var CONDITIONAL_AGENTS = [
   }
 ];
 async function copyAgents(targetDir, scan) {
-  const agentsTarget = path18.join(targetDir, ".claude", "agents");
+  const agentsTarget = path19.join(targetDir, ".claude", "agents");
   await fs7.ensureDir(agentsTarget);
   const copied = [];
   for (const agent of UNIVERSAL_AGENTS) {
-    const src = path18.join(AGENTS_DIR, `${agent}.md`);
+    const src = path19.join(AGENTS_DIR, `${agent}.md`);
     if (!await fs7.pathExists(src)) continue;
-    await fs7.copy(src, path18.join(agentsTarget, `${agent}.md`), {
+    await fs7.copy(src, path19.join(agentsTarget, `${agent}.md`), {
       overwrite: true
     });
     copied.push(agent);
   }
   for (const { name, condition } of CONDITIONAL_AGENTS) {
     if (!condition(scan)) continue;
-    const src = path18.join(AGENTS_DIR, `${name}.md`);
+    const src = path19.join(AGENTS_DIR, `${name}.md`);
     if (!await fs7.pathExists(src)) continue;
-    await fs7.copy(src, path18.join(agentsTarget, `${name}.md`), {
+    await fs7.copy(src, path19.join(agentsTarget, `${name}.md`), {
       overwrite: true
     });
     copied.push(name);
@@ -1599,17 +1707,17 @@ async function copyAgents(targetDir, scan) {
 }
 // src/copier/contexts.ts
-import path19 from "path";
+import path20 from "path";
 import fs8 from "fs-extra";
 var AVAILABLE_CONTEXTS = ["dev", "review", "research"];
 async function copyContexts(targetDir) {
-  const contextsTarget = path19.join(targetDir, ".claude", "contexts");
+  const contextsTarget = path20.join(targetDir, ".claude", "contexts");
   await fs8.ensureDir(contextsTarget);
   const copied = [];
   for (const context of AVAILABLE_CONTEXTS) {
-    const src = path19.join(CONTEXTS_DIR, `${context}.md`);
+    const src = path20.join(CONTEXTS_DIR, `${context}.md`);
     if (!await fs8.pathExists(src)) continue;
-    await fs8.copy(src, path19.join(contextsTarget, `${context}.md`), {
+    await fs8.copy(src, path20.join(contextsTarget, `${context}.md`), {
       overwrite: true
     });
     copied.push(context);
@@ -1619,10 +1727,10 @@ async function copyContexts(targetDir) {
 // src/commands/init.ts
 async function initCommand(targetPath) {
-  const projectDir = path20.resolve(targetPath || process.cwd());
+  const projectDir = path21.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Project Setup");
   logInfo(`Scanning: ${projectDir}`);
-  const configPath = path20.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
   let savedConfig = null;
   let reuseMode = false;
   if (fileExists(configPath)) {
@@ -1799,7 +1907,7 @@ async function selectHookProfile() {
   });
 }
 async function selectConflictStrategy(projectDir) {
-  const hasExisting = fileExists(path20.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path20.join(projectDir, GENERATED_FILES.cursorRules));
+  const hasExisting = fileExists(path21.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path21.join(projectDir, GENERATED_FILES.cursorRules));
   if (!hasExisting) return "overwrite";
   return select({
     message: "Existing AI config files detected. How should we handle conflicts?",
@@ -1829,7 +1937,7 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     docs: []
   };
   if (tools.claude) {
-    const claudeMdPath = path20.join(projectDir, GENERATED_FILES.claudeMd);
+    const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
     if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
       const content = generateClaudeMd(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
       await fs9.writeFile(claudeMdPath, content, "utf-8");
@@ -1841,14 +1949,14 @@ 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 = path20.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path21.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs9.ensureDir(path20.dirname(settingsLocalPath));
+    await fs9.ensureDir(path21.dirname(settingsLocalPath));
     await fs9.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     result.hooks = true;
   }
   if (tools.cursor) {
-    const cursorPath = path20.join(projectDir, GENERATED_FILES.cursorRules);
+    const cursorPath = path21.join(projectDir, GENERATED_FILES.cursorRules);
     if (conflict === "overwrite" || !fileExists(cursorPath)) {
       const content = generateCursorRules(scan, { strictness: opts?.strictness, customFragments: opts?.customFragments });
       await fs9.writeFile(cursorPath, content, "utf-8");
@@ -1856,11 +1964,11 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     } else {
       logWarning(".cursorrules exists, skipping");
     }
-    const mdcDir = path20.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    const mdcDir = path21.join(projectDir, GENERATED_FILES.cursorMdcDir);
     await fs9.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs9.writeFile(path20.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs9.writeFile(path21.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     result.cursorMdcFiles = mdcFiles.length;
   }
@@ -1879,7 +1987,7 @@ async function generate(projectDir, scan, tools, conflict, opts) {
     tools
   });
   await fs9.writeJson(
-    path20.join(projectDir, AI_KIT_CONFIG_FILE),
+    path21.join(projectDir, AI_KIT_CONFIG_FILE),
     config,
     { spaces: 2 }
   );
@@ -1955,13 +2063,13 @@ function showRecommendations(scan) {
 }
 // src/commands/update.ts
-import path21 from "path";
+import path22 from "path";
 import fs10 from "fs-extra";
 import ora2 from "ora";
 import { confirm as confirm2 } from "@inquirer/prompts";
 async function updateCommand(targetPath) {
-  const projectDir = path21.resolve(targetPath || process.cwd());
-  const configPath = path21.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path22.resolve(targetPath || process.cwd());
+  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
   if (!fileExists(configPath)) {
     logError("No ai-kit.config.json found. Run `ai-kit init` first.");
     return;
@@ -1986,6 +2094,16 @@ async function updateCommand(targetPath) {
   const spinner = ora2("Re-scanning project...").start();
   const scan = await scanProject(projectDir);
   spinner.succeed("Project re-scanned");
+  const filesToBackup = [
+    GENERATED_FILES.claudeMd,
+    GENERATED_FILES.cursorRules,
+    GENERATED_FILES.claudeSettingsLocal,
+    AI_KIT_CONFIG_FILE
+  ];
+  const backupPath = await backupFiles(projectDir, filesToBackup);
+  if (backupPath) {
+    logSuccess(`Backed up current configs to ${path22.relative(projectDir, backupPath)}`);
+  }
   logSection("Updating Files");
   const strictness = existingConfig.strictness || "standard";
   const hookProfile = existingConfig.hookProfile || "standard";
@@ -1994,8 +2112,8 @@ async function updateCommand(targetPath) {
   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 (tools.claude && (existingConfig.templates.includes("CLAUDE.md") || fileExists(path21.join(projectDir, GENERATED_FILES.claudeMd)))) {
-    const claudeMdPath = path21.join(projectDir, GENERATED_FILES.claudeMd);
+  if (tools.claude && (existingConfig.templates.includes("CLAUDE.md") || fileExists(path22.join(projectDir, GENERATED_FILES.claudeMd)))) {
+    const claudeMdPath = path22.join(projectDir, GENERATED_FILES.claudeMd);
     const newContent = generateClaudeMd(scan, genOpts);
     const existing = readFileSafe(claudeMdPath);
     if (existing) {
@@ -2006,8 +2124,8 @@ async function updateCommand(targetPath) {
     templates.push("CLAUDE.md");
     logSuccess("CLAUDE.md updated");
   }
-  if (tools.cursor && (existingConfig.templates.includes(".cursorrules") || fileExists(path21.join(projectDir, GENERATED_FILES.cursorRules)))) {
-    const cursorRulesPath = path21.join(projectDir, GENERATED_FILES.cursorRules);
+  if (tools.cursor && (existingConfig.templates.includes(".cursorrules") || fileExists(path22.join(projectDir, GENERATED_FILES.cursorRules)))) {
+    const cursorRulesPath = path22.join(projectDir, GENERATED_FILES.cursorRules);
     const newContent = generateCursorRules(scan, genOpts);
     const existing = readFileSafe(cursorRulesPath);
     if (existing) {
@@ -2017,11 +2135,11 @@ async function updateCommand(targetPath) {
     }
     templates.push(".cursorrules");
     logSuccess(".cursorrules updated");
-    const mdcDir = path21.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    const mdcDir = path22.join(projectDir, GENERATED_FILES.cursorMdcDir);
     await fs10.ensureDir(mdcDir);
     const mdcFiles = generateMdcFiles(scan);
     for (const mdc of mdcFiles) {
-      await fs10.writeFile(path21.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+      await fs10.writeFile(path22.join(mdcDir, mdc.filename), mdc.content, "utf-8");
     }
     logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
   }
@@ -2032,9 +2150,9 @@ async function updateCommand(targetPath) {
   const contexts = await copyContexts(projectDir);
   logSuccess(`${contexts.length} context modes updated (.claude/contexts/)`);
   if (existingConfig.hooks !== false) {
-    const settingsLocalPath = path21.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+    const settingsLocalPath = path22.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
     const settingsLocal = generateSettingsLocal(scan, hookProfile);
-    await fs10.ensureDir(path21.dirname(settingsLocalPath));
+    await fs10.ensureDir(path22.dirname(settingsLocalPath));
     await fs10.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
     logSuccess(`Hooks updated (profile: ${hookProfile})`);
   }
@@ -2052,14 +2170,17 @@ async function updateCommand(targetPath) {
   logSuccess("ai-kit.config.json updated");
   console.log("");
   logInfo("All AI configs refreshed with latest project scan.");
+  if (backupPath) {
+    logInfo("Rollback available: `ai-kit rollback --latest`");
+  }
 }
 // src/commands/reset.ts
-import path22 from "path";
+import path23 from "path";
 import fs11 from "fs-extra";
 import { confirm as confirm3 } from "@inquirer/prompts";
 async function resetCommand(targetPath) {
-  const projectDir = path22.resolve(targetPath || process.cwd());
+  const projectDir = path23.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Reset");
   logWarning("This will remove all AI Kit generated files:");
   logInfo(`  - ${GENERATED_FILES.claudeMd}`);
@@ -2080,42 +2201,42 @@ async function resetCommand(targetPath) {
     return;
   }
   const removed = [];
-  const claudeMdPath = path22.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path23.join(projectDir, GENERATED_FILES.claudeMd);
   if (fileExists(claudeMdPath)) {
     await fs11.remove(claudeMdPath);
     removed.push(GENERATED_FILES.claudeMd);
   }
-  const cursorPath = path22.join(projectDir, GENERATED_FILES.cursorRules);
+  const cursorPath = path23.join(projectDir, GENERATED_FILES.cursorRules);
   if (fileExists(cursorPath)) {
     await fs11.remove(cursorPath);
     removed.push(GENERATED_FILES.cursorRules);
   }
-  const cursorMdcDir = path22.join(projectDir, GENERATED_FILES.cursorMdcDir);
+  const cursorMdcDir = path23.join(projectDir, GENERATED_FILES.cursorMdcDir);
   if (fileExists(cursorMdcDir)) {
     await fs11.remove(cursorMdcDir);
     removed.push(GENERATED_FILES.cursorMdcDir);
   }
-  const commandsDir = path22.join(projectDir, GENERATED_FILES.claudeCommands);
+  const commandsDir = path23.join(projectDir, GENERATED_FILES.claudeCommands);
   if (fileExists(commandsDir)) {
     await fs11.remove(commandsDir);
     removed.push(GENERATED_FILES.claudeCommands);
   }
-  const claudeSkillsDir = path22.join(projectDir, GENERATED_FILES.claudeSkills);
+  const claudeSkillsDir = path23.join(projectDir, GENERATED_FILES.claudeSkills);
   if (fileExists(claudeSkillsDir)) {
     await fs11.remove(claudeSkillsDir);
     removed.push(GENERATED_FILES.claudeSkills);
   }
-  const cursorSkillsDir = path22.join(projectDir, GENERATED_FILES.cursorSkills);
+  const cursorSkillsDir = path23.join(projectDir, GENERATED_FILES.cursorSkills);
   if (fileExists(cursorSkillsDir)) {
     await fs11.remove(cursorSkillsDir);
     removed.push(GENERATED_FILES.cursorSkills);
   }
-  const aiKitDir = path22.join(projectDir, "ai-kit");
+  const aiKitDir = path23.join(projectDir, "ai-kit");
   if (fileExists(aiKitDir)) {
     await fs11.remove(aiKitDir);
     removed.push("ai-kit/");
   }
-  const configPath = path22.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path23.join(projectDir, AI_KIT_CONFIG_FILE);
   if (fileExists(configPath)) {
     await fs11.remove(configPath);
     removed.push(AI_KIT_CONFIG_FILE);
@@ -2129,7 +2250,7 @@ async function resetCommand(targetPath) {
 }
 // src/commands/tokens.ts
-import path23 from "path";
+import path24 from "path";
 import fs12 from "fs-extra";
 import chalk2 from "chalk";
 import ora3 from "ora";
@@ -2140,14 +2261,14 @@ var PRICING = {
 };
 var PLAN_BUDGET = 20;
 function findSessionFiles() {
-  const claudeDir = path23.join(os.homedir(), ".claude", "projects");
+  const claudeDir = path24.join(os.homedir(), ".claude", "projects");
   if (!fs12.existsSync(claudeDir)) return [];
   const files = [];
   function walkDir(dir) {
     try {
       const entries = fs12.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const full = path23.join(dir, entry.name);
+        const full = path24.join(dir, entry.name);
         if (entry.isDirectory()) {
           walkDir(full);
         } else if (entry.name.endsWith(".jsonl")) {
@@ -2202,8 +2323,8 @@ function parseSessionFile(filePath) {
       const stat = fs12.statSync(filePath);
       sessionDate = stat.mtime.toISOString().slice(0, 10);
     }
-    const sessionId = path23.basename(filePath, ".jsonl");
-    const projectName = path23.basename(path23.dirname(filePath));
+    const sessionId = path24.basename(filePath, ".jsonl");
+    const projectName = path24.basename(path24.dirname(filePath));
     return {
       sessionId,
       filePath,
@@ -2432,7 +2553,7 @@ ${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
   );
   console.log("");
   if (options.csv) {
-    const csvPath = path23.join(process.cwd(), "token-usage.csv");
+    const csvPath = path24.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(
@@ -2475,9 +2596,9 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
     }
   };
   const outputDir = process.cwd();
-  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");
+  const dataPath = path24.join(outputDir, "token-data.json");
+  const dashboardSrc = path24.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
+  const dashboardDest = path24.join(outputDir, "token-dashboard.html");
   await fs12.writeJson(dataPath, exportData, { spaces: 2 });
   logInfo(`Token data written to ${dataPath}`);
   if (await fs12.pathExists(dashboardSrc)) {
@@ -2498,12 +2619,12 @@ async function exportDashboard(allSessions, todaySessions, weekSessions, monthSe
 }
 // src/commands/doctor.ts
-import path24 from "path";
+import path25 from "path";
 import chalk3 from "chalk";
 import ora4 from "ora";
 async function doctorCommand(targetPath) {
-  const projectDir = path24.resolve(targetPath || process.cwd());
-  const configPath = path24.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path25.resolve(targetPath || process.cwd());
+  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
   let passed = 0;
   let warnings = 0;
   let issues = 0;
@@ -2535,7 +2656,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 = path24.join(projectDir, templateFile);
+    const templatePath = path25.join(projectDir, templateFile);
     if (fileExists(templatePath)) {
       logSuccess(`${template} exists and in sync`);
       passed++;
@@ -2546,8 +2667,8 @@ async function doctorCommand(targetPath) {
   }
   const missingSkills = [];
   for (const skill of config.commands) {
-    const claudeSkillPath = path24.join(projectDir, GENERATED_FILES.claudeSkills, skill);
-    const cursorSkillPath = path24.join(projectDir, GENERATED_FILES.cursorSkills, skill);
+    const claudeSkillPath = path25.join(projectDir, GENERATED_FILES.claudeSkills, skill);
+    const cursorSkillPath = path25.join(projectDir, GENERATED_FILES.cursorSkills, skill);
     if (!fileExists(claudeSkillPath) && !fileExists(cursorSkillPath)) {
       missingSkills.push(skill);
     }
@@ -2561,10 +2682,10 @@ async function doctorCommand(targetPath) {
     );
     issues++;
   }
-  const guidesDir = path24.join(projectDir, "ai-kit", "guides");
+  const guidesDir = path25.join(projectDir, "ai-kit", "guides");
   const missingGuides = [];
   for (const guide of config.guides) {
-    const guidePath = path24.join(guidesDir, guide);
+    const guidePath = path25.join(guidesDir, guide);
     if (!fileExists(guidePath)) {
       missingGuides.push(guide);
     }
@@ -2702,13 +2823,13 @@ function compareScanResults(previous, current) {
 }
 // src/commands/diff.ts
-import path25 from "path";
+import path26 from "path";
 import fs13 from "fs-extra";
 import chalk4 from "chalk";
 import ora5 from "ora";
 async function diffCommand(targetPath) {
-  const projectDir = path25.resolve(targetPath || process.cwd());
-  const configPath = path25.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path26.resolve(targetPath || process.cwd());
+  const configPath = path26.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.");
@@ -2775,11 +2896,11 @@ async function diffCommand(targetPath) {
   if (cursorRulesStatus.status === "modified") modified++;
   else if (cursorRulesStatus.status === "added") added++;
   else unchanged++;
-  const skillsDir = path25.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path26.join(projectDir, GENERATED_FILES.claudeSkills);
   const skillCount = countFilesInDir(skillsDir);
   console.log(chalk4.dim(`  unchanged ${GENERATED_FILES.claudeSkills}/ (${skillCount} skills)`));
   unchanged++;
-  const guidesDir = path25.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
+  const guidesDir = path26.join(projectDir, AI_KIT_FOLDER_NAME, "guides");
   const guideCount = existingConfig.guides?.length || 0;
   console.log(chalk4.dim(`  unchanged ai-kit/guides/ (${guideCount} guides)`));
   unchanged++;
@@ -2888,7 +3009,7 @@ function diffStack(oldScan, newScan) {
   return changes;
 }
 function diffGeneratedFile(projectDir, filename, config, generate2, oldFragments, newFragments) {
-  const filePath = path25.join(projectDir, filename);
+  const filePath = path26.join(projectDir, filename);
   const currentContent = readFileSafe(filePath);
   const newContent = generate2();
   if (!currentContent) {
@@ -2934,7 +3055,7 @@ function countFilesInDir(dirPath) {
 }
 // src/commands/export.ts
-import path26 from "path";
+import path27 from "path";
 import fs14 from "fs-extra";
 import ora6 from "ora";
 import { select as select2 } from "@inquirer/prompts";
@@ -2971,9 +3092,9 @@ function toCline(content) {
 ${stripped}`;
 }
 async function exportCommand(targetPath, options) {
-  const projectDir = path26.resolve(targetPath || process.cwd());
-  const configPath = path26.join(projectDir, AI_KIT_CONFIG_FILE);
-  const claudeMdPath = path26.join(projectDir, GENERATED_FILES.claudeMd);
+  const projectDir = path27.resolve(targetPath || process.cwd());
+  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
+  const claudeMdPath = path27.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.");
@@ -3015,7 +3136,7 @@ async function exportCommand(targetPath, options) {
   for (const fmt2 of formats) {
     const target = EXPORT_TARGETS[fmt2];
     const transformer = transformers[fmt2];
-    const outputPath = path26.join(projectDir, target.file);
+    const outputPath = path27.join(projectDir, target.file);
     const transformed = transformer(claudeContent);
     await fs14.writeFile(outputPath, transformed, "utf-8");
     exported++;
@@ -3033,7 +3154,7 @@ async function exportCommand(targetPath, options) {
 }
 // src/commands/stats.ts
-import path27 from "path";
+import path28 from "path";
 import chalk5 from "chalk";
 var SKILL_CATEGORIES = {
   "Getting Started": ["prompt-help", "understand"],
@@ -3136,8 +3257,8 @@ var MCP_DISPLAY_NAMES = {
   perplexity: "Perplexity"
 };
 async function statsCommand(targetPath) {
-  const projectDir = path27.resolve(targetPath || process.cwd());
-  const configPath = path27.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path28.resolve(targetPath || process.cwd());
+  const configPath = path28.join(projectDir, AI_KIT_CONFIG_FILE);
   logSection("AI Kit \u2014 Project Stats");
   console.log("");
   if (!fileExists(configPath)) {
@@ -3231,21 +3352,21 @@ async function statsCommand(targetPath) {
 }
 // src/commands/audit.ts
-import path28 from "path";
+import path29 from "path";
 import fs15 from "fs-extra";
 import chalk6 from "chalk";
 async function auditCommand(targetPath) {
-  const projectDir = path28.resolve(targetPath || process.cwd());
+  const projectDir = path29.resolve(targetPath || process.cwd());
   logSection("AI Kit \u2014 Security & Configuration Audit");
   logInfo(`Auditing: ${projectDir}`);
   const checks = [];
-  const configPath = path28.join(projectDir, AI_KIT_CONFIG_FILE);
+  const configPath = path29.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 = path28.join(projectDir, GENERATED_FILES.claudeMd);
+  const claudeMdPath = path29.join(projectDir, GENERATED_FILES.claudeMd);
   const claudeMd = readFileSafe(claudeMdPath);
   if (claudeMd) {
     if (claudeMd.includes("AI-KIT:START") && claudeMd.includes("AI-KIT:END")) {
@@ -3270,7 +3391,7 @@ async function auditCommand(targetPath) {
       checks.push({ name: "Secrets in CLAUDE.md", status: "pass", message: "No secrets detected" });
     }
   }
-  const settingsLocalPath = path28.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
+  const settingsLocalPath = path29.join(projectDir, GENERATED_FILES.claudeSettingsLocal);
   if (fileExists(settingsLocalPath)) {
     const settings2 = readJsonSafe(settingsLocalPath);
     if (settings2?.hooks) {
@@ -3281,14 +3402,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 = path28.join(projectDir, GENERATED_FILES.claudeAgents);
+  const agentsDir = path29.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(path28.join(agentsDir, file));
+        const content = readFileSafe(path29.join(agentsDir, file));
         if (content && !content.startsWith("---")) {
           invalidAgents++;
         }
@@ -3302,18 +3423,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 = path28.join(projectDir, GENERATED_FILES.claudeContexts);
+  const contextsDir = path29.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 = path28.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path29.join(projectDir, GENERATED_FILES.claudeSkills);
   if (await fs15.pathExists(skillsDir)) {
     const skillDirs = (await fs15.readdir(skillsDir)).filter(async (f) => {
       try {
-        return (await fs15.stat(path28.join(skillsDir, f))).isDirectory();
+        return (await fs15.stat(path29.join(skillsDir, f))).isDirectory();
       } catch {
         return false;
       }
@@ -3322,7 +3443,7 @@ async function auditCommand(targetPath) {
   } else {
     checks.push({ name: "Skills", status: "warn", message: "No skills directory" });
   }
-  const gitignorePath = path28.join(projectDir, ".gitignore");
+  const gitignorePath = path29.join(projectDir, ".gitignore");
   const gitignore = readFileSafe(gitignorePath);
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
@@ -3338,7 +3459,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 = path28.join(projectDir, ".claude", "settings.json");
+  const settingsPath = path29.join(projectDir, ".claude", "settings.json");
   const settings = readFileSafe(settingsPath);
   if (settings) {
     const hasEnvVarsInSettings = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settings);
@@ -3371,7 +3492,7 @@ async function auditCommand(targetPath) {
 }
 // src/commands/health.ts
-import path29 from "path";
+import path30 from "path";
 import fs16 from "fs-extra";
 import chalk7 from "chalk";
 import ora7 from "ora";
@@ -3413,7 +3534,7 @@ function checkSetup(projectDir, config) {
       detail: `config v${config.version} \u2260 CLI v${VERSION} \u2014 run \`ai-kit update\``
     });
   }
-  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path30.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) {
@@ -3421,19 +3542,19 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "CLAUDE.md", status: "fail", detail: "Not found" });
   }
-  if (fileExists(path29.join(projectDir, GENERATED_FILES.cursorRules))) {
+  if (fileExists(path30.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 = path29.join(projectDir, GENERATED_FILES.claudeSkills);
+  const skillsDir = path30.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 = path29.join(projectDir, GENERATED_FILES.claudeAgents);
+  const agentsDir = path30.join(projectDir, GENERATED_FILES.claudeAgents);
   if (dirExists(agentsDir)) {
     try {
       const agentFiles = fs16.readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
@@ -3444,7 +3565,7 @@ function checkSetup(projectDir, config) {
   } else {
     checks.push({ name: "Agents", status: "warn", detail: "Not configured" });
   }
-  const settingsLocal = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
+  const settingsLocal = readFileSafe(path30.join(projectDir, GENERATED_FILES.claudeSettingsLocal));
   if (settingsLocal && settingsLocal.includes('"hooks"')) {
     checks.push({ name: "Hooks", status: "pass", detail: "Configured" });
   } else {
@@ -3454,7 +3575,7 @@ function checkSetup(projectDir, config) {
 }
 function checkSecurity(projectDir) {
   const checks = [];
-  const claudeMd = readFileSafe(path29.join(projectDir, GENERATED_FILES.claudeMd));
+  const claudeMd = readFileSafe(path30.join(projectDir, GENERATED_FILES.claudeMd));
   if (claudeMd) {
     const secretPatterns = [
       /(?:api[_-]?key|secret|token|password|credential)\s*[:=]\s*['"][^'"]+['"]/i,
@@ -3469,7 +3590,7 @@ function checkSecurity(projectDir) {
       detail: hasSecrets ? "Potential secrets detected \u2014 remove immediately" : "Clean"
     });
   }
-  const gitignore = readFileSafe(path29.join(projectDir, ".gitignore"));
+  const gitignore = readFileSafe(path30.join(projectDir, ".gitignore"));
   if (gitignore) {
     const envIgnored = gitignore.includes(".env") || gitignore.includes(".env.local");
     checks.push({
@@ -3478,7 +3599,7 @@ function checkSecurity(projectDir) {
       detail: envIgnored ? "Protected" : "NOT gitignored \u2014 add .env to .gitignore"
     });
   }
-  const settingsJson = readFileSafe(path29.join(projectDir, ".claude", "settings.json"));
+  const settingsJson = readFileSafe(path30.join(projectDir, ".claude", "settings.json"));
   if (settingsJson) {
     const hasHardcoded = /(?:api[_-]?key|token|secret|password)\s*[:=]\s*"[^"]+"/i.test(settingsJson);
     checks.push({
@@ -3587,7 +3708,7 @@ function checkDocs(projectDir) {
     { name: "Time Log", path: "docs/time-log.md" }
   ];
   for (const doc of docsToCheck) {
-    const content = readFileSafe(path29.join(projectDir, doc.path));
+    const content = readFileSafe(path30.join(projectDir, doc.path));
     if (content) {
       const hasEntries = content.includes("## 20") || content.split("---").length > 2;
       checks.push({
@@ -3602,8 +3723,8 @@ function checkDocs(projectDir) {
   return { title: "Documentation", checks };
 }
 async function healthCommand(targetPath) {
-  const projectDir = path29.resolve(targetPath || process.cwd());
-  const configPath = path29.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 Project Health");
   console.log(chalk7.dim(`  ${projectDir}`));
@@ -3687,7 +3808,7 @@ async function healthCommand(targetPath) {
 }
 // src/commands/patterns.ts
-import path30 from "path";
+import path31 from "path";
 import fs17 from "fs-extra";
 import chalk8 from "chalk";
 import ora8 from "ora";
@@ -3774,7 +3895,7 @@ function walkTsFiles(dir, files) {
   try {
     const entries = fs17.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path30.join(dir, entry.name);
+      const full = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS.includes(entry.name)) continue;
         walkTsFiles(full, files);
@@ -3786,8 +3907,8 @@ function walkTsFiles(dir, files) {
   }
 }
 async function patternsCommand(targetPath) {
-  const projectDir = path30.resolve(targetPath || process.cwd());
-  const configPath = path30.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path31.resolve(targetPath || process.cwd());
+  const configPath = path31.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Pattern Library");
   console.log(chalk8.dim(`  ${projectDir}`));
@@ -3798,7 +3919,7 @@ async function patternsCommand(targetPath) {
   }
   const spinner = ora8("Scanning for code patterns...").start();
   const files = [];
-  const srcDir = path30.join(projectDir, "src");
+  const srcDir = path31.join(projectDir, "src");
   if (dirExists(srcDir)) {
     walkTsFiles(srcDir, files);
   } else {
@@ -3820,7 +3941,7 @@ async function patternsCommand(targetPath) {
           if (pattern.regex.test(lines2[i])) {
             pattern.matches.push({
               pattern: pattern.label,
-              file: path30.relative(projectDir, file),
+              file: path31.relative(projectDir, file),
               line: i + 1
             });
           }
@@ -3848,9 +3969,9 @@ async function patternsCommand(targetPath) {
     logInfo("No recognizable patterns found.");
     return;
   }
-  const outputDir = path30.join(projectDir, "ai-kit");
+  const outputDir = path31.join(projectDir, "ai-kit");
   fs17.ensureDirSync(outputDir);
-  const outputPath = path30.join(outputDir, "patterns.md");
+  const outputPath = path31.join(outputDir, "patterns.md");
   const lines = [
     "# Code Patterns",
     "",
@@ -3891,13 +4012,13 @@ async function patternsCommand(targetPath) {
 }
 // src/commands/dead-code.ts
-import path32 from "path";
+import path33 from "path";
 import fs19 from "fs-extra";
 import chalk9 from "chalk";
 import ora9 from "ora";
 // src/scanner/components.ts
-import path31 from "path";
+import path32 from "path";
 import fs18 from "fs-extra";
 var COMPONENT_DIRS = [
   "src/components",
@@ -3925,7 +4046,7 @@ function findComponentFiles(projectPath) {
   const files = [];
   const directories = /* @__PURE__ */ new Set();
   for (const dir of COMPONENT_DIRS) {
-    const fullDir = path31.join(projectPath, dir);
+    const fullDir = path32.join(projectPath, dir);
     if (dirExists(fullDir)) {
       walkForComponents(fullDir, files, directories);
     }
@@ -3936,7 +4057,7 @@ function walkForComponents(dir, files, directories) {
   try {
     const entries = fs18.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path31.join(dir, entry.name);
+      const full = path32.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_PATTERNS.includes(entry.name)) continue;
         walkForComponents(full, files, directories);
@@ -3976,7 +4097,7 @@ function extractComponentName(filePath, content) {
     /export\s+(?:const|function)\s+(\w+)/
   );
   if (namedExport) return namedExport[1];
-  return path31.basename(filePath, ".tsx");
+  return path32.basename(filePath, ".tsx");
 }
 function extractExportType(content) {
   const hasDefault = /export\s+default\s/.test(content);
@@ -4065,7 +4186,7 @@ function extractDependencies(content) {
   for (const match of imports) {
     const importPath = match[1];
     if (importPath.startsWith(".") || importPath.startsWith("..")) {
-      const basename = path31.basename(importPath).replace(/\.\w+$/, "");
+      const basename = path32.basename(importPath).replace(/\.\w+$/, "");
       if (/^[A-Z]/.test(basename)) {
         deps.push(basename);
       }
@@ -4074,33 +4195,33 @@ function extractDependencies(content) {
   return deps;
 }
 function checkForTests(componentPath, componentName) {
-  const dir = path31.dirname(componentPath);
-  const base = path31.basename(componentPath, ".tsx");
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
   for (const suffix of TEST_SUFFIXES) {
-    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, base + suffix))) return true;
   }
-  const testsDir = path31.join(dir, "__tests__");
+  const testsDir = path32.join(dir, "__tests__");
   if (dirExists(testsDir)) {
     for (const suffix of TEST_SUFFIXES) {
-      if (fs18.existsSync(path31.join(testsDir, base + suffix))) return true;
-      if (fs18.existsSync(path31.join(testsDir, componentName + suffix))) return true;
+      if (fs18.existsSync(path32.join(testsDir, base + suffix))) return true;
+      if (fs18.existsSync(path32.join(testsDir, componentName + suffix))) return true;
     }
   }
   return false;
 }
 function checkForStory(componentPath, componentName) {
-  const dir = path31.dirname(componentPath);
-  const base = path31.basename(componentPath, ".tsx");
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
   for (const suffix of STORY_SUFFIXES) {
-    if (fs18.existsSync(path31.join(dir, base + suffix))) return true;
-    if (fs18.existsSync(path31.join(dir, componentName + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, base + suffix))) return true;
+    if (fs18.existsSync(path32.join(dir, componentName + suffix))) return true;
   }
   return false;
 }
 function checkForAiDoc(componentPath) {
-  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"));
+  const dir = path32.dirname(componentPath);
+  const base = path32.basename(componentPath, ".tsx");
+  return fs18.existsSync(path32.join(dir, `${base}.ai.md`)) || fs18.existsSync(path32.join(dir, "component.ai.md"));
 }
 function categorizeComponent(relativePath) {
   const lower = relativePath.toLowerCase();
@@ -4118,7 +4239,7 @@ function parseComponent(filePath, projectPath) {
   const content = readFileSafe(filePath);
   if (!content) return null;
   const name = extractComponentName(filePath, content);
-  const relativePath = path31.relative(projectPath, filePath);
+  const relativePath = path32.relative(projectPath, filePath);
   return {
     name,
     filePath,
@@ -4166,7 +4287,7 @@ function collectAllFiles(dir, files) {
   try {
     const entries = fs19.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const full = path32.join(dir, entry.name);
+      const full = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORE_DIRS2.includes(entry.name)) continue;
         collectAllFiles(full, files);
@@ -4178,12 +4299,12 @@ function collectAllFiles(dir, files) {
   }
 }
 function isTestOrStoryFile(filePath) {
-  const name = path32.basename(filePath).toLowerCase();
+  const name = path33.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 = path32.resolve(targetPath || process.cwd());
-  const configPath = path32.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 Dead Code Report");
   console.log(chalk9.dim(`  ${projectDir}`));
@@ -4200,7 +4321,7 @@ async function deadCodeCommand(targetPath) {
   }
   spinner.text = `Found ${scanResult.components.length} components. Checking imports...`;
   const allFiles = [];
-  const srcDir = path32.join(projectDir, "src");
+  const srcDir = path33.join(projectDir, "src");
   if (fs19.existsSync(srcDir)) {
     collectAllFiles(srcDir, allFiles);
   } else {
@@ -4224,7 +4345,7 @@ async function deadCodeCommand(targetPath) {
       `(?:import|from)\\s+.*['"][^'"]*(?:/|\\b)${escapeRegex(component.name)}(?:[/'"]|\\b)`
     );
     for (const [file, content] of fileContents) {
-      if (path32.resolve(file) === path32.resolve(componentFile)) continue;
+      if (path33.resolve(file) === path33.resolve(componentFile)) continue;
       if (namePattern.test(content)) {
         importCount++;
         if (isTestOrStoryFile(file)) {
@@ -4303,7 +4424,7 @@ function escapeRegex(str) {
 }
 // src/commands/drift.ts
-import path33 from "path";
+import path34 from "path";
 import fs20 from "fs-extra";
 import chalk10 from "chalk";
 import ora10 from "ora";
@@ -4340,11 +4461,11 @@ function parseAiDocFrontmatter(content) {
   return { props, fields };
 }
 function findAiDocPath(componentPath) {
-  const dir = path33.dirname(componentPath);
-  const base = path33.basename(componentPath, ".tsx");
+  const dir = path34.dirname(componentPath);
+  const base = path34.basename(componentPath, ".tsx");
   const candidates = [
-    path33.join(dir, `${base}.ai.md`),
-    path33.join(dir, "component.ai.md")
+    path34.join(dir, `${base}.ai.md`),
+    path34.join(dir, "component.ai.md")
   ];
   for (const candidate of candidates) {
     if (fs20.existsSync(candidate)) return candidate;
@@ -4388,8 +4509,8 @@ function analyzeDrift(component, projectDir) {
   };
 }
 async function driftCommand(targetPath) {
-  const projectDir = path33.resolve(targetPath || process.cwd());
-  const configPath = path33.join(projectDir, AI_KIT_CONFIG_FILE);
+  const projectDir = path34.resolve(targetPath || process.cwd());
+  const configPath = path34.join(projectDir, AI_KIT_CONFIG_FILE);
   console.log("");
   logSection("AI Kit \u2014 Component Drift Detector");
   console.log(chalk10.dim(`  ${projectDir}`));
@@ -4491,7 +4612,7 @@ async function driftCommand(targetPath) {
 }
 // src/commands/component-registry.ts
-import path34 from "path";
+import path35 from "path";
 import fs22 from "fs-extra";
 import chalk11 from "chalk";
 import ora11 from "ora";
@@ -4516,12 +4637,12 @@ function calculateHealthScore(component) {
 // src/commands/component-registry.ts
 async function componentRegistryCommand(targetPath) {
-  const projectDir = path34.resolve(targetPath || process.cwd());
+  const projectDir = path35.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))) {
+  if (!fileExists(path35.join(projectDir, AI_KIT_CONFIG_FILE))) {
     logWarning("ai-kit.config.json not found. Run `ai-kit init` first.");
     return;
   }
@@ -4555,20 +4676,20 @@ async function componentRegistryCommand(targetPath) {
   for (const entry of entries) {
     categories[entry.category] = (categories[entry.category] || 0) + 1;
   }
-  const pkgPath = path34.join(projectDir, "package.json");
+  const pkgPath = path35.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),
+    projectName: pkg.name || path35.basename(projectDir),
     totalComponents: entries.length,
     categories,
     components: entries
   };
-  const outputPath = path34.join(projectDir, "ai-kit", "component-registry.json");
-  await fs22.ensureDir(path34.dirname(outputPath));
+  const outputPath = path35.join(projectDir, "ai-kit", "component-registry.json");
+  await fs22.ensureDir(path35.dirname(outputPath));
   await fs22.writeJson(outputPath, registry, { spaces: 2 });
-  const mdPath = path34.join(projectDir, "ai-kit", "component-registry.md");
+  const mdPath = path35.join(projectDir, "ai-kit", "component-registry.md");
   const md = generateRegistryMarkdown(registry);
   await fs22.writeFile(mdPath, md, "utf-8");
   console.log("");
@@ -4628,6 +4749,220 @@ function generateRegistryMarkdown(registry) {
   return lines.join("\n");
 }
+// src/commands/rollback.ts
+import path36 from "path";
+import { select as select3, confirm as confirm4 } from "@inquirer/prompts";
+async function rollbackCommand(targetPath, latest) {
+  const projectDir = path36.resolve(targetPath || process.cwd());
+  const backups = await listBackups(projectDir);
+  if (backups.length === 0) {
+    logInfo("No backups found. Backups are created when you run `ai-kit update`.");
+    return;
+  }
+  logSection("Available Backups");
+  let selected;
+  if (latest) {
+    selected = backups[0];
+    logInfo(`Restoring latest backup: ${selected}`);
+  } else {
+    for (const b of backups) {
+      const label = b === backups[0] ? `${b}  (latest)` : b;
+      logInfo(label);
+    }
+    console.log("");
+    selected = await select3({
+      message: "Which backup do you want to restore?",
+      choices: backups.map((b, i) => ({
+        name: i === 0 ? `${b}  (latest)` : b,
+        value: b
+      }))
+    });
+  }
+  const proceed = await confirm4({
+    message: `Restore configs from backup ${selected}? This will overwrite current files.`,
+    default: true
+  });
+  if (!proceed) {
+    logInfo("Cancelled.");
+    return;
+  }
+  try {
+    const restored = await restoreBackup(projectDir, selected);
+    logSection("Restored Files");
+    for (const file of restored) {
+      logSuccess(`Restored: ${file}`);
+    }
+    console.log("");
+    logInfo(`Configs restored from backup ${selected}`);
+  } catch (err) {
+    logError(`Failed to restore backup: ${String(err)}`);
+  }
+}
+// src/commands/migrate.ts
+import path37 from "path";
+import fs23 from "fs-extra";
+import { confirm as confirm5 } from "@inquirer/prompts";
+import ora12 from "ora";
+var AI_KIT_START2 = "<!-- AI-KIT:START -->";
+var AI_KIT_END2 = "<!-- AI-KIT:END -->";
+var CUSTOM_START = "<!-- CUSTOM RULES (preserved by ai-kit) -->";
+var CUSTOM_END = "<!-- /CUSTOM RULES -->";
+async function migrateCommand(targetPath, opts) {
+  const projectDir = path37.resolve(targetPath || process.cwd());
+  const configPath = path37.join(projectDir, AI_KIT_CONFIG_FILE);
+  const dryRun = opts?.dryRun ?? false;
+  logSection("AI Kit \u2014 Migrate Existing Project");
+  const existingConfig = readJsonSafe(configPath);
+  if (existingConfig) {
+    logInfo("This project is already managed by ai-kit.");
+    logInfo("Use `ai-kit update` to refresh configs.");
+    return;
+  }
+  const claudeMdPath = path37.join(projectDir, GENERATED_FILES.claudeMd);
+  const cursorRulesPath = path37.join(projectDir, GENERATED_FILES.cursorRules);
+  const existingClaudeMd = readFileSafe(claudeMdPath);
+  const existingCursorRules = readFileSafe(cursorRulesPath);
+  if (!existingClaudeMd && !existingCursorRules) {
+    logInfo("No existing AI config files found (CLAUDE.md or .cursorrules).");
+    logInfo("Use `ai-kit init` for a fresh setup.");
+    return;
+  }
+  const spinner = ora12("Scanning project...").start();
+  const scan = await scanProject(projectDir);
+  spinner.succeed("Project scanned");
+  logSection("Detected Stack");
+  const frameworkLabel = scan.framework === "nextjs" ? `Next.js ${scan.nextjsVersion || ""} (${scan.routerType || "unknown"} router)`.trim() : scan.framework;
+  logInfo(`Framework: ${frameworkLabel}`);
+  logInfo(`CMS: ${scan.cms === "none" ? "None" : scan.cms}`);
+  logInfo(`Styling: ${scan.styling.join(", ") || "None"}`);
+  logInfo(`TypeScript: ${scan.typescript ? "Yes" : "No"}`);
+  logInfo(`Package Manager: ${scan.packageManager}`);
+  const customSections = existingClaudeMd ? parseSections(existingClaudeMd) : [];
+  const customFragments = loadCustomFragments(projectDir);
+  const strictness = "standard";
+  const hookProfile = "standard";
+  const tools = {
+    claude: true,
+    cursor: !!existingCursorRules || fileExists(path37.join(projectDir, ".cursor"))
+  };
+  const aiKitClaudeMd = generateClaudeMd(scan, { strictness, customFragments });
+  const aiKitSections = parseSections(
+    aiKitClaudeMd.replace(AI_KIT_START2, "").replace(AI_KIT_END2, "")
+  );
+  logSection("Migration Plan");
+  if (customSections.length > 0) {
+    logInfo(`Your existing CLAUDE.md has ${customSections.length} section(s):`);
+    for (const s of customSections) {
+      logSuccess(`  KEEP: "${s.heading}"`);
+    }
+  }
+  logInfo(`ai-kit will generate ${aiKitSections.length} section(s) for your stack:`);
+  for (const s of aiKitSections) {
+    logInfo(`  + ADD: "${s.heading}"`);
+  }
+  console.log("");
+  logInfo("Your custom sections will be placed at the TOP of the file.");
+  logInfo("ai-kit sections will be wrapped in AI-KIT markers below.");
+  logInfo("Future `ai-kit update` will only touch the marked section.");
+  if (dryRun) {
+    console.log("");
+    logInfo("Dry run \u2014 no files were modified.");
+    return;
+  }
+  console.log("");
+  const proceed = await confirm5({
+    message: "Apply this migration?",
+    default: true
+  });
+  if (!proceed) {
+    logInfo("Cancelled.");
+    return;
+  }
+  const filesToBackup = [
+    GENERATED_FILES.claudeMd,
+    GENERATED_FILES.cursorRules
+  ].filter((f) => fileExists(path37.join(projectDir, f)));
+  if (filesToBackup.length > 0) {
+    const backupPath = await backupFiles(projectDir, filesToBackup);
+    if (backupPath) {
+      logSuccess(
+        `Backed up existing files to ${path37.relative(projectDir, backupPath)}`
+      );
+    }
+  }
+  logSection("Migrating");
+  if (tools.claude) {
+    const customBlock = customSections.length > 0 ? `${CUSTOM_START}
+${customSections.map((s) => s.raw).join("\n\n")}
+${CUSTOM_END}
+` : "";
+    const merged = `${customBlock}${aiKitClaudeMd}`;
+    await fs23.writeFile(claudeMdPath, merged, "utf-8");
+    logSuccess("CLAUDE.md migrated (custom rules preserved at top)");
+  }
+  if (tools.cursor) {
+    const cursorContent = generateCursorRules(scan, {
+      strictness,
+      customFragments
+    });
+    await fs23.writeFile(cursorRulesPath, cursorContent, "utf-8");
+    logSuccess(".cursorrules generated");
+    const mdcDir = path37.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs23.ensureDir(mdcDir);
+    const mdcFiles = generateMdcFiles(scan);
+    for (const mdc of mdcFiles) {
+      await fs23.writeFile(path37.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+    }
+    logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files generated`);
+  }
+  const commands = await copySkills(projectDir);
+  logSuccess(`${commands.length} skills copied`);
+  const agents = await copyAgents(projectDir, scan);
+  logSuccess(`${agents.length} agents copied`);
+  const contexts = await copyContexts(projectDir);
+  logSuccess(`${contexts.length} context modes copied`);
+  const settingsLocalPath = path37.join(
+    projectDir,
+    GENERATED_FILES.claudeSettingsLocal
+  );
+  const settingsLocal = generateSettingsLocal(scan, hookProfile);
+  await fs23.ensureDir(path37.dirname(settingsLocalPath));
+  await fs23.writeJson(settingsLocalPath, settingsLocal, { spaces: 2 });
+  logSuccess(`Hooks configured (profile: ${hookProfile})`);
+  const guides = await copyGuides(projectDir);
+  logSuccess(`${guides.length} guides copied`);
+  const templates = [];
+  if (tools.claude) templates.push("CLAUDE.md");
+  if (tools.cursor) templates.push(".cursorrules");
+  const config = generateConfig(scan, templates, commands, guides, {
+    strictness,
+    customFragments,
+    agents,
+    contexts,
+    hooks: true,
+    hookProfile,
+    tools
+  });
+  await fs23.writeJson(configPath, config, { spaces: 2 });
+  logSuccess("ai-kit.config.json created");
+  logSection("Migration Complete");
+  if (customSections.length > 0) {
+    logInfo(
+      `${customSections.length} custom section(s) preserved in CLAUDE.md`
+    );
+  }
+  logInfo("This project is now managed by ai-kit.");
+  logInfo("Run `ai-kit update` anytime to refresh generated sections.");
+  logInfo("Your custom rules above the AI-KIT markers will never be touched.");
+  if (filesToBackup.length > 0) {
+    logInfo("Rollback available: `ai-kit rollback --latest`");
+  }
+}
 // src/cli/error-handler.ts
 function withErrorHandler(fn) {
   const wrapped = async (...args) => {
@@ -4688,6 +5023,12 @@ function registerCommands(program2) {
   program2.command("component-registry").description("Generate a component registry for AI agent discovery").argument("[path]", "Project directory (defaults to current directory)").action(withErrorHandler(async (targetPath) => {
     await componentRegistryCommand(targetPath);
   }));
+  program2.command("rollback").description("Restore AI configs from a previous backup").argument("[path]", "Project directory (defaults to current directory)").option("--latest", "Restore most recent backup without selection prompt").action(withErrorHandler(async (targetPath, opts) => {
+    await rollbackCommand(targetPath, opts?.latest);
+  }));
+  program2.command("migrate").description("Adopt ai-kit in a project with existing CLAUDE.md/.cursorrules").argument("[path]", "Project directory (defaults to current directory)").option("--dry-run", "Preview migration without writing files").action(withErrorHandler(async (targetPath, opts) => {
+    await migrateCommand(targetPath, opts);
+  }));
 }
 // src/index.ts