@qazuor/claude-code-config 0.1.0 → 0.2.0

package/dist/bin.cjs

@@ -72,11 +72,11 @@ __export(fs_exports, {
   writeJson: () => writeJson
 });
 async function pathExists(filePath) {
-  return import_fs_extra2.default.pathExists(filePath);
+  return import_fs_extra.default.pathExists(filePath);
 }
 async function isDirectory(filePath) {
   try {
-    const stat = await import_fs_extra2.default.stat(filePath);
+    const stat = await import_fs_extra.default.stat(filePath);
     return stat.isDirectory();
   } catch {
     return false;
@@ -84,41 +84,41 @@ async function isDirectory(filePath) {
 }
 async function isFile(filePath) {
   try {
-    const stat = await import_fs_extra2.default.stat(filePath);
+    const stat = await import_fs_extra.default.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
   }
 }
 async function readJson(filePath) {
-  return import_fs_extra2.default.readJson(filePath);
+  return import_fs_extra.default.readJson(filePath);
 }
 async function writeJson(filePath, data, options) {
-  await import_fs_extra2.default.ensureDir(import_node_path2.default.dirname(filePath));
-  await import_fs_extra2.default.writeJson(filePath, data, { spaces: options?.spaces ?? 2 });
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(filePath));
+  await import_fs_extra.default.writeJson(filePath, data, { spaces: options?.spaces ?? 2 });
 }
 async function readFile(filePath) {
-  return import_fs_extra2.default.readFile(filePath, "utf-8");
+  return import_fs_extra.default.readFile(filePath, "utf-8");
 }
 async function writeFile(filePath, content) {
-  await import_fs_extra2.default.ensureDir(import_node_path2.default.dirname(filePath));
-  await import_fs_extra2.default.writeFile(filePath, content, "utf-8");
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(filePath));
+  await import_fs_extra.default.writeFile(filePath, content, "utf-8");
 }
 async function copy(src, dest, options) {
-  await import_fs_extra2.default.ensureDir(import_node_path2.default.dirname(dest));
-  await import_fs_extra2.default.copy(src, dest, { overwrite: options?.overwrite ?? false });
+  await import_fs_extra.default.ensureDir(import_node_path.default.dirname(dest));
+  await import_fs_extra.default.copy(src, dest, { overwrite: options?.overwrite ?? false });
 }
 async function copyDir(src, dest, options) {
-  await import_fs_extra2.default.copy(src, dest, {
+  await import_fs_extra.default.copy(src, dest, {
     overwrite: options?.overwrite ?? false,
     filter: options?.filter
   });
 }
 async function ensureDir(dirPath) {
-  await import_fs_extra2.default.ensureDir(dirPath);
+  await import_fs_extra.default.ensureDir(dirPath);
 }
 async function remove(filePath) {
-  await import_fs_extra2.default.remove(filePath);
+  await import_fs_extra.default.remove(filePath);
 }
 async function listFiles(pattern, options) {
   return (0, import_glob.glob)(pattern, {
@@ -133,7 +133,7 @@ async function listDirs(pattern, options) {
   });
   const dirs = [];
   for (const match of matches) {
-    const fullPath = options?.cwd ? import_node_path2.default.join(options.cwd, match) : match;
+    const fullPath = options?.cwd ? import_node_path.default.join(options.cwd, match) : match;
     if (await isDirectory(fullPath)) {
       dirs.push(match);
     }
@@ -142,7 +142,7 @@ async function listDirs(pattern, options) {
 }
 async function getFileInfo(filePath) {
   try {
-    const stat = await import_fs_extra2.default.stat(filePath);
+    const stat = await import_fs_extra.default.stat(filePath);
     return {
       exists: true,
       isFile: stat.isFile(),
@@ -163,7 +163,7 @@ async function readDirRecursive(dirPath, options) {
 }
 async function getFileHash(filePath) {
   const crypto = await import("crypto");
-  const content = await import_fs_extra2.default.readFile(filePath);
+  const content = await import_fs_extra.default.readFile(filePath);
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 async function filesAreEqual(file1, file2) {
@@ -175,22 +175,22 @@ async function filesAreEqual(file1, file2) {
   }
 }
 function relativePath(from, to) {
-  return import_node_path2.default.relative(from, to);
+  return import_node_path.default.relative(from, to);
 }
 function resolvePath(...segments) {
-  return import_node_path2.default.resolve(...segments);
+  return import_node_path.default.resolve(...segments);
 }
 function joinPath(...segments) {
-  return import_node_path2.default.join(...segments);
+  return import_node_path.default.join(...segments);
 }
 function dirname(filePath) {
-  return import_node_path2.default.dirname(filePath);
+  return import_node_path.default.dirname(filePath);
 }
 function basename(filePath, ext) {
-  return import_node_path2.default.basename(filePath, ext);
+  return import_node_path.default.basename(filePath, ext);
 }
 function extname(filePath) {
-  return import_node_path2.default.extname(filePath);
+  return import_node_path.default.extname(filePath);
 }
 async function backup(src, suffix = ".backup") {
   const backupPath = `${src}${suffix}`;
@@ -199,27 +199,27 @@ async function backup(src, suffix = ".backup") {
 }
 async function makeExecutable(filePath) {
   try {
-    await import_fs_extra2.default.chmod(filePath, 493);
+    await import_fs_extra.default.chmod(filePath, 493);
   } catch {
   }
 }
 async function createTempDir(prefix = "claude-config-") {
   const os4 = await import("os");
   const tempBase = os4.tmpdir();
-  const tempDir = import_node_path2.default.join(tempBase, `${prefix}${Date.now()}`);
+  const tempDir = import_node_path.default.join(tempBase, `${prefix}${Date.now()}`);
   await ensureDir(tempDir);
   return tempDir;
 }
 async function cleanTempDir(tempDir) {
   await remove(tempDir);
 }
-var import_node_path2, import_fs_extra2, import_glob;
+var import_node_path, import_fs_extra, import_glob;
 var init_fs = __esm({
   "src/lib/utils/fs.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_path2 = __toESM(require("path"), 1);
-    import_fs_extra2 = __toESM(require("fs-extra"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    import_fs_extra = __toESM(require("fs-extra"), 1);
     import_glob = require("glob");
   }
 });
@@ -1350,13 +1350,351 @@ function getBundleCategoryName(category) {
   return BUNDLE_CATEGORY_NAMES[category] ?? category;
 }
 
+// src/lib/ci-cd/index.ts
+init_cjs_shims();
+
+// src/lib/ci-cd/github-actions-generator.ts
+init_cjs_shims();
+init_fs();
+
+// src/lib/utils/spinner.ts
+init_cjs_shims();
+var import_ora = __toESM(require("ora"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+var SpinnerManager = class {
+  spinner = null;
+  silent = false;
+  configure(options) {
+    if (options.silent !== void 0) this.silent = options.silent;
+  }
+  /**
+   * Start a spinner with a message
+   */
+  start(text, options) {
+    if (this.silent) return null;
+    this.stop();
+    this.spinner = (0, import_ora.default)({
+      text,
+      color: options?.color || "cyan",
+      spinner: "dots"
+    }).start();
+    return this.spinner;
+  }
+  /**
+   * Update spinner text
+   */
+  text(text) {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+  }
+  /**
+   * Stop spinner with success message
+   */
+  succeed(text) {
+    if (this.spinner) {
+      this.spinner.succeed(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with failure message
+   */
+  fail(text) {
+    if (this.spinner) {
+      this.spinner.fail(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with warning message
+   */
+  warn(text) {
+    if (this.spinner) {
+      this.spinner.warn(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner with info message
+   */
+  info(text) {
+    if (this.spinner) {
+      this.spinner.info(text);
+      this.spinner = null;
+    }
+  }
+  /**
+   * Stop spinner without message
+   */
+  stop() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+  /**
+   * Check if spinner is running
+   */
+  isRunning() {
+    return this.spinner?.isSpinning ?? false;
+  }
+};
+var spinner = new SpinnerManager();
+async function withSpinner(text, operation, options) {
+  if (options?.silent) {
+    return operation();
+  }
+  spinner.start(text);
+  try {
+    const result = await operation();
+    spinner.succeed(options?.successText || text);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    spinner.fail(options?.failText || `${text} - ${import_picocolors.default.red(errorMessage)}`);
+    throw error;
+  }
+}
+
+// src/lib/ci-cd/github-actions-generator.ts
+function getInstallCommand(packageManager) {
+  switch (packageManager) {
+    case "npm":
+      return "npm ci";
+    case "yarn":
+      return "yarn install --frozen-lockfile";
+    case "pnpm":
+      return "pnpm install --frozen-lockfile";
+    case "bun":
+      return "bun install --frozen-lockfile";
+    default:
+      return "npm ci";
+  }
+}
+function getRunCommand(packageManager, script) {
+  switch (packageManager) {
+    case "npm":
+      return `npm run ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "pnpm":
+      return `pnpm ${script}`;
+    case "bun":
+      return `bun run ${script}`;
+    default:
+      return `npm run ${script}`;
+  }
+}
+function getCacheConfig(packageManager) {
+  switch (packageManager) {
+    case "npm":
+      return {
+        path: "~/.npm",
+        key: "npm-${{ hashFiles('**/package-lock.json') }}"
+      };
+    case "yarn":
+      return {
+        path: ".yarn/cache",
+        key: "yarn-${{ hashFiles('**/yarn.lock') }}"
+      };
+    case "pnpm":
+      return {
+        path: "~/.local/share/pnpm/store",
+        key: "pnpm-${{ hashFiles('**/pnpm-lock.yaml') }}"
+      };
+    case "bun":
+      return {
+        path: "~/.bun/install/cache",
+        key: "bun-${{ hashFiles('**/bun.lockb') }}"
+      };
+    default:
+      return {
+        path: "~/.npm",
+        key: "npm-${{ hashFiles('**/package-lock.json') }}"
+      };
+  }
+}
+function generateCIWorkflow(config) {
+  const { packageManager, nodeVersion, enableCaching, runTests, runLint, runTypecheck, runBuild } = config;
+  const cache = getCacheConfig(packageManager);
+  const installCmd = getInstallCommand(packageManager);
+  const steps = [];
+  steps.push(`      - name: Checkout
+        uses: actions/checkout@v4`);
+  if (packageManager === "pnpm") {
+    steps.push(`
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: latest`);
+  }
+  if (packageManager === "bun") {
+    steps.push(`
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest`);
+  }
+  if (packageManager !== "bun") {
+    steps.push(`
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '${nodeVersion}'${enableCaching ? `
+          cache: '${packageManager}'` : ""}`);
+  }
+  if (enableCaching && packageManager === "bun") {
+    steps.push(`
+      - name: Cache dependencies
+        uses: actions/cache@v4
+        with:
+          path: ${cache.path}
+          key: ${cache.key}`);
+  }
+  steps.push(`
+      - name: Install dependencies
+        run: ${installCmd}`);
+  if (runLint) {
+    steps.push(`
+      - name: Lint
+        run: ${getRunCommand(packageManager, "lint")}`);
+  }
+  if (runTypecheck) {
+    steps.push(`
+      - name: Type check
+        run: ${getRunCommand(packageManager, "typecheck")}`);
+  }
+  if (runTests) {
+    steps.push(`
+      - name: Run tests
+        run: ${getRunCommand(packageManager, "test")}`);
+  }
+  if (runBuild) {
+    steps.push(`
+      - name: Build
+        run: ${getRunCommand(packageManager, "build")}`);
+  }
+  return `name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    steps:
+${steps.join("\n")}
+`;
+}
+function generateReleaseWorkflow(config) {
+  const { packageManager, nodeVersion } = config;
+  const installCmd = getInstallCommand(packageManager);
+  let setupSteps = "";
+  if (packageManager === "pnpm") {
+    setupSteps = `
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: latest
+`;
+  }
+  return `name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+${setupSteps}
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '${nodeVersion}'
+          cache: '${packageManager}'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: ${installCmd}
+
+      - name: Build
+        run: ${getRunCommand(packageManager, "build")}
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          generate_release_notes: true
+`;
+}
+async function installCICD(projectPath, config, options) {
+  const result = {
+    created: [],
+    skipped: [],
+    errors: []
+  };
+  if (!config.enabled) {
+    return result;
+  }
+  const workflowsDir = joinPath(projectPath, ".github", "workflows");
+  try {
+    await ensureDir(workflowsDir);
+    if (config.ci) {
+      const ciPath = joinPath(workflowsDir, "ci.yml");
+      if (!await pathExists(ciPath) || options?.overwrite) {
+        const content = generateCIWorkflow(config);
+        await writeFile(ciPath, content);
+        result.created.push("ci.yml");
+      } else {
+        result.skipped.push("ci.yml");
+      }
+    }
+    if (config.cd) {
+      const releasePath = joinPath(workflowsDir, "release.yml");
+      if (!await pathExists(releasePath) || options?.overwrite) {
+        const content = generateReleaseWorkflow(config);
+        await writeFile(releasePath, content);
+        result.created.push("release.yml");
+      } else {
+        result.skipped.push("release.yml");
+      }
+    }
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function installCICDWithSpinner(projectPath, config, options) {
+  return withSpinner(
+    "Installing GitHub Actions workflows...",
+    () => installCICD(projectPath, config, options),
+    {
+      successText: "Installed GitHub Actions workflows"
+    }
+  );
+}
+
 // src/lib/code-style/index.ts
 init_cjs_shims();
 
 // src/lib/code-style/installer.ts
 init_cjs_shims();
-var import_node_path = __toESM(require("path"), 1);
-var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_fs_extra2 = __toESM(require("fs-extra"), 1);
 
 // src/constants/code-style-defaults.ts
 init_cjs_shims();
@@ -1726,106 +2064,6 @@ var colors = {
   underline: import_chalk.default.underline
 };
 
-// src/lib/utils/spinner.ts
-init_cjs_shims();
-var import_ora = __toESM(require("ora"), 1);
-var import_picocolors = __toESM(require("picocolors"), 1);
-var SpinnerManager = class {
-  spinner = null;
-  silent = false;
-  configure(options) {
-    if (options.silent !== void 0) this.silent = options.silent;
-  }
-  /**
-   * Start a spinner with a message
-   */
-  start(text, options) {
-    if (this.silent) return null;
-    this.stop();
-    this.spinner = (0, import_ora.default)({
-      text,
-      color: options?.color || "cyan",
-      spinner: "dots"
-    }).start();
-    return this.spinner;
-  }
-  /**
-   * Update spinner text
-   */
-  text(text) {
-    if (this.spinner) {
-      this.spinner.text = text;
-    }
-  }
-  /**
-   * Stop spinner with success message
-   */
-  succeed(text) {
-    if (this.spinner) {
-      this.spinner.succeed(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * Stop spinner with failure message
-   */
-  fail(text) {
-    if (this.spinner) {
-      this.spinner.fail(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * Stop spinner with warning message
-   */
-  warn(text) {
-    if (this.spinner) {
-      this.spinner.warn(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * Stop spinner with info message
-   */
-  info(text) {
-    if (this.spinner) {
-      this.spinner.info(text);
-      this.spinner = null;
-    }
-  }
-  /**
-   * Stop spinner without message
-   */
-  stop() {
-    if (this.spinner) {
-      this.spinner.stop();
-      this.spinner = null;
-    }
-  }
-  /**
-   * Check if spinner is running
-   */
-  isRunning() {
-    return this.spinner?.isSpinning ?? false;
-  }
-};
-var spinner = new SpinnerManager();
-async function withSpinner(text, operation, options) {
-  if (options?.silent) {
-    return operation();
-  }
-  spinner.start(text);
-  try {
-    const result = await operation();
-    spinner.succeed(options?.successText || text);
-    return result;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : "Unknown error";
-    spinner.fail(options?.failText || `${text} - ${import_picocolors.default.red(errorMessage)}`);
-    throw error;
-  }
-}
-
 // src/lib/code-style/generator.ts
 init_cjs_shims();
 function generateEditorConfig(options) {
@@ -2006,14 +2244,14 @@ async function installCodeStyle(targetPath, config, options) {
   spinner.start("Installing code style configurations...");
   if (config.editorconfig) {
     const filename = CODE_STYLE_FILES.editorconfig;
-    const destPath = import_node_path.default.join(targetPath, filename);
+    const destPath = import_node_path2.default.join(targetPath, filename);
     try {
-      if (await import_fs_extra.default.pathExists(destPath) && !options?.overwrite) {
+      if (await import_fs_extra2.default.pathExists(destPath) && !options?.overwrite) {
         result.skipped.push(filename);
       } else {
         const editorconfigOptions = config.editorconfigOptions ?? DEFAULT_EDITORCONFIG_OPTIONS;
         const content = generateEditorConfig(editorconfigOptions);
-        await import_fs_extra.default.writeFile(destPath, content, "utf-8");
+        await import_fs_extra2.default.writeFile(destPath, content, "utf-8");
         result.installed.push(filename);
       }
     } catch (error) {
@@ -2023,14 +2261,14 @@ async function installCodeStyle(targetPath, config, options) {
   }
   if (config.biome) {
     const filename = CODE_STYLE_FILES.biome;
-    const destPath = import_node_path.default.join(targetPath, filename);
+    const destPath = import_node_path2.default.join(targetPath, filename);
     try {
-      if (await import_fs_extra.default.pathExists(destPath) && !options?.overwrite) {
+      if (await import_fs_extra2.default.pathExists(destPath) && !options?.overwrite) {
         result.skipped.push(filename);
       } else {
         const biomeOptions = config.biomeOptions ?? DEFAULT_BIOME_OPTIONS;
         const content = generateBiomeConfig(biomeOptions);
-        await import_fs_extra.default.writeFile(destPath, content, "utf-8");
+        await import_fs_extra2.default.writeFile(destPath, content, "utf-8");
         result.installed.push(filename);
       }
     } catch (error) {
@@ -2040,20 +2278,20 @@ async function installCodeStyle(targetPath, config, options) {
   }
   if (config.prettier) {
     const filename = CODE_STYLE_FILES.prettier;
-    const destPath = import_node_path.default.join(targetPath, filename);
+    const destPath = import_node_path2.default.join(targetPath, filename);
     try {
-      if (await import_fs_extra.default.pathExists(destPath) && !options?.overwrite) {
+      if (await import_fs_extra2.default.pathExists(destPath) && !options?.overwrite) {
         result.skipped.push(filename);
       } else {
         const prettierOptions = config.prettierOptions ?? DEFAULT_PRETTIER_OPTIONS;
         const content = generatePrettierConfig(prettierOptions);
-        await import_fs_extra.default.writeFile(destPath, content, "utf-8");
+        await import_fs_extra2.default.writeFile(destPath, content, "utf-8");
         result.installed.push(filename);
       }
-      const ignoreDest = import_node_path.default.join(targetPath, PRETTIER_IGNORE);
-      if (!await import_fs_extra.default.pathExists(ignoreDest) || options?.overwrite) {
+      const ignoreDest = import_node_path2.default.join(targetPath, PRETTIER_IGNORE);
+      if (!await import_fs_extra2.default.pathExists(ignoreDest) || options?.overwrite) {
         const ignoreContent = generatePrettierIgnore();
-        await import_fs_extra.default.writeFile(ignoreDest, ignoreContent, "utf-8");
+        await import_fs_extra2.default.writeFile(ignoreDest, ignoreContent, "utf-8");
         result.installed.push(PRETTIER_IGNORE);
       }
     } catch (error) {
@@ -2063,14 +2301,14 @@ async function installCodeStyle(targetPath, config, options) {
   }
   if (config.commitlint) {
     const filename = CODE_STYLE_FILES.commitlint;
-    const destPath = import_node_path.default.join(targetPath, filename);
+    const destPath = import_node_path2.default.join(targetPath, filename);
     try {
-      if (await import_fs_extra.default.pathExists(destPath) && !options?.overwrite) {
+      if (await import_fs_extra2.default.pathExists(destPath) && !options?.overwrite) {
         result.skipped.push(filename);
       } else {
         const commitlintOptions = config.commitlintOptions ?? DEFAULT_COMMITLINT_OPTIONS;
         const content = generateCommitlintConfig(commitlintOptions);
-        await import_fs_extra.default.writeFile(destPath, content, "utf-8");
+        await import_fs_extra2.default.writeFile(destPath, content, "utf-8");
         result.installed.push(filename);
       }
     } catch (error) {
@@ -2141,6 +2379,214 @@ function showCodeStyleInstructions(config) {
   }
 }
 
+// src/lib/code-style/vscode-installer.ts
+init_cjs_shims();
+init_fs();
+function generateVSCodeSettings(config) {
+  const settings = {};
+  if (config.biome) {
+    settings["editor.defaultFormatter"] = "biomejs.biome";
+    settings["editor.formatOnSave"] = true;
+    settings["[javascript]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["[javascriptreact]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["[typescript]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["[typescriptreact]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["[json]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["[jsonc]"] = {
+      "editor.defaultFormatter": "biomejs.biome"
+    };
+    settings["eslint.enable"] = false;
+    settings["biome.enabled"] = true;
+    settings["biome.lintOnSave"] = true;
+  }
+  if (config.prettier && !config.biome) {
+    settings["editor.defaultFormatter"] = "esbenp.prettier-vscode";
+    settings["editor.formatOnSave"] = true;
+    settings["[javascript]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+    settings["[javascriptreact]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+    settings["[typescript]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+    settings["[typescriptreact]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+    settings["[json]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+    settings["[markdown]"] = {
+      "editor.defaultFormatter": "esbenp.prettier-vscode"
+    };
+  }
+  if (config.editorconfig) {
+    settings["editor.detectIndentation"] = false;
+  }
+  return settings;
+}
+function generateVSCodeExtensions(config) {
+  const recommendations = [];
+  if (config.biome) {
+    recommendations.push("biomejs.biome");
+  }
+  if (config.prettier && !config.biome) {
+    recommendations.push("esbenp.prettier-vscode");
+  }
+  if (config.editorconfig) {
+    recommendations.push("EditorConfig.EditorConfig");
+  }
+  recommendations.push("dbaeumer.vscode-eslint");
+  return { recommendations };
+}
+async function installVSCodeSettings(projectPath, config, options) {
+  if (!config.enabled) {
+    return {
+      created: false,
+      updated: false,
+      skipped: true,
+      path: ""
+    };
+  }
+  const vscodeDir = joinPath(projectPath, ".vscode");
+  const settingsPath = joinPath(vscodeDir, "settings.json");
+  try {
+    const newSettings = generateVSCodeSettings(config);
+    const exists = await pathExists(settingsPath);
+    if (exists) {
+      if (options?.merge) {
+        const existingContent = await readFile(settingsPath);
+        let existingSettings = {};
+        try {
+          existingSettings = JSON.parse(existingContent);
+        } catch {
+          logger.warn("Could not parse existing settings.json, will overwrite");
+        }
+        const mergedSettings = { ...existingSettings, ...newSettings };
+        await writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+        return {
+          created: false,
+          updated: true,
+          skipped: false,
+          path: settingsPath
+        };
+      }
+      if (!options?.overwrite) {
+        return {
+          created: false,
+          updated: false,
+          skipped: true,
+          path: settingsPath
+        };
+      }
+    }
+    await ensureDir(vscodeDir);
+    await writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+    return {
+      created: !exists,
+      updated: exists,
+      skipped: false,
+      path: settingsPath
+    };
+  } catch (error) {
+    return {
+      created: false,
+      updated: false,
+      skipped: false,
+      path: settingsPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function installVSCodeExtensions(projectPath, config, options) {
+  if (!config.enabled) {
+    return {
+      created: false,
+      updated: false,
+      skipped: true,
+      path: ""
+    };
+  }
+  const vscodeDir = joinPath(projectPath, ".vscode");
+  const extensionsPath = joinPath(vscodeDir, "extensions.json");
+  try {
+    const newExtensions = generateVSCodeExtensions(config);
+    const exists = await pathExists(extensionsPath);
+    if (exists) {
+      if (options?.merge) {
+        const existingContent = await readFile(extensionsPath);
+        let existingExtensions = { recommendations: [] };
+        try {
+          existingExtensions = JSON.parse(existingContent);
+        } catch {
+          logger.warn("Could not parse existing extensions.json, will overwrite");
+        }
+        const mergedRecommendations = [
+          .../* @__PURE__ */ new Set([
+            ...existingExtensions.recommendations || [],
+            ...newExtensions.recommendations
+          ])
+        ];
+        await writeFile(
+          extensionsPath,
+          JSON.stringify({ recommendations: mergedRecommendations }, null, 2)
+        );
+        return {
+          created: false,
+          updated: true,
+          skipped: false,
+          path: extensionsPath
+        };
+      }
+      if (!options?.overwrite) {
+        return {
+          created: false,
+          updated: false,
+          skipped: true,
+          path: extensionsPath
+        };
+      }
+    }
+    await ensureDir(vscodeDir);
+    await writeFile(extensionsPath, JSON.stringify(newExtensions, null, 2));
+    return {
+      created: !exists,
+      updated: exists,
+      skipped: false,
+      path: extensionsPath
+    };
+  } catch (error) {
+    return {
+      created: false,
+      updated: false,
+      skipped: false,
+      path: extensionsPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function installVSCodeConfig(projectPath, config, options) {
+  const [settingsResult, extensionsResult] = await Promise.all([
+    installVSCodeSettings(projectPath, config, options),
+    installVSCodeExtensions(projectPath, config, options)
+  ]);
+  return {
+    settings: settingsResult,
+    extensions: extensionsResult
+  };
+}
+
 // src/lib/config/index.ts
 init_cjs_shims();
 
@@ -2802,7 +3248,172 @@ function formatManualInstallInstructions(report) {
       lines.push("");
     }
   }
-  return lines;
+  return lines;
+}
+
+// src/lib/git-hooks/index.ts
+init_cjs_shims();
+
+// src/lib/git-hooks/husky-installer.ts
+init_cjs_shims();
+init_fs();
+function generateCommitMsgHook() {
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx --no -- commitlint --edit "\${1}"
+`;
+}
+function generatePreCommitHook(lintCommand) {
+  const command = lintCommand || "pnpm lint-staged";
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${command}
+`;
+}
+function generatePrePushHook(testCommand) {
+  const command = testCommand || "pnpm test";
+  return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${command}
+`;
+}
+function generateHuskyScript() {
+  return `#!/usr/bin/env sh
+if [ -z "$husky_skip_init" ]; then
+  debug () {
+    if [ "$HUSKY_DEBUG" = "1" ]; then
+      echo "husky (debug) - $1"
+    fi
+  }
+
+  readonly hook_name="$(basename -- "$0")"
+  debug "starting $hook_name..."
+
+  if [ "$HUSKY" = "0" ]; then
+    debug "HUSKY env variable is set to 0, skipping hook"
+    exit 0
+  fi
+
+  if [ -f ~/.huskyrc ]; then
+    debug "sourcing ~/.huskyrc"
+    . ~/.huskyrc
+  fi
+
+  readonly husky_skip_init=1
+  export husky_skip_init
+  sh -e "$0" "$@"
+  exitCode="$?"
+
+  if [ $exitCode != 0 ]; then
+    echo "husky - $hook_name hook exited with code $exitCode (error)"
+  fi
+
+  if [ $exitCode = 127 ]; then
+    echo "husky - command not found in PATH=$PATH"
+  fi
+
+  exit $exitCode
+fi
+`;
+}
+function generateHuskyGitignore() {
+  return `_
+`;
+}
+async function installHusky(projectPath, config, options) {
+  const result = {
+    created: [],
+    skipped: [],
+    errors: [],
+    initialized: false
+  };
+  const huskyDir = joinPath(projectPath, ".husky");
+  const huskyInternalDir = joinPath(huskyDir, "_");
+  try {
+    await ensureDir(huskyDir);
+    await ensureDir(huskyInternalDir);
+    result.initialized = true;
+    const huskyScriptPath = joinPath(huskyInternalDir, "husky.sh");
+    if (!await pathExists(huskyScriptPath) || options?.overwrite) {
+      await writeFile(huskyScriptPath, generateHuskyScript());
+      await makeExecutable(huskyScriptPath);
+      result.created.push("_/husky.sh");
+    } else {
+      result.skipped.push("_/husky.sh");
+    }
+    const gitignorePath = joinPath(huskyInternalDir, ".gitignore");
+    if (!await pathExists(gitignorePath) || options?.overwrite) {
+      await writeFile(gitignorePath, generateHuskyGitignore());
+      result.created.push("_/.gitignore");
+    }
+    if (config.commitlint) {
+      const commitMsgPath = joinPath(huskyDir, "commit-msg");
+      if (!await pathExists(commitMsgPath) || options?.overwrite) {
+        await writeFile(commitMsgPath, generateCommitMsgHook());
+        await makeExecutable(commitMsgPath);
+        result.created.push("commit-msg");
+      } else {
+        result.skipped.push("commit-msg");
+      }
+    }
+    if (config.preCommit) {
+      const preCommitPath = joinPath(huskyDir, "pre-commit");
+      if (!await pathExists(preCommitPath) || options?.overwrite) {
+        await writeFile(preCommitPath, generatePreCommitHook(config.lintCommand));
+        await makeExecutable(preCommitPath);
+        result.created.push("pre-commit");
+      } else {
+        result.skipped.push("pre-commit");
+      }
+    }
+    if (config.prePush) {
+      const prePushPath = joinPath(huskyDir, "pre-push");
+      if (!await pathExists(prePushPath) || options?.overwrite) {
+        await writeFile(prePushPath, generatePrePushHook(config.testCommand));
+        await makeExecutable(prePushPath);
+        result.created.push("pre-push");
+      } else {
+        result.skipped.push("pre-push");
+      }
+    }
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function installHuskyWithSpinner(projectPath, config, options) {
+  return withSpinner(
+    "Installing Husky hooks...",
+    () => installHusky(projectPath, config, options),
+    {
+      successText: "Installed Husky hooks"
+    }
+  );
+}
+function deriveHuskyConfigFromCodeStyle(codeStyle) {
+  if (!codeStyle.enabled) {
+    return null;
+  }
+  const commitlintEnabled = codeStyle.commitlint && codeStyle.commitlintOptions?.huskyIntegration;
+  if (!commitlintEnabled) {
+    return null;
+  }
+  let lintCommand;
+  if (codeStyle.biome) {
+    lintCommand = "pnpm biome check --staged";
+  } else if (codeStyle.prettier) {
+    lintCommand = "pnpm lint-staged";
+  }
+  return {
+    commitlint: true,
+    preCommit: !!lintCommand,
+    lintCommand,
+    prePush: false
+    // Don't run tests on push by default
+  };
 }
 
 // src/lib/hooks/index.ts
@@ -3008,44 +3619,72 @@ var os2 = __toESM(require("os"), 1);
 init_cjs_shims();
 var MCP_SERVERS = [
   // ============================================
-  // DOCUMENTATION
+  // DOCUMENTATION & AI TOOLS
   // ============================================
   {
     id: "context7",
     name: "Context7",
-    description: "Documentation lookup for libraries and frameworks",
-    package: "@anthropic/context7-mcp",
+    description: "Up-to-date documentation lookup for libraries and frameworks",
+    package: "@upstash/context7-mcp",
     category: "documentation",
-    requiresConfig: false
+    requiresConfig: false,
+    installInstructions: "API keys provide higher rate limits. Get one at https://context7.com/dashboard"
+  },
+  {
+    id: "perplexity",
+    name: "Perplexity",
+    description: "Web search without leaving the MCP ecosystem via Sonar API",
+    package: "@chatmcp/server-perplexity-ask",
+    category: "search",
+    requiresConfig: true,
+    configFields: [
+      {
+        name: "apiKey",
+        type: "string",
+        required: true,
+        description: "Perplexity/Sonar API Key",
+        envVar: "PERPLEXITY_API_KEY"
+      }
+    ],
+    installInstructions: "Get API key at https://www.perplexity.ai/settings/api"
+  },
+  {
+    id: "sequential-thinking",
+    name: "Sequential Thinking",
+    description: "Dynamic problem-solving through structured thinking process",
+    package: "@modelcontextprotocol/server-sequential-thinking",
+    category: "ai",
+    requiresConfig: false,
+    installInstructions: "Helps break down complex problems into manageable steps."
   },
   // ============================================
   // TESTING & BROWSER AUTOMATION
   // ============================================
   {
-    id: "chrome-devtools",
-    name: "Chrome DevTools",
-    description: "Browser automation, debugging, and performance profiling via Chrome DevTools Protocol",
-    package: "@anthropic/chrome-devtools-mcp",
+    id: "puppeteer",
+    name: "Puppeteer",
+    description: "Headless Chrome automation for testing and scraping",
+    package: "@modelcontextprotocol/server-puppeteer",
     category: "testing",
-    requiresConfig: false,
-    installInstructions: "Requires Chrome/Chromium browser installed on the system."
+    requiresConfig: false
   },
   {
     id: "playwright",
     name: "Playwright",
-    description: "Cross-browser end-to-end testing and automation",
-    package: "@anthropic/playwright-mcp",
+    description: "Browser automation via accessibility snapshots, not screenshots",
+    package: "@playwright/mcp",
     category: "testing",
     requiresConfig: false,
-    installInstructions: "Run `npx playwright install` after setup to install browsers."
+    installInstructions: "Requires Node.js 18+. Supports Chrome, Firefox, WebKit."
   },
   {
-    id: "puppeteer",
-    name: "Puppeteer",
-    description: "Headless Chrome automation for testing and scraping",
-    package: "@anthropic/puppeteer-mcp",
+    id: "chrome-devtools",
+    name: "Chrome DevTools",
+    description: "Control and inspect live Chrome browser with DevTools Protocol",
+    package: "chrome-devtools-mcp",
     category: "testing",
-    requiresConfig: false
+    requiresConfig: false,
+    installInstructions: "Requires Chrome installed. For Claude Code: claude mcp add chrome-devtools npx chrome-devtools-mcp@latest"
   },
   // ============================================
   // VERSION CONTROL
@@ -3053,7 +3692,7 @@ var MCP_SERVERS = [
   {
     id: "github",
     name: "GitHub",
-    description: "GitHub API integration (issues, PRs, repos)",
+    description: "GitHub API integration (issues, PRs, repos, file operations)",
     package: "@modelcontextprotocol/server-github",
     category: "version-control",
     requiresConfig: true,
@@ -3066,32 +3705,33 @@ var MCP_SERVERS = [
         envVar: "GITHUB_TOKEN"
       }
     ],
-    installInstructions: "Create a Personal Access Token at https://github.com/settings/tokens with repo, issues, and pull_request scopes."
+    installInstructions: "Create a Personal Access Token at https://github.com/settings/tokens with repo scope."
   },
   {
     id: "gitlab",
     name: "GitLab",
-    description: "GitLab API integration (issues, MRs, repos)",
-    package: "@anthropic/gitlab-mcp",
+    description: "GitLab API for project management, issues, and merge requests",
+    package: "@modelcontextprotocol/server-gitlab",
     category: "version-control",
     requiresConfig: true,
     configFields: [
       {
         name: "token",
         type: "string",
-        required: false,
+        required: true,
         description: "GitLab Personal Access Token",
-        envVar: "GITLAB_TOKEN"
+        envVar: "GITLAB_PERSONAL_ACCESS_TOKEN"
       },
       {
-        name: "baseUrl",
+        name: "apiUrl",
         type: "string",
         required: false,
-        description: "GitLab instance URL (default: https://gitlab.com)",
-        default: "https://gitlab.com"
+        description: "GitLab API URL (default: https://gitlab.com/api/v4)",
+        envVar: "GITLAB_API_URL",
+        default: "https://gitlab.com/api/v4"
       }
     ],
-    installInstructions: "Create a Personal Access Token at GitLab Settings > Access Tokens with api scope."
+    installInstructions: "Create PAT at GitLab User Settings > Access Tokens with api, read_repository, write_repository scopes."
   },
   // ============================================
   // DATABASES
@@ -3099,7 +3739,7 @@ var MCP_SERVERS = [
   {
     id: "postgres",
     name: "PostgreSQL",
-    description: "Direct PostgreSQL database access",
+    description: "Read-only PostgreSQL database access with schema inspection",
     package: "@modelcontextprotocol/server-postgres",
     category: "database",
     requiresConfig: true,
@@ -3115,63 +3755,45 @@ var MCP_SERVERS = [
     installInstructions: "Connection string format: postgresql://user:password@host:port/database"
   },
   {
-    id: "neon",
-    name: "Neon",
-    description: "Neon serverless PostgreSQL",
-    package: "@neondatabase/mcp-server-neon",
-    category: "database",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "apiKey",
-        type: "string",
-        required: false,
-        description: "Neon API Key",
-        envVar: "NEON_API_KEY"
-      }
-    ],
-    installInstructions: "Get your API key from https://console.neon.tech/app/settings/api-keys"
-  },
-  {
-    id: "mongodb",
-    name: "MongoDB",
-    description: "MongoDB document database access",
-    package: "@anthropic/mongodb-mcp",
+    id: "mysql",
+    name: "MySQL",
+    description: "Read-only MySQL/MariaDB database access",
+    package: "@modelcontextprotocol/server-mysql",
     category: "database",
     requiresConfig: true,
     configFields: [
       {
         name: "connectionString",
         type: "string",
-        required: false,
-        description: "MongoDB connection string",
-        envVar: "MONGODB_URI"
+        required: true,
+        description: "MySQL connection URL",
+        envVar: "MYSQL_URL"
       }
     ],
-    installInstructions: "Connection string format: mongodb://user:password@host:port/database or mongodb+srv://..."
+    installInstructions: "Connection format: mysql://user:password@host:port/database"
   },
   {
-    id: "mysql",
-    name: "MySQL",
-    description: "MySQL/MariaDB database access",
-    package: "@anthropic/mysql-mcp",
+    id: "neon",
+    name: "Neon",
+    description: "Neon serverless PostgreSQL with branch management",
+    package: "@neondatabase/mcp-server-neon",
     category: "database",
     requiresConfig: true,
     configFields: [
       {
-        name: "connectionString",
+        name: "apiKey",
         type: "string",
         required: false,
-        description: "MySQL connection string",
-        envVar: "MYSQL_URL"
+        description: "Neon API Key",
+        envVar: "NEON_API_KEY"
       }
     ],
-    installInstructions: "Connection string format: mysql://user:password@host:port/database"
+    installInstructions: "Get your API key from https://console.neon.tech/app/settings/api-keys"
   },
   {
     id: "sqlite",
     name: "SQLite",
-    description: "SQLite local database access",
+    description: "SQLite database interaction and business intelligence",
     package: "@modelcontextprotocol/server-sqlite",
     category: "database",
     requiresConfig: true,
@@ -3188,27 +3810,20 @@ var MCP_SERVERS = [
   {
     id: "supabase",
     name: "Supabase",
-    description: "Supabase backend-as-a-service (DB, Auth, Storage)",
-    package: "@supabase/mcp-server",
+    description: "Supabase projects, database, Edge Functions, and type generation",
+    package: "@supabase/mcp-server-supabase",
     category: "database",
     requiresConfig: true,
     configFields: [
       {
-        name: "url",
-        type: "string",
-        required: false,
-        description: "Supabase project URL",
-        envVar: "SUPABASE_URL"
-      },
-      {
-        name: "anonKey",
+        name: "accessToken",
         type: "string",
         required: false,
-        description: "Supabase anon/public key",
-        envVar: "SUPABASE_ANON_KEY"
+        description: "Supabase Personal Access Token",
+        envVar: "SUPABASE_ACCESS_TOKEN"
       }
     ],
-    installInstructions: "Find your project URL and anon key in Supabase Dashboard > Settings > API"
+    installInstructions: "Get your access token from https://supabase.com/dashboard/account/tokens"
   },
   // ============================================
   // CACHE & KEY-VALUE STORES
@@ -3216,8 +3831,8 @@ var MCP_SERVERS = [
   {
     id: "redis",
     name: "Redis",
-    description: "Redis cache and key-value store",
-    package: "@anthropic/redis-mcp",
+    description: "Redis key-value store operations (set, get, delete, list)",
+    package: "@modelcontextprotocol/server-redis",
     category: "cache",
     requiresConfig: true,
     configFields: [
@@ -3230,29 +3845,29 @@ var MCP_SERVERS = [
         default: "redis://localhost:6379"
       }
     ],
-    installInstructions: "Connection URL format: redis://[[user]:password@]host[:port][/db]"
+    installInstructions: "Pass Redis URL as argument: npx @modelcontextprotocol/server-redis redis://localhost:6379"
   },
   {
     id: "upstash",
     name: "Upstash",
-    description: "Upstash serverless Redis and Kafka",
+    description: "Upstash Redis database management and commands",
     package: "@upstash/mcp-server",
     category: "cache",
     requiresConfig: true,
     configFields: [
       {
-        name: "url",
+        name: "email",
         type: "string",
         required: false,
-        description: "Upstash Redis REST URL",
-        envVar: "UPSTASH_REDIS_REST_URL"
+        description: "Upstash account email",
+        envVar: "UPSTASH_EMAIL"
       },
       {
-        name: "token",
+        name: "apiKey",
         type: "string",
         required: false,
-        description: "Upstash Redis REST token",
-        envVar: "UPSTASH_REDIS_REST_TOKEN"
+        description: "Upstash API Key",
+        envVar: "UPSTASH_API_KEY"
       }
     ],
     installInstructions: "Get credentials from https://console.upstash.com"
@@ -3260,57 +3875,14 @@ var MCP_SERVERS = [
   // ============================================
   // DEPLOYMENT & INFRASTRUCTURE
   // ============================================
-  {
-    id: "vercel",
-    name: "Vercel",
-    description: "Vercel deployment and project management",
-    package: "@vercel/mcp",
-    category: "deployment",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Vercel Access Token",
-        envVar: "VERCEL_TOKEN"
-      }
-    ],
-    installInstructions: "Create an access token at https://vercel.com/account/tokens"
-  },
-  {
-    id: "netlify",
-    name: "Netlify",
-    description: "Netlify deployment and site management",
-    package: "@anthropic/netlify-mcp",
-    category: "deployment",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Netlify Personal Access Token",
-        envVar: "NETLIFY_TOKEN"
-      }
-    ],
-    installInstructions: "Create a token at https://app.netlify.com/user/applications#personal-access-tokens"
-  },
   {
     id: "cloudflare",
     name: "Cloudflare",
-    description: "Cloudflare Workers, Pages, and DNS management",
-    package: "@cloudflare/mcp-server",
+    description: "Cloudflare Workers, D1, KV, R2, and DNS management",
+    package: "@cloudflare/mcp-server-cloudflare",
     category: "deployment",
     requiresConfig: true,
     configFields: [
-      {
-        name: "apiToken",
-        type: "string",
-        required: false,
-        description: "Cloudflare API Token",
-        envVar: "CLOUDFLARE_API_TOKEN"
-      },
       {
         name: "accountId",
         type: "string",
@@ -3319,170 +3891,89 @@ var MCP_SERVERS = [
         envVar: "CLOUDFLARE_ACCOUNT_ID"
       }
     ],
-    installInstructions: "Create an API token at https://dash.cloudflare.com/profile/api-tokens"
-  },
-  {
-    id: "aws",
-    name: "AWS",
-    description: "Amazon Web Services integration",
-    package: "@anthropic/aws-mcp",
-    category: "infrastructure",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "accessKeyId",
-        type: "string",
-        required: false,
-        description: "AWS Access Key ID",
-        envVar: "AWS_ACCESS_KEY_ID"
-      },
-      {
-        name: "secretAccessKey",
-        type: "string",
-        required: false,
-        description: "AWS Secret Access Key",
-        envVar: "AWS_SECRET_ACCESS_KEY"
-      },
-      {
-        name: "region",
-        type: "string",
-        required: false,
-        description: "AWS Region",
-        envVar: "AWS_REGION",
-        default: "us-east-1"
-      }
-    ],
-    installInstructions: "Create credentials in AWS IAM Console with appropriate permissions."
-  },
-  {
-    id: "docker",
-    name: "Docker",
-    description: "Docker container management",
-    package: "@anthropic/docker-mcp",
-    category: "infrastructure",
-    requiresConfig: false,
-    installInstructions: "Requires Docker Desktop or Docker Engine installed."
+    installInstructions: "Run: npx @cloudflare/mcp-server-cloudflare init"
   },
   {
-    id: "kubernetes",
-    name: "Kubernetes",
-    description: "Kubernetes cluster management",
-    package: "@anthropic/kubernetes-mcp",
-    category: "infrastructure",
+    id: "vercel",
+    name: "Vercel",
+    description: "Vercel deployments, DNS records, and project management",
+    package: "vercel-mcp",
+    category: "deployment",
     requiresConfig: true,
     configFields: [
       {
-        name: "kubeconfig",
-        type: "string",
-        required: false,
-        description: "Path to kubeconfig file",
-        default: "~/.kube/config"
-      },
-      {
-        name: "context",
+        name: "apiKey",
         type: "string",
-        required: false,
-        description: "Kubernetes context to use"
+        required: true,
+        description: "Vercel API Key",
+        envVar: "VERCEL_API_KEY"
       }
     ],
-    installInstructions: "Requires kubectl installed and configured."
+    installInstructions: "Get API key at https://vercel.com/account/tokens"
   },
   {
     id: "filesystem",
     name: "Filesystem",
-    description: "Enhanced filesystem operations",
+    description: "Secure file operations with configurable access controls",
     package: "@modelcontextprotocol/server-filesystem",
     category: "infrastructure",
     requiresConfig: false
   },
-  // ============================================
-  // PROJECT MANAGEMENT
-  // ============================================
-  {
-    id: "linear",
-    name: "Linear",
-    description: "Linear project management integration",
-    package: "@anthropic/linear-mcp",
-    category: "project-mgmt",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "apiKey",
-        type: "string",
-        required: false,
-        description: "Linear API Key",
-        envVar: "LINEAR_API_KEY"
-      }
-    ],
-    installInstructions: "Create an API key at https://linear.app/settings/api"
-  },
   {
-    id: "jira",
-    name: "Jira",
-    description: "Atlassian Jira issue tracking",
-    package: "@anthropic/jira-mcp",
-    category: "project-mgmt",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "host",
-        type: "string",
-        required: false,
-        description: "Jira instance URL",
-        envVar: "JIRA_HOST"
-      },
-      {
-        name: "email",
-        type: "string",
-        required: false,
-        description: "Jira account email",
-        envVar: "JIRA_EMAIL"
-      },
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Jira API Token",
-        envVar: "JIRA_TOKEN"
-      }
-    ],
-    installInstructions: "Create an API token at https://id.atlassian.com/manage-profile/security/api-tokens"
+    id: "memory",
+    name: "Memory",
+    description: "Knowledge graph-based persistent memory system",
+    package: "@modelcontextprotocol/server-memory",
+    category: "infrastructure",
+    requiresConfig: false,
+    installInstructions: "Memory is stored in memory.jsonl in the server directory by default."
   },
+  // ============================================
+  // PROJECT MANAGEMENT & PRODUCTIVITY
+  // ============================================
   {
     id: "notion",
     name: "Notion",
-    description: "Notion workspace, pages, and databases",
-    package: "@anthropic/notion-mcp",
+    description: "Official Notion API for pages, databases, and workspace",
+    package: "@notionhq/notion-mcp-server",
     category: "project-mgmt",
     requiresConfig: true,
     configFields: [
       {
         name: "token",
         type: "string",
-        required: false,
+        required: true,
         description: "Notion Integration Token",
         envVar: "NOTION_TOKEN"
       }
     ],
-    installInstructions: "Create an integration at https://www.notion.so/my-integrations and share pages with it."
+    installInstructions: "Create integration at https://www.notion.so/profile/integrations and share pages with it."
   },
   {
-    id: "asana",
-    name: "Asana",
-    description: "Asana project and task management",
-    package: "@anthropic/asana-mcp",
+    id: "obsidian",
+    name: "Obsidian",
+    description: "Read and search Obsidian vaults and Markdown directories",
+    package: "mcp-obsidian",
     category: "project-mgmt",
     requiresConfig: true,
     configFields: [
       {
-        name: "token",
+        name: "vaultPath",
         type: "string",
-        required: false,
-        description: "Asana Personal Access Token",
-        envVar: "ASANA_TOKEN"
+        required: true,
+        description: "Path to Obsidian vault"
       }
     ],
-    installInstructions: "Create a PAT at https://app.asana.com/0/my-apps"
+    installInstructions: "Works with any Markdown directory. Point to your vault path."
+  },
+  {
+    id: "n8n",
+    name: "n8n",
+    description: "n8n workflow automation node documentation and management",
+    package: "n8n-mcp",
+    category: "project-mgmt",
+    requiresConfig: false,
+    installInstructions: "Provides access to 543 n8n nodes documentation."
   },
   // ============================================
   // MONITORING & OBSERVABILITY
@@ -3490,7 +3981,7 @@ var MCP_SERVERS = [
   {
     id: "sentry",
     name: "Sentry",
-    description: "Error monitoring and tracking",
+    description: "Query Sentry errors, issues, and project information",
     package: "@sentry/mcp-server",
     category: "monitoring",
     requiresConfig: true,
@@ -3501,255 +3992,145 @@ var MCP_SERVERS = [
         required: false,
         description: "Sentry Auth Token",
         envVar: "SENTRY_AUTH_TOKEN"
-      },
-      {
-        name: "org",
-        type: "string",
-        required: false,
-        description: "Sentry Organization slug"
-      }
-    ],
-    installInstructions: "Create an auth token at https://sentry.io/settings/account/api/auth-tokens/"
-  },
-  {
-    id: "datadog",
-    name: "Datadog",
-    description: "Datadog monitoring and APM",
-    package: "@anthropic/datadog-mcp",
-    category: "monitoring",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "apiKey",
-        type: "string",
-        required: false,
-        description: "Datadog API Key",
-        envVar: "DD_API_KEY"
-      },
-      {
-        name: "appKey",
-        type: "string",
-        required: false,
-        description: "Datadog Application Key",
-        envVar: "DD_APP_KEY"
-      },
-      {
-        name: "site",
-        type: "string",
-        required: false,
-        description: "Datadog site (e.g., datadoghq.com)",
-        default: "datadoghq.com"
-      }
-    ],
-    installInstructions: "Find keys at https://app.datadoghq.com/organization-settings/api-keys"
-  },
-  // ============================================
-  // COMMUNICATION
-  // ============================================
-  {
-    id: "slack",
-    name: "Slack",
-    description: "Slack messaging and channel management",
-    package: "@anthropic/slack-mcp",
-    category: "communication",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Slack Bot Token (xoxb-...)",
-        envVar: "SLACK_BOT_TOKEN"
-      }
-    ],
-    installInstructions: "Create a Slack app at https://api.slack.com/apps and install to your workspace."
-  },
-  {
-    id: "discord",
-    name: "Discord",
-    description: "Discord bot and server management",
-    package: "@anthropic/discord-mcp",
-    category: "communication",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Discord Bot Token",
-        envVar: "DISCORD_BOT_TOKEN"
-      }
-    ],
-    installInstructions: "Create a bot at https://discord.com/developers/applications"
-  },
-  // ============================================
-  // DESIGN
-  // ============================================
-  {
-    id: "figma",
-    name: "Figma",
-    description: "Figma design file access and inspection",
-    package: "@anthropic/figma-mcp",
-    category: "design",
-    requiresConfig: true,
-    configFields: [
-      {
-        name: "token",
-        type: "string",
-        required: false,
-        description: "Figma Personal Access Token",
-        envVar: "FIGMA_TOKEN"
       }
     ],
-    installInstructions: "Create a token at https://www.figma.com/developers/api#access-tokens"
+    installInstructions: "For Claude Code: claude mcp add --transport http sentry https://mcp.sentry.dev/mcp"
   },
   // ============================================
-  // PAYMENTS
+  // COMMUNICATION
   // ============================================
   {
-    id: "stripe",
-    name: "Stripe",
-    description: "Stripe payments API integration",
-    package: "@stripe/mcp-server",
-    category: "payments",
+    id: "slack",
+    name: "Slack",
+    description: "Slack messaging, channels, and workspace interaction",
+    package: "@modelcontextprotocol/server-slack",
+    category: "communication",
     requiresConfig: true,
     configFields: [
       {
-        name: "secretKey",
+        name: "token",
         type: "string",
         required: false,
-        description: "Stripe Secret Key",
-        envVar: "STRIPE_SECRET_KEY"
+        description: "Slack Bot Token (xoxb-...)",
+        envVar: "SLACK_BOT_TOKEN"
       }
     ],
-    installInstructions: "Find your API keys at https://dashboard.stripe.com/apikeys (use test keys for development)"
+    installInstructions: "Create a Slack app at https://api.slack.com/apps and install to your workspace."
   },
   // ============================================
-  // SEARCH
+  // DESIGN
   // ============================================
   {
-    id: "algolia",
-    name: "Algolia",
-    description: "Algolia search and discovery",
-    package: "@anthropic/algolia-mcp",
-    category: "search",
+    id: "figma",
+    name: "Figma",
+    description: "Figma layout information for AI coding agents",
+    package: "figma-developer-mcp",
+    category: "design",
     requiresConfig: true,
     configFields: [
-      {
-        name: "appId",
-        type: "string",
-        required: false,
-        description: "Algolia Application ID",
-        envVar: "ALGOLIA_APP_ID"
-      },
       {
         name: "apiKey",
         type: "string",
-        required: false,
-        description: "Algolia Admin API Key",
-        envVar: "ALGOLIA_API_KEY"
+        required: true,
+        description: "Figma Personal Access Token",
+        envVar: "FIGMA_API_KEY"
       }
     ],
-    installInstructions: "Find credentials at https://www.algolia.com/account/api-keys/"
+    installInstructions: "Create token at https://www.figma.com/developers/api#access-tokens"
   },
   {
-    id: "elasticsearch",
-    name: "Elasticsearch",
-    description: "Elasticsearch search engine",
-    package: "@anthropic/elasticsearch-mcp",
-    category: "search",
+    id: "shadcn",
+    name: "shadcn/ui",
+    description: "shadcn/ui component docs, installation, and code generation",
+    package: "@heilgar/shadcn-ui-mcp-server",
+    category: "ui-library",
+    requiresConfig: false,
+    installInstructions: "Supports npm, pnpm, yarn, and bun package managers."
+  },
+  {
+    id: "magic-ui",
+    name: "21st.dev Magic",
+    description: "AI-driven UI component generation through natural language",
+    package: "@21st-dev/magic",
+    category: "ui-library",
     requiresConfig: true,
     configFields: [
-      {
-        name: "node",
-        type: "string",
-        required: false,
-        description: "Elasticsearch node URL",
-        envVar: "ELASTICSEARCH_NODE",
-        default: "http://localhost:9200"
-      },
       {
         name: "apiKey",
         type: "string",
-        required: false,
-        description: "Elasticsearch API Key (optional)",
-        envVar: "ELASTICSEARCH_API_KEY"
+        required: true,
+        description: "21st.dev Magic API Key",
+        envVar: "TWENTYFIRST_API_KEY"
       }
-    ]
+    ],
+    installInstructions: "Get API key at https://21st.dev/magic/console"
   },
   // ============================================
-  // AI & ML
+  // PAYMENTS
   // ============================================
   {
-    id: "openai",
-    name: "OpenAI",
-    description: "OpenAI API for GPT and embeddings",
-    package: "@anthropic/openai-mcp",
-    category: "ai",
+    id: "stripe",
+    name: "Stripe",
+    description: "Stripe payments API with MCP support via Agent Toolkit",
+    package: "@stripe/agent-toolkit",
+    category: "payments",
     requiresConfig: true,
     configFields: [
       {
-        name: "apiKey",
+        name: "secretKey",
         type: "string",
         required: false,
-        description: "OpenAI API Key",
-        envVar: "OPENAI_API_KEY"
+        description: "Stripe Secret Key",
+        envVar: "STRIPE_SECRET_KEY"
       }
     ],
-    installInstructions: "Get your API key at https://platform.openai.com/api-keys"
+    installInstructions: "Get API keys at https://dashboard.stripe.com/apikeys. Run: npx -y @stripe/mcp --tools=all --api-key=YOUR_KEY"
   },
   {
-    id: "pinecone",
-    name: "Pinecone",
-    description: "Pinecone vector database for embeddings",
-    package: "@anthropic/pinecone-mcp",
-    category: "ai",
+    id: "mercadopago",
+    name: "Mercado Pago",
+    description: "Mercado Pago payments, refunds, and customer management",
+    package: "mercado-pago-mcp",
+    category: "payments",
     requiresConfig: true,
     configFields: [
       {
-        name: "apiKey",
+        name: "accessToken",
         type: "string",
-        required: false,
-        description: "Pinecone API Key",
-        envVar: "PINECONE_API_KEY"
+        required: true,
+        description: "Mercado Pago Access Token",
+        envVar: "MERCADOPAGO_ACCESS_TOKEN"
       },
       {
         name: "environment",
         type: "string",
         required: false,
-        description: "Pinecone environment",
-        envVar: "PINECONE_ENVIRONMENT"
+        description: "Environment (sandbox or production)",
+        default: "sandbox"
       }
     ],
-    installInstructions: "Get credentials at https://app.pinecone.io/"
+    installInstructions: "Get credentials at https://www.mercadopago.com/developers/panel/app"
   },
   // ============================================
-  // SECURITY
+  // SEARCH
   // ============================================
   {
-    id: "vault",
-    name: "HashiCorp Vault",
-    description: "Secrets management with HashiCorp Vault",
-    package: "@anthropic/vault-mcp",
-    category: "security",
+    id: "brave-search",
+    name: "Brave Search",
+    description: "Web and local search using Brave Search API",
+    package: "@modelcontextprotocol/server-brave-search",
+    category: "search",
     requiresConfig: true,
     configFields: [
       {
-        name: "address",
-        type: "string",
-        required: false,
-        description: "Vault server address",
-        envVar: "VAULT_ADDR",
-        default: "http://127.0.0.1:8200"
-      },
-      {
-        name: "token",
+        name: "apiKey",
         type: "string",
         required: false,
-        description: "Vault token",
-        envVar: "VAULT_TOKEN"
+        description: "Brave Search API Key",
+        envVar: "BRAVE_API_KEY"
       }
-    ]
+    ],
+    installInstructions: "Get an API key at https://brave.com/search/api/"
   }
 ];
 function getMcpServer(id) {
@@ -4087,6 +4468,29 @@ async function installModules(category, modules, options) {
   }
   return result;
 }
+async function installCategoryReadme(category, options) {
+  const sourceReadme = joinPath(options.templatesPath, category, "README.md");
+  const targetReadme = joinPath(options.targetPath, ".claude", category, "README.md");
+  if (!await pathExists(sourceReadme)) {
+    logger.debug(`No README found for category: ${category}`);
+    return;
+  }
+  const targetExists = await pathExists(targetReadme);
+  if (targetExists && !options.overwrite) {
+    logger.debug(`README already exists for ${category}, skipping`);
+    return;
+  }
+  if (options.dryRun) {
+    logger.debug(`Would install README for ${category}`);
+    return;
+  }
+  try {
+    await copy(sourceReadme, targetReadme, { overwrite: options.overwrite });
+    logger.debug(`Installed README for ${category}`);
+  } catch (error) {
+    logger.debug(`Failed to install README for ${category}: ${error}`);
+  }
+}
 async function installAllModules(modulesByCategory, options) {
   const results = {};
   const categories = ["agents", "skills", "commands", "docs"];
@@ -4109,6 +4513,7 @@ async function installAllModules(modulesByCategory, options) {
         silent: options.dryRun
       }
     );
+    await installCategoryReadme(category, options);
   }
   return results;
 }
@@ -4619,7 +5024,7 @@ async function updatePackageJson(projectPath, changes, options = {}) {
     return result;
   }
 }
-function getInstallCommand(packageManager) {
+function getInstallCommand2(packageManager) {
   switch (packageManager) {
     case "npm":
       return "npm install";
@@ -5324,6 +5729,218 @@ function showReplacementReport(report) {
   }
 }
 
+// src/lib/scaffold/claude-md-generator.ts
+init_cjs_shims();
+init_fs();
+
+// src/lib/utils/paths.ts
+init_cjs_shims();
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function getPackageRoot() {
+  const currentFilePath = (0, import_node_url.fileURLToPath)(importMetaUrl);
+  let currentDir = import_node_path3.default.dirname(currentFilePath);
+  while (currentDir !== import_node_path3.default.dirname(currentDir)) {
+    const packageJsonPath = import_node_path3.default.join(currentDir, "package.json");
+    if (import_node_fs.default.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    currentDir = import_node_path3.default.dirname(currentDir);
+  }
+  throw new Error("Could not find package root (no package.json found in parent directories)");
+}
+function getTemplatesPath() {
+  return import_node_path3.default.join(getPackageRoot(), "templates");
+}
+
+// src/lib/scaffold/claude-md-generator.ts
+async function generateClaudeMd(projectPath, projectInfo, options) {
+  const claudeMdPath = joinPath(projectPath, "CLAUDE.md");
+  const exists = await pathExists(claudeMdPath);
+  if (exists && !options?.overwrite) {
+    return {
+      created: false,
+      skipped: true,
+      path: claudeMdPath
+    };
+  }
+  try {
+    let template;
+    if (options?.customTemplate) {
+      template = options.customTemplate;
+    } else {
+      const templatePath = joinPath(getTemplatesPath(), "CLAUDE.md.template");
+      if (await pathExists(templatePath)) {
+        template = await readFile(templatePath);
+      } else {
+        template = getMinimalTemplate();
+      }
+    }
+    const content = processTemplate(template, projectInfo, options);
+    await writeFile(claudeMdPath, content);
+    return {
+      created: true,
+      skipped: false,
+      path: claudeMdPath
+    };
+  } catch (error) {
+    return {
+      created: false,
+      skipped: false,
+      path: claudeMdPath,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function generateClaudeMdWithSpinner(projectPath, projectInfo, options) {
+  return withSpinner(
+    "Generating CLAUDE.md...",
+    () => generateClaudeMd(projectPath, projectInfo, options),
+    {
+      successText: "Created CLAUDE.md"
+    }
+  );
+}
+function processTemplate(template, projectInfo, options) {
+  let content = template;
+  const techStack = options?.templateConfig?.techStack;
+  const commands = options?.templateConfig?.commands;
+  const targets = options?.templateConfig?.targets;
+  const preferences = options?.claudeConfig?.preferences;
+  content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectInfo.name).replace(/\{\{PROJECT_DESCRIPTION\}\}/g, projectInfo.description).replace(/\{\{ORG\}\}/g, projectInfo.org).replace(/\{\{REPO\}\}/g, projectInfo.repo).replace(/\{\{ENTITY_TYPE\}\}/g, projectInfo.entityType).replace(/\{\{ENTITY_TYPE_PLURAL\}\}/g, projectInfo.entityTypePlural).replace(/\{\{LOCATION\}\}/g, projectInfo.location || "");
+  const packageManager = preferences?.packageManager || "pnpm";
+  content = content.replace(/\{\{PACKAGE_MANAGER\}\}/g, packageManager);
+  const coverageTarget = targets && "coverage" in targets ? String(targets.coverage) : "90";
+  content = content.replace(/\{\{COVERAGE_TARGET\}\}/g, coverageTarget);
+  if (projectInfo.domain) {
+    content = content.replace(/\{\{#if DOMAIN\}\}/g, "").replace(/\{\{\/if\}\}/g, "").replace(/\{\{DOMAIN\}\}/g, projectInfo.domain);
+  } else {
+    content = content.replace(/\{\{#if DOMAIN\}\}[\s\S]*?\{\{\/if\}\}/g, "");
+  }
+  if (techStack && Object.keys(techStack).length > 0) {
+    const techStackContent = generateTechStackSection(techStack);
+    content = content.replace(/\{\{#if TECH_STACK\}\}/g, "").replace(/\{\{TECH_STACK\}\}\n\{\{else\}\}[\s\S]*?\{\{\/if\}\}/g, techStackContent);
+  } else {
+    content = content.replace(/\{\{#if TECH_STACK\}\}[\s\S]*?\{\{else\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  }
+  if (commands && Object.keys(commands).length > 0) {
+    const commandsContent = generateCommandsSection(commands, packageManager);
+    content = content.replace(/\{\{#if COMMANDS\}\}/g, "").replace(/\{\{COMMANDS\}\}\n\{\{else\}\}[\s\S]*?\{\{\/if\}\}/g, commandsContent);
+  } else {
+    content = content.replace(/\{\{#if COMMANDS\}\}[\s\S]*?\{\{else\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  }
+  content = content.replace(/\{\{#if PROJECT_STRUCTURE\}\}[\s\S]*?\{\{else\}\}/g, "").replace(/\{\{\/if\}\}/g, "");
+  return content;
+}
+function generateTechStackSection(techStack) {
+  const lines = [];
+  if (techStack.frontendFramework && techStack.frontendFramework !== "None") {
+    lines.push("**Frontend:**");
+    lines.push(`- Framework: ${techStack.frontendFramework}`);
+    if (techStack.stateManagement && techStack.stateManagement !== "None") {
+      lines.push(`- State: ${techStack.stateManagement}`);
+    }
+    lines.push("");
+  }
+  if (techStack.apiFramework && techStack.apiFramework !== "None") {
+    lines.push("**Backend:**");
+    lines.push(`- API: ${techStack.apiFramework}`);
+    if (techStack.validationLibrary && techStack.validationLibrary !== "None") {
+      lines.push(`- Validation: ${techStack.validationLibrary}`);
+    }
+    lines.push("");
+  }
+  if (techStack.databaseOrm && techStack.databaseOrm !== "None") {
+    lines.push("**Database:**");
+    lines.push(`- ORM: ${techStack.databaseOrm}`);
+    lines.push("");
+  }
+  if (techStack.authPattern && techStack.authPattern !== "None") {
+    lines.push("**Authentication:**");
+    lines.push(`- Provider: ${techStack.authPattern}`);
+    lines.push("");
+  }
+  if (techStack.testFramework && techStack.testFramework !== "None") {
+    lines.push("**Testing:**");
+    lines.push(`- Framework: ${techStack.testFramework}`);
+    lines.push("");
+  }
+  if (techStack.bundler && techStack.bundler !== "None") {
+    lines.push("**Build:**");
+    lines.push(`- Bundler: ${techStack.bundler}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateCommandsSection(commands, packageManager) {
+  const lines = ["```bash"];
+  lines.push("# Development");
+  lines.push(`${packageManager} dev              # Start development server`);
+  lines.push("");
+  lines.push("# Testing");
+  if (commands.test) {
+    lines.push(`${commands.test}           # Run tests`);
+  } else {
+    lines.push(`${packageManager} test             # Run tests`);
+  }
+  if (commands.coverage) {
+    lines.push(`${commands.coverage}  # Run tests with coverage`);
+  } else {
+    lines.push(`${packageManager} test:coverage    # Run tests with coverage`);
+  }
+  lines.push("");
+  lines.push("# Quality");
+  if (commands.lint) {
+    lines.push(`${commands.lint}           # Run linter`);
+  } else {
+    lines.push(`${packageManager} lint             # Run linter`);
+  }
+  if (commands.typecheck) {
+    lines.push(`${commands.typecheck}      # Type checking`);
+  } else {
+    lines.push(`${packageManager} typecheck        # Type checking`);
+  }
+  if (commands.build) {
+    lines.push("");
+    lines.push("# Build");
+    lines.push(`${commands.build}          # Build for production`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function getMinimalTemplate() {
+  return `# CLAUDE.md
+
+## Project Overview
+
+**{{PROJECT_NAME}}** - {{PROJECT_DESCRIPTION}}
+
+## Repository
+
+- **GitHub:** https://github.com/{{ORG}}/{{REPO}}
+
+## Quick Commands
+
+\`\`\`bash
+{{PACKAGE_MANAGER}} dev        # Start development
+{{PACKAGE_MANAGER}} test       # Run tests
+{{PACKAGE_MANAGER}} lint       # Run linter
+{{PACKAGE_MANAGER}} build      # Build project
+\`\`\`
+
+## Claude Configuration
+
+This project uses \`@qazuor/claude-code-config\` for AI-assisted development.
+
+See \`.claude/docs/quick-start.md\` for getting started.
+
+---
+
+*Generated by [@qazuor/claude-code-config](https://github.com/qazuor/claude-code-config)*
+`;
+}
+
 // src/lib/scaffold/index.ts
 init_cjs_shims();
 
@@ -5839,8 +6456,8 @@ async function generateScaffoldWithProgress(projectPath, options) {
 
 // src/lib/templates/config-replacer.ts
 init_cjs_shims();
-var fs3 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
+var fs4 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
 var import_ora2 = __toESM(require("ora"), 1);
 
 // src/constants/template-placeholders.ts
@@ -6254,16 +6871,19 @@ var TEMPLATE_PLACEHOLDERS = [
     choices: [
       { name: "React", value: "React" },
       { name: "Next.js", value: "Next.js" },
+      { name: "TanStack Start", value: "TanStack Start" },
       { name: "Vue", value: "Vue" },
       { name: "Nuxt", value: "Nuxt" },
       { name: "Svelte", value: "Svelte" },
       { name: "SvelteKit", value: "SvelteKit" },
       { name: "Astro", value: "Astro" },
       { name: "SolidJS", value: "SolidJS" },
+      { name: "Remix", value: "Remix" },
       { name: "Angular", value: "Angular" },
       { name: "None", value: "None" }
     ],
     default: (ctx) => {
+      if (hasDependency(ctx, "@tanstack/start")) return "TanStack Start";
       if (hasDependency(ctx, "next")) return "Next.js";
       if (hasDependency(ctx, "nuxt")) return "Nuxt";
       if (hasDependency(ctx, "vue")) return "Vue";
@@ -6271,6 +6891,7 @@ var TEMPLATE_PLACEHOLDERS = [
       if (hasDependency(ctx, "@sveltejs/kit")) return "SvelteKit";
       if (hasDependency(ctx, "astro")) return "Astro";
       if (hasDependency(ctx, "solid-js")) return "SolidJS";
+      if (hasDependency(ctx, "@remix-run/react")) return "Remix";
       if (hasDependency(ctx, "@angular/core")) return "Angular";
       if (hasDependency(ctx, "react")) return "React";
       return "None";
@@ -6342,26 +6963,32 @@ var TEMPLATE_PLACEHOLDERS = [
     description: "Authentication approach",
     inputType: "select",
     choices: [
+      { name: "Better Auth", value: "Better Auth" },
       { name: "Clerk", value: "Clerk" },
       { name: "Auth.js (NextAuth)", value: "Auth.js" },
       { name: "Lucia", value: "Lucia" },
       { name: "Firebase Auth", value: "Firebase" },
       { name: "Supabase Auth", value: "Supabase" },
+      { name: "Kinde", value: "Kinde" },
+      { name: "WorkOS", value: "WorkOS" },
       { name: "Custom JWT", value: "JWT" },
       { name: "Session-based", value: "Session" },
       { name: "None", value: "None" }
     ],
     default: (ctx) => {
+      if (hasDependency(ctx, "better-auth")) return "Better Auth";
       if (hasDependency(ctx, "@clerk/nextjs") || hasDependency(ctx, "@clerk/clerk-react"))
         return "Clerk";
       if (hasDependency(ctx, "next-auth") || hasDependency(ctx, "@auth/core")) return "Auth.js";
       if (hasDependency(ctx, "lucia")) return "Lucia";
       if (hasDependency(ctx, "firebase")) return "Firebase";
       if (hasDependency(ctx, "@supabase/supabase-js")) return "Supabase";
+      if (hasDependency(ctx, "@kinde-oss/kinde-auth-nextjs")) return "Kinde";
+      if (hasDependency(ctx, "@workos-inc/authkit-nextjs")) return "WorkOS";
       return "None";
     },
     required: false,
-    example: "Clerk"
+    example: "Better Auth"
   },
   {
     key: "STATE_MANAGEMENT",
@@ -6738,7 +7365,7 @@ function flattenTemplateConfig(config) {
   return flattened;
 }
 function shouldProcessFile(filePath) {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   return PROCESSABLE_EXTENSIONS.includes(ext);
 }
 function shouldSkipDirectory(dirName) {
@@ -6747,9 +7374,9 @@ function shouldSkipDirectory(dirName) {
 async function getAllFiles(dir) {
   const files = [];
   try {
-    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path4.join(dir, entry.name);
+      const fullPath = path5.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (!shouldSkipDirectory(entry.name)) {
           const subFiles = await getAllFiles(fullPath);
@@ -6766,7 +7393,7 @@ async function getAllFiles(dir) {
 async function replaceInFile2(filePath, replacements) {
   const changes = [];
   try {
-    let content = await fs3.readFile(filePath, "utf-8");
+    let content = await fs4.readFile(filePath, "utf-8");
     let modified = false;
     for (const [placeholder, value] of Object.entries(replacements)) {
       if (content.includes(placeholder)) {
@@ -6776,7 +7403,7 @@ async function replaceInFile2(filePath, replacements) {
       }
     }
     if (modified) {
-      await fs3.writeFile(filePath, content, "utf-8");
+      await fs4.writeFile(filePath, content, "utf-8");
     }
   } catch {
   }
@@ -6797,7 +7424,7 @@ async function replaceTemplatePlaceholders(dir, config) {
       report.filesModified++;
       for (const change of changes) {
         report.replacements.push({
-          file: path4.relative(dir, file),
+          file: path5.relative(dir, file),
           placeholder: change.placeholder,
           value: change.value
         });
@@ -6868,11 +7495,11 @@ async function previewReplacements(dir, config) {
   const preview = [];
   for (const file of files) {
     try {
-      const content = await fs3.readFile(file, "utf-8");
+      const content = await fs4.readFile(file, "utf-8");
       for (const [placeholder, value] of Object.entries(replacements)) {
         if (content.includes(placeholder)) {
           preview.push({
-            file: path4.relative(dir, file),
+            file: path5.relative(dir, file),
             placeholder,
             value
           });
@@ -6887,27 +7514,6 @@ async function previewReplacements(dir, config) {
 // src/cli/commands/init.ts
 init_fs();
 
-// src/lib/utils/paths.ts
-init_cjs_shims();
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_url = require("url");
-function getPackageRoot() {
-  const currentFilePath = (0, import_node_url.fileURLToPath)(importMetaUrl);
-  let currentDir = import_node_path3.default.dirname(currentFilePath);
-  while (currentDir !== import_node_path3.default.dirname(currentDir)) {
-    const packageJsonPath = import_node_path3.default.join(currentDir, "package.json");
-    if (import_node_fs.default.existsSync(packageJsonPath)) {
-      return currentDir;
-    }
-    currentDir = import_node_path3.default.dirname(currentDir);
-  }
-  throw new Error("Could not find package root (no package.json found in parent directories)");
-}
-function getTemplatesPath() {
-  return import_node_path3.default.join(getPackageRoot(), "templates");
-}
-
 // src/lib/utils/prompt-cancel.ts
 init_cjs_shims();
 var readline = __toESM(require("readline"), 1);
@@ -7379,6 +7985,124 @@ async function editBundleSelection(currentBundleIds) {
   return selected;
 }
 
+// src/cli/prompts/ci-cd-config.ts
+init_cjs_shims();
+async function promptCICDConfig(options) {
+  logger.section("CI/CD Configuration", "\u{1F680}");
+  logger.info("Configure continuous integration and deployment workflows");
+  logger.newline();
+  const enableCICD = await confirm({
+    message: "Would you like to set up GitHub Actions workflows?",
+    default: true
+  });
+  if (!enableCICD) {
+    return {
+      enabled: false,
+      provider: "github-actions",
+      ci: false,
+      cd: false,
+      packageManager: options?.packageManager || "pnpm",
+      nodeVersion: "22",
+      enableCaching: true,
+      runTests: true,
+      runLint: true,
+      runTypecheck: true,
+      runBuild: true
+    };
+  }
+  const workflows = await checkbox({
+    message: "Which workflows would you like to create?",
+    choices: [
+      {
+        name: "CI (Continuous Integration) - Lint, test, build on PRs",
+        value: "ci",
+        checked: true
+      },
+      {
+        name: "Release - Create releases on version tags",
+        value: "cd",
+        checked: false
+      }
+    ]
+  });
+  if (workflows.length === 0) {
+    return {
+      enabled: false,
+      provider: "github-actions",
+      ci: false,
+      cd: false,
+      packageManager: options?.packageManager || "pnpm",
+      nodeVersion: "22",
+      enableCaching: true,
+      runTests: true,
+      runLint: true,
+      runTypecheck: true,
+      runBuild: true
+    };
+  }
+  const hasCi = workflows.includes("ci");
+  const hasCd = workflows.includes("cd");
+  let runTests = true;
+  let runLint = true;
+  let runTypecheck = true;
+  let runBuild = true;
+  if (hasCi) {
+    const ciSteps = await checkbox({
+      message: "Which steps should the CI workflow run?",
+      choices: [
+        { name: "Lint", value: "lint", checked: true },
+        { name: "Type checking", value: "typecheck", checked: true },
+        { name: "Tests", value: "tests", checked: true },
+        { name: "Build", value: "build", checked: true }
+      ]
+    });
+    runTests = ciSteps.includes("tests");
+    runLint = ciSteps.includes("lint");
+    runTypecheck = ciSteps.includes("typecheck");
+    runBuild = ciSteps.includes("build");
+  }
+  const nodeVersion = await select({
+    message: "Node.js version:",
+    choices: [
+      { name: "22 (LTS - Recommended)", value: "22" },
+      { name: "20 (LTS)", value: "20" },
+      { name: "18 (LTS)", value: "18" },
+      { name: "Custom", value: "custom" }
+    ],
+    default: "22"
+  });
+  let finalNodeVersion = nodeVersion;
+  if (nodeVersion === "custom") {
+    finalNodeVersion = await input({
+      message: "Enter Node.js version:",
+      default: "22",
+      validate: (v) => {
+        if (!/^\d+(\.\d+)?$/.test(v)) {
+          return 'Please enter a valid version (e.g., "20" or "20.10")';
+        }
+        return true;
+      }
+    });
+  }
+  const enableCaching = await confirm({
+    message: "Enable dependency caching for faster builds?",
+    default: true
+  });
+  return {
+    enabled: true,
+    provider: "github-actions",
+    ci: hasCi,
+    cd: hasCd,
+    packageManager: options?.packageManager || "pnpm",
+    nodeVersion: finalNodeVersion,
+    enableCaching,
+    runTests,
+    runLint,
+    runTypecheck,
+    runBuild
+  };
+}
+
 // src/cli/prompts/folder-preferences.ts
 init_cjs_shims();
 
@@ -7993,18 +8717,38 @@ async function promptProjectInfo(options) {
       return true;
     }
   });
-  const entityType = await input({
-    message: "Primary entity type (e.g., product, article, user):",
-    default: options?.defaults?.entityType || "item",
-    validate: (value) => {
-      if (!value.trim()) return "Entity type is required";
-      return true;
-    }
+  const author = await input({
+    message: 'Author (name or "Name <email>"):',
+    default: options?.defaults?.author || ""
   });
-  const entityTypePlural = await input({
-    message: "Entity type plural:",
-    default: options?.defaults?.entityTypePlural || pluralize(entityType)
+  let entityType = "item";
+  let entityTypePlural = "items";
+  const wantEntityConfig = await confirm({
+    message: "Configure primary entity type? (Used for code examples and templates)",
+    default: false
   });
+  if (wantEntityConfig) {
+    logger.info("The entity type is used in code examples and templates throughout the project.");
+    logger.info(
+      'For example, if your project manages "products", code examples will use product-related names.'
+    );
+    logger.newline();
+    entityType = await input({
+      message: "Primary entity type (e.g., product, article, user, listing):",
+      default: options?.defaults?.entityType || "item",
+      validate: (value) => {
+        if (!value.trim()) return "Entity type is required";
+        return true;
+      }
+    });
+    entityTypePlural = await input({
+      message: "Entity type plural:",
+      default: options?.defaults?.entityTypePlural || pluralize(entityType)
+    });
+  } else if (options?.defaults?.entityType) {
+    entityType = options.defaults.entityType;
+    entityTypePlural = options.defaults.entityTypePlural || pluralize(entityType);
+  }
   let domain;
   let location;
   if (!options?.skipOptional) {
@@ -8043,7 +8787,8 @@ async function promptProjectInfo(options) {
     domain,
     entityType: entityType.trim().toLowerCase(),
     entityTypePlural: entityTypePlural.trim().toLowerCase(),
-    location
+    location,
+    author: author.trim() || void 0
   };
 }
 function pluralize(word) {
@@ -8062,6 +8807,7 @@ async function confirmProjectInfo(info) {
   logger.keyValue("Name", info.name);
   logger.keyValue("Description", info.description);
   logger.keyValue("GitHub", `${info.org}/${info.repo}`);
+  if (info.author) logger.keyValue("Author", info.author);
   logger.keyValue("Entity", `${info.entityType} / ${info.entityTypePlural}`);
   if (info.domain) logger.keyValue("Domain", info.domain);
   if (info.location) logger.keyValue("Location", info.location);
@@ -10010,6 +10756,17 @@ function placeholderKeyToConfigKey(key, category) {
 async function promptTemplateConfig(options) {
   const { context, mode = "quick", category, requiredOnly = false } = options;
   logger.section("Template Configuration", "\u{1F4DD}");
+  logger.newline();
+  logger.info("This step personalizes all Claude Code configuration files for YOUR project.");
+  logger.info("Your answers will be used to:");
+  logger.newline();
+  logger.item("Replace {{PLACEHOLDERS}} in agents, commands, and skills");
+  logger.item("Configure CLAUDE.md with your tech stack and commands");
+  logger.item("Set up quality targets (coverage, performance, accessibility)");
+  logger.item("Customize code examples to match your project structure");
+  logger.newline();
+  logger.info("Accurate configuration means better AI assistance tailored to your codebase!");
+  logger.newline();
   const hasDefaults = await hasGlobalDefaults();
   const globalDefaults = hasDefaults ? await getGlobalTemplateConfig() : void 0;
   if (mode === "quick") {
@@ -10282,7 +11039,7 @@ async function runInit(path7, options) {
       logger.warn("Configuration cancelled");
       return;
     }
-    const { config, skippedMcpConfigs, templateConfig } = buildResult;
+    const { config, skippedMcpConfigs, templateConfig, cicdConfig } = buildResult;
     if (templateConfig) {
       config.templateConfig = templateConfig;
     }
@@ -10299,7 +11056,7 @@ async function runInit(path7, options) {
       showConfigSummary(config);
       return;
     }
-    await executeInstallation(projectPath, config, registry, templatesPath, options);
+    await executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig);
     if (templateConfig && !options.noPlaceholders) {
       const claudePath = joinPath(projectPath, ".claude");
       await replaceTemplateConfigWithSpinner(claudePath, templateConfig);
@@ -10479,6 +11236,9 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
   }
   const permissionsConfig = await promptPermissionsConfig();
   const codeStyleConfig = await promptCodeStyleConfig();
+  const cicdConfig = await promptCICDConfig({
+    packageManager: preferences.packageManager
+  });
   const folderPreferences = await promptQuickFolderPreferences({
     selectedBundles: bundleSelection.selectedBundles,
     technologies: detection.detectedTechnologies || []
@@ -10536,7 +11296,8 @@ async function buildInteractiveConfig(projectPath, detection, registry, options)
   return {
     config,
     skippedMcpConfigs,
-    templateConfig: templateConfigResult
+    templateConfig: templateConfigResult,
+    cicdConfig
   };
 }
 async function selectModulesWithBundles(registry, suggestedBundles) {
@@ -10584,7 +11345,7 @@ async function selectModulesWithBundles(registry, suggestedBundles) {
   }
   return result;
 }
-async function executeInstallation(projectPath, config, registry, templatesPath, options) {
+async function executeInstallation(projectPath, config, registry, templatesPath, options, cicdConfig) {
   logger.newline();
   logger.title("Installing Configuration");
   if (config.scaffold.type === "full-project") {
@@ -10596,6 +11357,16 @@ async function executeInstallation(projectPath, config, registry, templatesPath,
       ...scaffoldResult.createdFiles
     ];
   }
+  const claudeMdResult = await generateClaudeMdWithSpinner(projectPath, config.project, {
+    overwrite: options.force,
+    templateConfig: config.templateConfig,
+    claudeConfig: config
+  });
+  if (claudeMdResult.error) {
+    logger.warn(`CLAUDE.md generation warning: ${claudeMdResult.error}`);
+  } else if (claudeMdResult.skipped) {
+    logger.info("CLAUDE.md already exists, skipped");
+  }
   const modulesByCategory = {
     agents: filterModules(registry, "agents", config.modules.agents.selected),
     skills: filterModules(registry, "skills", config.modules.skills.selected),
@@ -10656,6 +11427,33 @@ async function executeInstallation(projectPath, config, registry, templatesPath,
     if (codeStyleResult.errors.length > 0) {
       logger.warn(`Code style installation warnings: ${codeStyleResult.errors.join(", ")}`);
     }
+    const vscodeResult = await installVSCodeConfig(projectPath, config.extras.codeStyle, {
+      overwrite: options.force,
+      merge: !options.force
+      // Merge with existing settings if not forcing
+    });
+    if (vscodeResult.settings.error) {
+      logger.warn(`VSCode settings warning: ${vscodeResult.settings.error}`);
+    } else if (vscodeResult.settings.created || vscodeResult.settings.updated) {
+      logger.info("VSCode settings configured for code style tools");
+    }
+    const huskyConfig = deriveHuskyConfigFromCodeStyle(config.extras.codeStyle);
+    if (huskyConfig) {
+      const huskyResult = await installHuskyWithSpinner(projectPath, huskyConfig, {
+        overwrite: options.force
+      });
+      if (huskyResult.errors.length > 0) {
+        logger.warn(`Husky installation warnings: ${huskyResult.errors.join(", ")}`);
+      }
+    }
+  }
+  if (cicdConfig?.enabled) {
+    const cicdResult = await installCICDWithSpinner(projectPath, cicdConfig, {
+      overwrite: options.force
+    });
+    if (cicdResult.errors.length > 0) {
+      logger.warn(`CI/CD installation warnings: ${cicdResult.errors.join(", ")}`);
+    }
   }
   await writeConfig(projectPath, config);
   logger.newline();
@@ -10684,6 +11482,7 @@ async function handlePackageJsonUpdate(projectPath, config, options) {
     project: {
       name: config.project.name,
       description: config.project.description,
+      author: config.project.author,
       repository: config.project.org && config.project.repo ? `https://github.com/${config.project.org}/${config.project.repo}` : void 0
     }
   };
@@ -10753,7 +11552,7 @@ async function handlePackageJsonUpdate(projectPath, config, options) {
       logger.newline();
       logger.subtitle("Next Steps");
       logger.info("Run the following command to install dependencies:");
-      logger.raw(`  ${getInstallCommand(packageManager)}`);
+      logger.raw(`  ${getInstallCommand2(packageManager)}`);
       const setupInstructions = getSetupInstructions(toolSelection);
       if (setupInstructions.length > 0) {
         logger.newline();