@mikulgohil/ai-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,1425 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/constants.ts
+import { fileURLToPath } from "url";
+import path from "path";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var PACKAGE_ROOT = path.resolve(__dirname, "..");
+var TEMPLATES_DIR = path.join(PACKAGE_ROOT, "templates");
+var COMMANDS_DIR = path.join(PACKAGE_ROOT, "commands");
+var GUIDES_DIR = path.join(PACKAGE_ROOT, "guides");
+var DOCS_SCAFFOLDS_DIR = path.join(PACKAGE_ROOT, "docs-scaffolds");
+var VERSION = "1.0.0";
+var AI_KIT_CONFIG_FILE = "ai-kit.config.json";
+var GENERATED_FILES = {
+  claudeMd: "CLAUDE.md",
+  cursorRules: ".cursorrules",
+  cursorMdcDir: ".cursor/rules",
+  claudeSettings: ".claude/settings.json",
+  claudeCommands: ".claude/commands"
+};
+
+// src/commands/init.ts
+import path15 from "path";
+import fs5 from "fs-extra";
+import { select, confirm } from "@inquirer/prompts";
+import ora from "ora";
+
+// src/scanner/index.ts
+import path10 from "path";
+
+// src/utils.ts
+import fs from "fs-extra";
+import chalk from "chalk";
+function readJsonSafe(filePath) {
+  try {
+    return fs.readJsonSync(filePath);
+  } catch {
+    return null;
+  }
+}
+function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}
+function dirExists(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function logSuccess(message) {
+  console.log(chalk.green("\u2713") + " " + message);
+}
+function logWarning(message) {
+  console.log(chalk.yellow("\u26A0") + " " + message);
+}
+function logError(message) {
+  console.log(chalk.red("\u2717") + " " + message);
+}
+function logInfo(message) {
+  console.log(chalk.blue("\u2139") + " " + message);
+}
+function logSection(title) {
+  console.log("\n" + chalk.bold.underline(title));
+}
+var AI_KIT_START = "<!-- AI-KIT:START -->";
+var AI_KIT_END = "<!-- AI-KIT:END -->";
+function mergeWithMarkers(existingContent, newGenerated) {
+  const startIdx = existingContent.indexOf(AI_KIT_START);
+  const endIdx = existingContent.indexOf(AI_KIT_END);
+  if (startIdx === -1 || endIdx === -1) {
+    return newGenerated;
+  }
+  const before = existingContent.substring(0, startIdx);
+  const after = existingContent.substring(endIdx + AI_KIT_END.length);
+  return `${before}${newGenerated}${after}`;
+}
+
+// src/scanner/nextjs.ts
+import path2 from "path";
+function detectNextjs(projectPath, pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (!deps.next) {
+    if (deps.react) return { framework: "react" };
+    return { framework: "unknown" };
+  }
+  const nextjsVersion = deps.next.replace(/[\^~>=<]/g, "");
+  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"));
+  let routerType;
+  if (hasAppDir && hasPagesDir) routerType = "hybrid";
+  else if (hasAppDir) routerType = "app";
+  else if (hasPagesDir) routerType = "pages";
+  return { framework: "nextjs", nextjsVersion, routerType };
+}
+
+// src/scanner/sitecore.ts
+function detectSitecore(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const jssNextjs = deps["@sitecore-jss/sitecore-jss-nextjs"];
+  const jssReact = deps["@sitecore-jss/sitecore-jss-react"];
+  const contentSdk = deps["@sitecore-content-sdk/nextjs"];
+  if (contentSdk || jssNextjs) {
+    const version = (contentSdk || jssNextjs || "").replace(/[\^~>=<]/g, "");
+    return { cms: "sitecore-xmc", sitecorejssVersion: version || void 0 };
+  }
+  if (jssReact) {
+    const version = jssReact.replace(/[\^~>=<]/g, "");
+    return { cms: "sitecore-jss", sitecorejssVersion: version || void 0 };
+  }
+  return { cms: "none" };
+}
+
+// src/scanner/styling.ts
+import path3 from "path";
+function detectStyling(projectPath, pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const styling = [];
+  let tailwindVersion;
+  if (deps.tailwindcss || deps["@tailwindcss/postcss"]) {
+    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"));
+  if (hasTailwindConfig && !styling.includes("tailwind")) {
+    styling.push("tailwind");
+  }
+  if (deps["styled-components"]) styling.push("styled-components");
+  if (deps.sass || deps["node-sass"]) styling.push("scss");
+  return {
+    styling,
+    tailwindVersion: tailwindVersion || void 0
+  };
+}
+
+// src/scanner/typescript.ts
+import path4 from "path";
+function detectTypescript(projectPath) {
+  const tsconfigPath = path4.join(projectPath, "tsconfig.json");
+  if (!fileExists(tsconfigPath)) {
+    return { typescript: false };
+  }
+  const tsconfig = readJsonSafe(tsconfigPath);
+  return {
+    typescript: true,
+    typescriptStrict: tsconfig?.compilerOptions?.strict ?? false
+  };
+}
+
+// src/scanner/monorepo.ts
+import path5 from "path";
+function detectMonorepo(projectPath, pkg) {
+  if (fileExists(path5.join(projectPath, "turbo.json"))) {
+    return { monorepo: true, monorepoTool: "turborepo" };
+  }
+  if (fileExists(path5.join(projectPath, "nx.json"))) {
+    return { monorepo: true, monorepoTool: "nx" };
+  }
+  if (fileExists(path5.join(projectPath, "lerna.json"))) {
+    return { monorepo: true, monorepoTool: "lerna" };
+  }
+  if (fileExists(path5.join(projectPath, "pnpm-workspace.yaml"))) {
+    return { monorepo: true, monorepoTool: "pnpm-workspaces" };
+  }
+  if (pkg.workspaces) {
+    return { monorepo: true };
+  }
+  return { monorepo: false };
+}
+
+// src/scanner/package-manager.ts
+import path6 from "path";
+function detectPackageManager(projectPath) {
+  const pkg = readJsonSafe(
+    path6.join(projectPath, "package.json")
+  );
+  if (pkg?.packageManager) {
+    if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+    if (pkg.packageManager.startsWith("yarn")) return "yarn";
+    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";
+  return "npm";
+}
+
+// src/scanner/figma.ts
+import path7 from "path";
+function detectFigma(projectPath, pkg) {
+  return {
+    figmaMcp: detectFigmaMcp(projectPath),
+    figmaCodeCli: detectFigmaCodeCli(pkg),
+    designTokens: detectDesignTokens(projectPath),
+    tokenFormat: detectTokenFormat(projectPath),
+    visualTests: detectVisualTests(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")
+  ];
+  for (const settingsPath of settingsPaths) {
+    const content = readFileSafe(settingsPath);
+    if (content && content.toLowerCase().includes("figma")) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectFigmaCodeCli(pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  return Object.keys(deps).some(
+    (dep) => dep.startsWith("@figma-code/") || dep === "figma-code-cli"
+  );
+}
+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")
+  ];
+  for (const tokenPath of tokenPaths) {
+    if (fileExists(tokenPath)) return true;
+  }
+  const globalsCss = readFileSafe(
+    path7.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")
+  );
+  if (globalsCss && globalsCss.includes("@theme")) return "tailwind-v4";
+  const twConfigPaths = [
+    path7.join(projectPath, "tailwind.config.ts"),
+    path7.join(projectPath, "tailwind.config.js")
+  ];
+  for (const twPath of twConfigPaths) {
+    const content = readFileSafe(twPath);
+    if (content && content.includes("theme")) return "tailwind-v3";
+  }
+  if (globalsCss && globalsCss.includes("--")) return "css-variables";
+  return "none";
+}
+function detectVisualTests(projectPath, pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...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"));
+  return hasPlaywright || hasPlaywrightConfig;
+}
+
+// src/scanner/tools.ts
+import path8 from "path";
+function detectTools(projectPath, pkg) {
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  return {
+    playwright: detectPlaywright(projectPath, deps),
+    storybook: detectStorybook(projectPath, deps),
+    eslint: detectEslint(projectPath, deps),
+    prettier: detectPrettier(projectPath, deps),
+    axeCore: detectAxeCore(deps),
+    snyk: detectSnyk(projectPath, deps),
+    knip: detectKnip(projectPath, deps),
+    bundleAnalyzer: detectBundleAnalyzer(deps)
+  };
+}
+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;
+  return false;
+}
+function detectStorybook(projectPath, deps) {
+  if ("@storybook/react" in deps) return true;
+  if (dirExists(path8.join(projectPath, ".storybook"))) return true;
+  return false;
+}
+function detectEslint(projectPath, deps) {
+  if ("eslint" in deps) return true;
+  const eslintConfigs = [
+    ".eslintrc",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    ".eslintrc.json",
+    ".eslintrc.yml",
+    ".eslintrc.yaml",
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts"
+  ];
+  for (const config of eslintConfigs) {
+    if (fileExists(path8.join(projectPath, config))) return true;
+  }
+  return false;
+}
+function detectPrettier(projectPath, deps) {
+  if ("prettier" in deps) return true;
+  const prettierConfigs = [
+    ".prettierrc",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.json",
+    ".prettierrc.yml",
+    ".prettierrc.yaml",
+    ".prettierrc.toml",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.ts"
+  ];
+  for (const config of prettierConfigs) {
+    if (fileExists(path8.join(projectPath, config))) return true;
+  }
+  return false;
+}
+function detectAxeCore(deps) {
+  return "@axe-core/playwright" in deps || "axe-core" in deps;
+}
+function detectSnyk(projectPath, deps) {
+  if ("snyk" in deps) return true;
+  if (fileExists(path8.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;
+  return false;
+}
+function detectBundleAnalyzer(deps) {
+  return "@next/bundle-analyzer" in deps;
+}
+
+// src/scanner/mcp.ts
+import path9 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")
+  ];
+  let combined = "";
+  for (const settingsPath of settingsPaths) {
+    const content = readFileSafe(settingsPath);
+    if (content) {
+      combined += content.toLowerCase() + "\n";
+    }
+  }
+  return {
+    playwright: combined.includes("playwright"),
+    figma: combined.includes("figma"),
+    github: combined.includes("github"),
+    context7: combined.includes("context7"),
+    perplexity: combined.includes("perplexity"),
+    notion: combined.includes("notion")
+  };
+}
+
+// src/scanner/index.ts
+async function scanProject(projectPath) {
+  const pkgPath = path10.join(projectPath, "package.json");
+  const pkg = readJsonSafe(pkgPath) || {};
+  const scripts = pkg.scripts || {};
+  const projectName = pkg.name || path10.basename(projectPath);
+  const nextjsResult = detectNextjs(projectPath, pkg);
+  const sitecoreResult = detectSitecore(pkg);
+  const stylingResult = detectStyling(projectPath, pkg);
+  const tsResult = detectTypescript(projectPath);
+  const monorepoResult = detectMonorepo(projectPath, pkg);
+  const packageManager = detectPackageManager(projectPath);
+  const figmaResult = detectFigma(projectPath, pkg);
+  const toolsResult = detectTools(projectPath, pkg);
+  const mcpResult = detectMcpServers(projectPath);
+  const figmaDetected = figmaResult.figmaMcp || figmaResult.figmaCodeCli || figmaResult.designTokens;
+  return {
+    ...nextjsResult,
+    ...sitecoreResult,
+    ...stylingResult,
+    ...tsResult,
+    ...monorepoResult,
+    figma: {
+      detected: figmaDetected,
+      ...figmaResult
+    },
+    tools: toolsResult,
+    mcpServers: mcpResult,
+    packageManager,
+    projectName,
+    projectPath,
+    scripts
+  };
+}
+
+// src/generator/assembler.ts
+import path11 from "path";
+function readTemplate(relativePath) {
+  const fullPath = path11.join(TEMPLATES_DIR, relativePath);
+  const content = readFileSafe(fullPath);
+  if (!content) {
+    throw new Error(`Template not found: ${relativePath}`);
+  }
+  return content.trim();
+}
+function assembleTemplate(subfolder, fragments, variables) {
+  const versionComment = `<!-- Generated by ai-kit v${VERSION} -->`;
+  const header = readTemplate("header.md");
+  const body = fragments.map((name) => readTemplate(`${subfolder}/${name}.md`)).join("\n\n---\n\n");
+  const full = `${versionComment}
+${header}
+
+---
+
+${body}`;
+  const replaced = replacePlaceholders(full, variables);
+  return `<!-- AI-KIT:START -->
+${replaced}
+<!-- AI-KIT:END -->`;
+}
+function replacePlaceholders(content, variables) {
+  let result = content;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+
+// src/generator/claude-md.ts
+function selectFragments(scan) {
+  const fragments = ["base"];
+  if (scan.framework === "nextjs") {
+    if (scan.routerType === "app" || scan.routerType === "hybrid") {
+      fragments.push("nextjs-app-router");
+    }
+    if (scan.routerType === "pages" || scan.routerType === "hybrid") {
+      fragments.push("nextjs-pages-router");
+    }
+  }
+  if (scan.cms !== "none") {
+    fragments.push("sitecore-xmc");
+  }
+  if (scan.styling.includes("tailwind")) {
+    fragments.push("tailwind");
+  }
+  if (scan.typescript) {
+    fragments.push("typescript");
+  }
+  if (scan.monorepo) {
+    fragments.push("monorepo");
+  }
+  if (scan.figma?.detected) {
+    fragments.push("figma");
+  }
+  return fragments;
+}
+function generateClaudeMd(scan) {
+  const fragments = selectFragments(scan);
+  const variables = buildVariables(scan);
+  return assembleTemplate("claude-md", fragments, variables);
+}
+function buildVariables(scan) {
+  const techStack = [];
+  if (scan.framework === "nextjs") {
+    techStack.push(`Next.js ${scan.nextjsVersion || ""}`);
+  }
+  if (scan.cms !== "none") {
+    techStack.push(
+      scan.cms === "sitecore-xmc" ? `Sitecore XM Cloud${scan.sitecorejssVersion ? ` (JSS ${scan.sitecorejssVersion})` : ""}` : "Sitecore JSS"
+    );
+  }
+  if (scan.typescript) techStack.push("TypeScript");
+  if (scan.styling.includes("tailwind"))
+    techStack.push(`Tailwind CSS ${scan.tailwindVersion || ""}`);
+  if (scan.styling.includes("scss")) techStack.push("SCSS");
+  if (scan.styling.includes("styled-components"))
+    techStack.push("styled-components");
+  if (scan.monorepo && scan.monorepoTool)
+    techStack.push(scan.monorepoTool);
+  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");
+  return {
+    projectName: scan.projectName,
+    techStack: techStack.join(" \xB7 "),
+    packageManager: scan.packageManager,
+    routerType: scan.routerType || "unknown",
+    scripts: scripts || "- No scripts detected",
+    framework: scan.framework
+  };
+}
+
+// src/generator/cursorrules.ts
+function generateCursorRules(scan) {
+  const fragments = selectFragments(scan);
+  const variables = buildCursorVariables(scan);
+  return assembleTemplate("cursorrules", fragments, variables);
+}
+function buildCursorVariables(scan) {
+  const techStack = [];
+  if (scan.framework === "nextjs") {
+    techStack.push(`Next.js ${scan.nextjsVersion || ""}`);
+  }
+  if (scan.cms !== "none") {
+    techStack.push(scan.cms === "sitecore-xmc" ? "Sitecore XM Cloud" : "Sitecore JSS");
+  }
+  if (scan.typescript) techStack.push("TypeScript");
+  if (scan.styling.includes("tailwind")) techStack.push("Tailwind CSS");
+  if (scan.monorepo && scan.monorepoTool) techStack.push(scan.monorepoTool);
+  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");
+  return {
+    projectName: scan.projectName,
+    techStack: techStack.join(" \xB7 "),
+    packageManager: scan.packageManager,
+    routerType: scan.routerType || "unknown",
+    scripts: scripts || "- No scripts detected",
+    framework: scan.framework
+  };
+}
+
+// src/generator/cursor-mdc.ts
+var MDC_CONFIG = {
+  base: {
+    description: "Project coding standards and conventions",
+    globs: "**/*"
+  },
+  "nextjs-app-router": {
+    description: "Next.js App Router patterns and best practices",
+    globs: "app/**/*.{ts,tsx}, src/app/**/*.{ts,tsx}"
+  },
+  "nextjs-pages-router": {
+    description: "Next.js Pages Router patterns and best practices",
+    globs: "pages/**/*.{ts,tsx}, src/pages/**/*.{ts,tsx}"
+  },
+  "sitecore-xmc": {
+    description: "Sitecore XM Cloud component patterns and field helpers",
+    globs: "src/components/**/*.{ts,tsx}"
+  },
+  tailwind: {
+    description: "Tailwind CSS conventions and utility patterns",
+    globs: "**/*.{tsx,jsx,css}"
+  },
+  typescript: {
+    description: "TypeScript strict typing conventions",
+    globs: "**/*.{ts,tsx}"
+  },
+  monorepo: {
+    description: "Monorepo workspace conventions",
+    globs: "**/*"
+  },
+  figma: {
+    description: "Figma-to-code workflow and design token rules",
+    globs: "src/components/**/*.{ts,tsx}, tokens/**/*"
+  }
+};
+function generateMdcFiles(scan) {
+  const fragments = selectFragments(scan);
+  const variables = buildCursorVariables(scan);
+  return fragments.map((fragment) => {
+    const config = MDC_CONFIG[fragment] || {
+      description: fragment,
+      globs: "**/*"
+    };
+    const body = readTemplate(`cursorrules/${fragment}.md`);
+    const replaced = replacePlaceholders(body, variables);
+    const frontmatter = [
+      "---",
+      `description: ${config.description}`,
+      `globs: ${config.globs}`,
+      "alwaysApply: true",
+      "---"
+    ].join("\n");
+    return {
+      filename: `${fragment}.mdc`,
+      content: `${frontmatter}
+
+<!-- Generated by ai-kit v${VERSION} -->
+
+${replaced}`
+    };
+  });
+}
+
+// src/generator/config.ts
+function generateConfig(scan, templates, commands, guides) {
+  return {
+    version: VERSION,
+    scanResult: scan,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    templates,
+    commands,
+    guides
+  };
+}
+
+// src/copier/commands.ts
+import path12 from "path";
+import fs2 from "fs-extra";
+var AVAILABLE_COMMANDS = [
+  "prompt-help",
+  "review",
+  "fix-bug",
+  "new-component",
+  "new-page",
+  "understand",
+  "test",
+  "optimize",
+  "figma-to-code",
+  "design-tokens",
+  "accessibility-audit",
+  "security-check",
+  "refactor",
+  "api-route",
+  "pre-pr",
+  "migrate",
+  "error-boundary",
+  "type-fix",
+  "extract-hook",
+  "dep-check",
+  "env-setup",
+  "commit-msg",
+  "sitecore-debug",
+  "responsive-check",
+  "document",
+  "token-tips"
+];
+async function copyCommands(targetDir) {
+  const commandsTarget = path12.join(targetDir, ".claude", "commands");
+  await fs2.ensureDir(commandsTarget);
+  const copied = [];
+  for (const cmd of AVAILABLE_COMMANDS) {
+    const src = path12.join(COMMANDS_DIR, `${cmd}.md`);
+    const dest = path12.join(commandsTarget, `${cmd}.md`);
+    if (await fs2.pathExists(src)) {
+      await fs2.copy(src, dest, { overwrite: true });
+      copied.push(cmd);
+    }
+  }
+  return copied;
+}
+
+// src/copier/guides.ts
+import path13 from "path";
+import fs3 from "fs-extra";
+var AVAILABLE_GUIDES = [
+  "getting-started",
+  "prompt-playbook",
+  "when-to-use-ai",
+  "token-saving-tips",
+  "figma-workflow"
+];
+async function copyGuides(targetDir) {
+  const guidesTarget = path13.join(targetDir, "ai-kit", "guides");
+  await fs3.ensureDir(guidesTarget);
+  const copied = [];
+  for (const guide of AVAILABLE_GUIDES) {
+    const src = path13.join(GUIDES_DIR, `${guide}.md`);
+    const dest = path13.join(guidesTarget, `${guide}.md`);
+    if (await fs3.pathExists(src)) {
+      await fs3.copy(src, dest, { overwrite: true });
+      copied.push(guide);
+    }
+  }
+  return copied;
+}
+
+// src/copier/docs.ts
+import path14 from "path";
+import fs4 from "fs-extra";
+var DOC_SCAFFOLDS = ["mistakes-log", "decisions-log", "time-log"];
+async function scaffoldDocs(targetDir) {
+  const docsTarget = path14.join(targetDir, "docs");
+  await fs4.ensureDir(docsTarget);
+  const created = [];
+  for (const doc of DOC_SCAFFOLDS) {
+    const src = path14.join(DOCS_SCAFFOLDS_DIR, `${doc}.md`);
+    const dest = path14.join(docsTarget, `${doc}.md`);
+    if (await fs4.pathExists(dest)) {
+      continue;
+    }
+    if (await fs4.pathExists(src)) {
+      await fs4.copy(src, dest);
+      created.push(doc);
+    }
+  }
+  return created;
+}
+
+// src/commands/init.ts
+async function initCommand(targetPath) {
+  const projectDir = path15.resolve(targetPath || process.cwd());
+  logSection("AI Kit \u2014 Project Setup");
+  logInfo(`Scanning: ${projectDir}`);
+  const configPath = path15.join(projectDir, AI_KIT_CONFIG_FILE);
+  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;
+    }
+  }
+  const spinner = ora("Scanning project...").start();
+  let scan;
+  try {
+    scan = await scanProject(projectDir);
+    spinner.succeed("Project scanned");
+  } catch (err) {
+    spinner.fail("Failed to scan project");
+    logError(String(err));
+    return;
+  }
+  logSection("Detected Stack");
+  logInfo(`Framework: ${formatFramework(scan)}`);
+  logInfo(`CMS: ${scan.cms === "none" ? "None" : scan.cms}`);
+  logInfo(`Styling: ${scan.styling.join(", ") || "None detected"}`);
+  logInfo(`TypeScript: ${scan.typescript ? "Yes" : "No"}`);
+  logInfo(`Monorepo: ${scan.monorepo ? `Yes (${scan.monorepoTool})` : "No"}`);
+  logInfo(`Package Manager: ${scan.packageManager}`);
+  const clarifications = await askClarifications(scan);
+  scan = applyClarifications(scan, clarifications);
+  const tools = await selectTools();
+  const conflict = await selectConflictStrategy(projectDir);
+  logSection("Generating Files");
+  const results = await generate(projectDir, scan, tools, conflict);
+  logSection("Setup Complete");
+  if (results.claudeMd) logSuccess(`CLAUDE.md generated`);
+  if (results.cursorRules) logSuccess(`.cursorrules generated`);
+  if (results.cursorMdcFiles > 0)
+    logSuccess(`${results.cursorMdcFiles} .cursor/rules/*.mdc files generated`);
+  if (results.commands.length > 0)
+    logSuccess(`${results.commands.length} slash commands copied`);
+  if (results.guides.length > 0)
+    logSuccess(`${results.guides.length} guides added to ai-kit/guides/`);
+  if (results.docs.length > 0)
+    logSuccess(`${results.docs.length} doc scaffolds created in docs/`);
+  showRecommendations(scan);
+  console.log("");
+  logInfo("Run `ai-kit update` anytime to refresh configs after project changes.");
+  logInfo("Check ai-kit/guides/getting-started.md to get started.");
+}
+function formatFramework(scan) {
+  if (scan.framework === "nextjs") {
+    const version = scan.nextjsVersion ? ` ${scan.nextjsVersion}` : "";
+    const router = scan.routerType ? ` (${scan.routerType} router)` : "";
+    return `Next.js${version}${router}`;
+  }
+  return scan.framework;
+}
+async function askClarifications(scan) {
+  const answers = {};
+  if (scan.framework === "nextjs" && !scan.routerType) {
+    answers.routerType = await select({
+      message: "Which Next.js router does this project use?",
+      choices: [
+        { name: "App Router (app/ directory)", value: "app" },
+        { name: "Pages Router (pages/ directory)", value: "pages" },
+        { name: "Both (hybrid)", value: "hybrid" }
+      ]
+    });
+  }
+  return answers;
+}
+function applyClarifications(scan, clarifications) {
+  return {
+    ...scan,
+    ...clarifications.routerType && { routerType: clarifications.routerType },
+    ...clarifications.cms && { cms: clarifications.cms }
+  };
+}
+async function selectTools() {
+  const tool = await select({
+    message: "Which AI tools does this project use?",
+    choices: [
+      { name: "Both Claude Code & Cursor", value: "both" },
+      { name: "Claude Code only", value: "claude" },
+      { name: "Cursor only", value: "cursor" }
+    ],
+    default: "both"
+  });
+  return {
+    claude: tool === "both" || tool === "claude",
+    cursor: tool === "both" || tool === "cursor"
+  };
+}
+async function selectConflictStrategy(projectDir) {
+  const hasExisting = fileExists(path15.join(projectDir, GENERATED_FILES.claudeMd)) || fileExists(path15.join(projectDir, GENERATED_FILES.cursorRules));
+  if (!hasExisting) return "overwrite";
+  return select({
+    message: "Existing AI config files detected. How should we handle conflicts?",
+    choices: [
+      {
+        name: "Overwrite \u2014 replace with fresh generated files",
+        value: "overwrite"
+      },
+      {
+        name: "Skip \u2014 keep existing files, only add missing ones",
+        value: "skip"
+      }
+    ],
+    default: "overwrite"
+  });
+}
+async function generate(projectDir, scan, tools, conflict) {
+  const result = {
+    claudeMd: false,
+    cursorRules: false,
+    cursorMdcFiles: 0,
+    commands: [],
+    guides: [],
+    docs: []
+  };
+  if (tools.claude) {
+    const claudeMdPath = path15.join(projectDir, GENERATED_FILES.claudeMd);
+    if (conflict === "overwrite" || !fileExists(claudeMdPath)) {
+      const content = generateClaudeMd(scan);
+      await fs5.writeFile(claudeMdPath, content, "utf-8");
+      result.claudeMd = true;
+    } else {
+      logWarning("CLAUDE.md exists, skipping");
+    }
+    result.commands = await copyCommands(projectDir);
+    await fs5.ensureDir(path15.join(projectDir, ".claude", "commands"));
+  }
+  if (tools.cursor) {
+    const cursorPath = path15.join(projectDir, GENERATED_FILES.cursorRules);
+    if (conflict === "overwrite" || !fileExists(cursorPath)) {
+      const content = generateCursorRules(scan);
+      await fs5.writeFile(cursorPath, content, "utf-8");
+      result.cursorRules = true;
+    } else {
+      logWarning(".cursorrules exists, skipping");
+    }
+    const mdcDir = path15.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs5.ensureDir(mdcDir);
+    const mdcFiles = generateMdcFiles(scan);
+    for (const mdc of mdcFiles) {
+      await fs5.writeFile(path15.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+    }
+    result.cursorMdcFiles = mdcFiles.length;
+  }
+  result.guides = await copyGuides(projectDir);
+  result.docs = await scaffoldDocs(projectDir);
+  const templates = [];
+  if (result.claudeMd) templates.push("CLAUDE.md");
+  if (result.cursorRules) templates.push(".cursorrules");
+  const config = generateConfig(scan, templates, result.commands, result.guides);
+  await fs5.writeJson(
+    path15.join(projectDir, AI_KIT_CONFIG_FILE),
+    config,
+    { spaces: 2 }
+  );
+  return result;
+}
+function showRecommendations(scan) {
+  const toolRecs = [
+    {
+      check: scan.tools.playwright,
+      label: "Playwright not detected \u2014 install for E2E testing:",
+      hint: "  npm install -D @playwright/test && npx playwright install"
+    },
+    {
+      check: scan.tools.eslint,
+      label: "ESLint not detected \u2014 install for code quality:",
+      hint: "  npm install -D eslint @typescript-eslint/eslint-plugin"
+    },
+    {
+      check: scan.tools.prettier,
+      label: "Prettier not detected \u2014 install for code formatting:",
+      hint: "  npm install -D prettier"
+    },
+    {
+      check: scan.tools.axeCore,
+      label: "axe-core not detected \u2014 install for accessibility testing:",
+      hint: "  npm install -D @axe-core/playwright"
+    },
+    {
+      check: scan.tools.knip,
+      label: "Knip not detected \u2014 install to find unused code:",
+      hint: "  npm install -D knip"
+    },
+    {
+      check: scan.tools.bundleAnalyzer,
+      label: "Bundle analyzer not detected \u2014 install for bundle insights:",
+      hint: "  npm install -D @next/bundle-analyzer"
+    }
+  ];
+  const mcpRecs = [
+    {
+      check: scan.mcpServers.context7,
+      label: "Context7 MCP not configured \u2014 enables up-to-date library docs:",
+      hint: "  Add to .claude/settings.json mcpServers"
+    },
+    {
+      check: scan.mcpServers.playwright,
+      label: "Playwright MCP not configured \u2014 enables browser automation:",
+      hint: "  Add to .claude/settings.json mcpServers"
+    },
+    {
+      check: scan.mcpServers.github,
+      label: "GitHub MCP not configured \u2014 enables PR/issue management:",
+      hint: "  Add to .claude/settings.json mcpServers"
+    },
+    {
+      check: scan.mcpServers.perplexity,
+      label: "Perplexity MCP not configured \u2014 enables web research:",
+      hint: "  Add to .claude/settings.json mcpServers"
+    }
+  ];
+  const missingTools = toolRecs.filter((r) => !r.check);
+  const missingMcps = mcpRecs.filter((r) => !r.check);
+  if (missingTools.length === 0 && missingMcps.length === 0) return;
+  logSection("Recommended Setup");
+  for (const rec of missingTools) {
+    logInfo(rec.label);
+    logInfo(rec.hint);
+  }
+  for (const rec of missingMcps) {
+    logInfo(rec.label);
+    logInfo(rec.hint);
+  }
+}
+
+// src/commands/update.ts
+import path16 from "path";
+import fs6 from "fs-extra";
+import ora2 from "ora";
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function updateCommand(targetPath) {
+  const projectDir = path16.resolve(targetPath || process.cwd());
+  const configPath = path16.join(projectDir, AI_KIT_CONFIG_FILE);
+  if (!fileExists(configPath)) {
+    logError("No ai-kit.config.json found. Run `ai-kit init` first.");
+    return;
+  }
+  const existingConfig = readJsonSafe(configPath);
+  if (!existingConfig) {
+    logError("Could not read ai-kit.config.json. Run `ai-kit init` to re-initialize.");
+    return;
+  }
+  const existingMajor = parseInt(existingConfig.version.split(".")[0], 10);
+  const currentMajor = parseInt(VERSION.split(".")[0], 10);
+  if (existingMajor !== currentMajor) {
+    logWarning(
+      `Config was generated with ai-kit v${existingConfig.version}, but you're running v${VERSION}. Consider running \`ai-kit init\` to re-initialize.`
+    );
+  }
+  const proceed = await confirm2({
+    message: "Re-scan project and update all generated files?",
+    default: true
+  });
+  if (!proceed) return;
+  const spinner = ora2("Re-scanning project...").start();
+  const scan = await scanProject(projectDir);
+  spinner.succeed("Project re-scanned");
+  logSection("Updating Files");
+  const templates = [];
+  if (existingConfig.templates.includes("CLAUDE.md") || fileExists(path16.join(projectDir, GENERATED_FILES.claudeMd))) {
+    const claudeMdPath = path16.join(projectDir, GENERATED_FILES.claudeMd);
+    const newContent = generateClaudeMd(scan);
+    const existing = readFileSafe(claudeMdPath);
+    if (existing) {
+      await fs6.writeFile(claudeMdPath, mergeWithMarkers(existing, newContent), "utf-8");
+    } else {
+      await fs6.writeFile(claudeMdPath, newContent, "utf-8");
+    }
+    templates.push("CLAUDE.md");
+    logSuccess("CLAUDE.md updated");
+  }
+  if (existingConfig.templates.includes(".cursorrules") || fileExists(path16.join(projectDir, GENERATED_FILES.cursorRules))) {
+    const cursorRulesPath = path16.join(projectDir, GENERATED_FILES.cursorRules);
+    const newContent = generateCursorRules(scan);
+    const existing = readFileSafe(cursorRulesPath);
+    if (existing) {
+      await fs6.writeFile(cursorRulesPath, mergeWithMarkers(existing, newContent), "utf-8");
+    } else {
+      await fs6.writeFile(cursorRulesPath, newContent, "utf-8");
+    }
+    templates.push(".cursorrules");
+    logSuccess(".cursorrules updated");
+    const mdcDir = path16.join(projectDir, GENERATED_FILES.cursorMdcDir);
+    await fs6.ensureDir(mdcDir);
+    const mdcFiles = generateMdcFiles(scan);
+    for (const mdc of mdcFiles) {
+      await fs6.writeFile(path16.join(mdcDir, mdc.filename), mdc.content, "utf-8");
+    }
+    logSuccess(`${mdcFiles.length} .cursor/rules/*.mdc files updated`);
+  }
+  const commands = await copyCommands(projectDir);
+  logSuccess(`${commands.length} slash commands updated`);
+  const guides = await copyGuides(projectDir);
+  logSuccess(`${guides.length} guides updated`);
+  const config = generateConfig(scan, templates, commands, guides);
+  await fs6.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 path17 from "path";
+import fs7 from "fs-extra";
+import { confirm as confirm3 } from "@inquirer/prompts";
+async function resetCommand(targetPath) {
+  const projectDir = path17.resolve(targetPath || process.cwd());
+  logSection("AI Kit \u2014 Reset");
+  logWarning("This will remove all AI Kit generated files:");
+  logInfo(`  - ${GENERATED_FILES.claudeMd}`);
+  logInfo(`  - ${GENERATED_FILES.cursorRules}`);
+  logInfo(`  - ${GENERATED_FILES.cursorMdcDir}/`);
+  logInfo(`  - ${GENERATED_FILES.claudeCommands}/`);
+  logInfo(`  - ai-kit/`);
+  logInfo(`  - ${AI_KIT_CONFIG_FILE}`);
+  console.log("");
+  const proceed = await confirm3({
+    message: "Are you sure? This cannot be undone.",
+    default: false
+  });
+  if (!proceed) {
+    logInfo("Cancelled.");
+    return;
+  }
+  const removed = [];
+  const claudeMdPath = path17.join(projectDir, GENERATED_FILES.claudeMd);
+  if (fileExists(claudeMdPath)) {
+    await fs7.remove(claudeMdPath);
+    removed.push(GENERATED_FILES.claudeMd);
+  }
+  const cursorPath = path17.join(projectDir, GENERATED_FILES.cursorRules);
+  if (fileExists(cursorPath)) {
+    await fs7.remove(cursorPath);
+    removed.push(GENERATED_FILES.cursorRules);
+  }
+  const cursorMdcDir = path17.join(projectDir, GENERATED_FILES.cursorMdcDir);
+  if (fileExists(cursorMdcDir)) {
+    await fs7.remove(cursorMdcDir);
+    removed.push(GENERATED_FILES.cursorMdcDir);
+  }
+  const commandsDir = path17.join(projectDir, GENERATED_FILES.claudeCommands);
+  if (fileExists(commandsDir)) {
+    await fs7.remove(commandsDir);
+    removed.push(GENERATED_FILES.claudeCommands);
+  }
+  const aiKitDir = path17.join(projectDir, "ai-kit");
+  if (fileExists(aiKitDir)) {
+    await fs7.remove(aiKitDir);
+    removed.push("ai-kit/");
+  }
+  const configPath = path17.join(projectDir, AI_KIT_CONFIG_FILE);
+  if (fileExists(configPath)) {
+    await fs7.remove(configPath);
+    removed.push(AI_KIT_CONFIG_FILE);
+  }
+  logSection("Reset Complete");
+  if (removed.length > 0) {
+    removed.forEach((f) => logSuccess(`Removed ${f}`));
+  } else {
+    logInfo("No AI Kit files found to remove.");
+  }
+}
+
+// src/commands/tokens.ts
+import path18 from "path";
+import fs8 from "fs-extra";
+import chalk2 from "chalk";
+import ora3 from "ora";
+import os from "os";
+var PRICING = {
+  sonnet: { input: 3, output: 15, cacheRead: 0.3 },
+  opus: { input: 15, output: 75, cacheRead: 0.3 }
+};
+var PLAN_BUDGET = 20;
+function findSessionFiles() {
+  const claudeDir = path18.join(os.homedir(), ".claude", "projects");
+  if (!fs8.existsSync(claudeDir)) return [];
+  const files = [];
+  function walkDir(dir) {
+    try {
+      const entries = fs8.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const full = path18.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          walkDir(full);
+        } else if (entry.name.endsWith(".jsonl")) {
+          files.push(full);
+        }
+      }
+    } catch {
+    }
+  }
+  walkDir(claudeDir);
+  return files;
+}
+function parseSessionFile(filePath) {
+  try {
+    const content = fs8.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    const usage = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0
+    };
+    let model = "sonnet";
+    let messageCount = 0;
+    let sessionDate = "";
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj.timestamp && !sessionDate) {
+          sessionDate = new Date(obj.timestamp).toISOString().slice(0, 10);
+        }
+        if (obj.model) {
+          const m = String(obj.model).toLowerCase();
+          if (m.includes("opus")) model = "opus";
+          else model = "sonnet";
+        }
+        if (obj.type === "assistant" || obj.role === "assistant") {
+          messageCount++;
+        }
+        const u = obj.usage || obj.message?.usage || obj.costInfo || obj.result?.usage || null;
+        if (u) {
+          usage.inputTokens += u.input_tokens || u.inputTokens || 0;
+          usage.outputTokens += u.output_tokens || u.outputTokens || 0;
+          usage.cacheReadTokens += u.cache_read_input_tokens || u.cacheReadTokens || u.cache_read || 0;
+          usage.cacheCreationTokens += u.cache_creation_input_tokens || u.cacheCreationTokens || u.cache_creation || 0;
+        }
+      } catch {
+      }
+    }
+    if (usage.inputTokens === 0 && usage.outputTokens === 0) return null;
+    if (!sessionDate) {
+      const stat = fs8.statSync(filePath);
+      sessionDate = stat.mtime.toISOString().slice(0, 10);
+    }
+    const sessionId = path18.basename(filePath, ".jsonl");
+    return {
+      sessionId,
+      filePath,
+      date: sessionDate,
+      usage,
+      model,
+      messageCount
+    };
+  } catch {
+    return null;
+  }
+}
+function calculateCost(usage, model = "sonnet") {
+  const rates = model === "opus" ? PRICING.opus : PRICING.sonnet;
+  const inputCost = usage.inputTokens / 1e6 * rates.input;
+  const outputCost = usage.outputTokens / 1e6 * rates.output;
+  const cacheCost = usage.cacheReadTokens / 1e6 * rates.cacheRead;
+  return inputCost + outputCost + cacheCost;
+}
+function aggregateByDate(sessions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const existing = map.get(s.date) || {
+      sessions: 0,
+      usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 },
+      models: []
+    };
+    existing.sessions++;
+    existing.usage.inputTokens += s.usage.inputTokens;
+    existing.usage.outputTokens += s.usage.outputTokens;
+    existing.usage.cacheReadTokens += s.usage.cacheReadTokens;
+    existing.usage.cacheCreationTokens += s.usage.cacheCreationTokens;
+    existing.models.push(s.model);
+    map.set(s.date, existing);
+  }
+  return Array.from(map.entries()).map(([date, data]) => ({
+    date,
+    sessions: data.sessions,
+    usage: data.usage,
+    cost: calculateCost(data.usage, data.models.includes("opus") ? "opus" : "sonnet")
+  })).sort((a, b) => b.date.localeCompare(a.date));
+}
+function filterDateRange(sessions, startDate, endDate) {
+  return sessions.filter((s) => s.date >= startDate && s.date <= endDate);
+}
+function sumUsage(sessions) {
+  return sessions.reduce(
+    (acc, s) => ({
+      inputTokens: acc.inputTokens + s.usage.inputTokens,
+      outputTokens: acc.outputTokens + s.usage.outputTokens,
+      cacheReadTokens: acc.cacheReadTokens + s.usage.cacheReadTokens,
+      cacheCreationTokens: acc.cacheCreationTokens + s.usage.cacheCreationTokens
+    }),
+    { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0 }
+  );
+}
+function sumCost(sessions) {
+  return sessions.reduce((acc, s) => acc + calculateCost(s.usage, s.model), 0);
+}
+function fmt(n) {
+  return n.toLocaleString("en-US");
+}
+function fmtCost(n) {
+  return `$${n.toFixed(2)}`;
+}
+function progressBar(percent, width = 20) {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  const bar = chalk2.green("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(empty));
+  return bar;
+}
+function printPeriodSummary(label, sessions) {
+  const usage = sumUsage(sessions);
+  const cost = sumCost(sessions);
+  console.log(`
+${chalk2.bold(label)}`);
+  console.log(`  Sessions: ${chalk2.cyan(String(sessions.length))}`);
+  console.log(`  Input tokens:  ${chalk2.white(fmt(usage.inputTokens))}`);
+  console.log(`  Output tokens: ${chalk2.white(fmt(usage.outputTokens))}`);
+  console.log(`  Cache read:    ${chalk2.white(fmt(usage.cacheReadTokens))}`);
+  console.log(`  Estimated cost: ${chalk2.yellow("~" + fmtCost(cost))}`);
+}
+async function tokensCommand(options = {}) {
+  logSection("AI Kit \u2014 Token Usage");
+  const spinner = ora3("Scanning Claude Code session logs...").start();
+  const sessionFiles = findSessionFiles();
+  if (sessionFiles.length === 0) {
+    spinner.fail("No Claude Code session logs found");
+    logInfo("Session logs are stored in ~/.claude/projects/");
+    logInfo("Use Claude Code to generate some activity first.");
+    return;
+  }
+  const sessions = [];
+  for (const file of sessionFiles) {
+    const s = parseSessionFile(file);
+    if (s) sessions.push(s);
+  }
+  spinner.succeed(`Parsed ${sessions.length} sessions from ${sessionFiles.length} log files`);
+  if (sessions.length === 0) {
+    logWarning("No token usage data found in session logs.");
+    return;
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const dayOfWeek = (/* @__PURE__ */ new Date()).getDay();
+  const mondayOffset = dayOfWeek === 0 ? 6 : dayOfWeek - 1;
+  const weekStart = /* @__PURE__ */ new Date();
+  weekStart.setDate(weekStart.getDate() - mondayOffset);
+  const weekStartStr = weekStart.toISOString().slice(0, 10);
+  const monthStart = today.slice(0, 7) + "-01";
+  const todaySessions = filterDateRange(sessions, today, today);
+  const weekSessions = filterDateRange(sessions, weekStartStr, today);
+  const monthSessions = filterDateRange(sessions, monthStart, today);
+  printPeriodSummary(`Today (${today})`, todaySessions);
+  printPeriodSummary("This Week", weekSessions);
+  printPeriodSummary("This Month", monthSessions);
+  const monthCost = sumCost(monthSessions);
+  const budgetPercent = Math.min(monthCost / PLAN_BUDGET * 100, 100);
+  const daysInMonth = new Date(
+    (/* @__PURE__ */ new Date()).getFullYear(),
+    (/* @__PURE__ */ new Date()).getMonth() + 1,
+    0
+  ).getDate();
+  const dayOfMonth = (/* @__PURE__ */ new Date()).getDate();
+  const daysRemaining = daysInMonth - dayOfMonth;
+  const dailyAvg = dayOfMonth > 0 ? monthCost / dayOfMonth : 0;
+  const estimatedDaysLeft = dailyAvg > 0 ? Math.floor((PLAN_BUDGET - monthCost) / dailyAvg) : daysRemaining;
+  console.log(`
+${chalk2.bold(`$${PLAN_BUDGET} Plan Budget`)}`);
+  console.log(
+    `  ${progressBar(budgetPercent)} ${Math.round(budgetPercent)}% used (~${fmtCost(monthCost)} of ${fmtCost(PLAN_BUDGET)})`
+  );
+  console.log(
+    `  Estimated days remaining at this rate: ${chalk2.cyan(String(Math.max(estimatedDaysLeft, 0)))} days`
+  );
+  console.log(`  Daily average: ${chalk2.yellow(fmtCost(dailyAvg))}`);
+  console.log(
+    `
+${chalk2.dim("Tip: Use /understand before modifying unfamiliar code \u2014")}`
+  );
+  console.log(
+    chalk2.dim("     it's cheaper than a failed implementation attempt.")
+  );
+  console.log("");
+  if (options.export) {
+    await exportDashboard(sessions, todaySessions, weekSessions, monthSessions);
+  }
+}
+async function exportDashboard(allSessions, todaySessions, weekSessions, monthSessions) {
+  const spinner = ora3("Generating dashboard...").start();
+  const exportData = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    planBudget: PLAN_BUDGET,
+    daily: aggregateByDate(allSessions),
+    sessions: allSessions.sort((a, b) => b.date.localeCompare(a.date)).slice(0, 50).map((s) => ({
+      ...s,
+      filePath: s.filePath
+      // keep for reference
+    })),
+    totals: {
+      today: {
+        usage: sumUsage(todaySessions),
+        cost: sumCost(todaySessions),
+        sessions: todaySessions.length
+      },
+      thisWeek: {
+        usage: sumUsage(weekSessions),
+        cost: sumCost(weekSessions),
+        sessions: weekSessions.length
+      },
+      thisMonth: {
+        usage: sumUsage(monthSessions),
+        cost: sumCost(monthSessions),
+        sessions: monthSessions.length
+      }
+    }
+  };
+  const outputDir = process.cwd();
+  const dataPath = path18.join(outputDir, "token-data.json");
+  const dashboardSrc = path18.join(PACKAGE_ROOT, "templates", "token-dashboard.html");
+  const dashboardDest = path18.join(outputDir, "token-dashboard.html");
+  await fs8.writeJson(dataPath, exportData, { spaces: 2 });
+  logInfo(`Token data written to ${dataPath}`);
+  if (await fs8.pathExists(dashboardSrc)) {
+    await fs8.copy(dashboardSrc, dashboardDest, { overwrite: true });
+    logInfo(`Dashboard copied to ${dashboardDest}`);
+  } else {
+    logWarning("Dashboard template not found. Skipping HTML export.");
+  }
+  spinner.succeed("Dashboard exported");
+  try {
+    const { exec } = await import("child_process");
+    const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+    exec(`${openCmd} "${dashboardDest}"`);
+    logInfo("Opening dashboard in browser...");
+  } catch {
+    logInfo(`Open ${dashboardDest} in your browser to view the dashboard.`);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("ai-kit").description(
+  "AI-powered project setup \u2014 generates CLAUDE.md, .cursorrules, slash commands, and guides tailored to your stack."
+).version(VERSION);
+program.command("init").description("Scan your project and generate AI configs").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await initCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("update").description("Re-scan and update all generated AI configs").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await updateCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("reset").description("Remove all AI Kit generated files").argument("[path]", "Project directory (defaults to current directory)").action(async (targetPath) => {
+  try {
+    await resetCommand(targetPath);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.command("tokens").description("Show token usage summary and cost estimates").option("--export", "Export data and open HTML dashboard").action(async (opts) => {
+  try {
+    await tokensCommand(opts);
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.exit(0);
+    }
+    console.error(err);
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.js.map