fe-kit-cli 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,1738 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/constants/meta.ts
+var CLI_NAME = "fe-kit";
+var META_DIR = ".fe-kit";
+var CLI_VERSION = "0.1.0";
+
+// src/constants/frameworks.ts
+var FRAMEWORKS = ["vue", "react"];
+var ROUTERS = {
+  vue: "vue-router",
+  react: "react-router"
+};
+var STATE_MANAGERS = {
+  vue: ["pinia", "vuex"],
+  react: ["redux-toolkit", "zustand", "mobx"]
+};
+
+// src/constants/bundlers.ts
+var BUNDLERS = ["vite", "webpack", "rspack"];
+
+// src/constants/tools.ts
+var DEV_TOOLS = [
+  "cursor",
+  "claude-code",
+  "vscode",
+  "codebuddy-cn",
+  "trae",
+  "idea"
+];
+
+// src/constants/lint.ts
+var LINT_TOOLS = [
+  "eslint",
+  "stylelint",
+  "prettier",
+  "editorconfig"
+];
+
+// src/prompts/init-prompts.ts
+import path2 from "path";
+import prompts from "prompts";
+
+// src/skills/catalog.ts
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+var { pathExistsSync, readdirSync, readFileSync } = fs;
+function toLabel(id) {
+  return id.split(/[-_]/g).filter(Boolean).map((w) => w.slice(0, 1).toUpperCase() + w.slice(1)).join(" ");
+}
+function splitFrontmatter(raw) {
+  if (!raw.startsWith("---\n")) return { meta: {}, body: raw };
+  const end = raw.indexOf("\n---\n", 4);
+  if (end === -1) return { meta: {}, body: raw };
+  const fm = raw.slice(4, end).trim();
+  const body = raw.slice(end + "\n---\n".length).replace(/^\n+/, "");
+  const meta = {};
+  for (const line of fm.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf(":");
+    if (idx <= 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    let value = trimmed.slice(idx + 1).trim();
+    value = value.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+    meta[key] = value;
+  }
+  return { meta, body };
+}
+function skillsDir() {
+  return fileURLToPath(new URL("./skills/", import.meta.url));
+}
+function loadSkillsFromDir() {
+  const dir = skillsDir();
+  if (!pathExistsSync(dir)) return [];
+  const entries = readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort((a, b) => a.localeCompare(b));
+  const defs = [];
+  for (const dirName of entries) {
+    const p = path.join(dir, dirName, "SKILL.md");
+    if (!pathExistsSync(p)) continue;
+    const raw = readFileSync(p, "utf8");
+    const { meta, body } = splitFrontmatter(raw);
+    const id = meta.name?.trim() || dirName;
+    const description = meta.description?.trim() || "";
+    defs.push({
+      id,
+      label: toLabel(id),
+      description,
+      content: body.trimEnd(),
+      tags: [],
+      sourcePath: p
+    });
+  }
+  return defs;
+}
+function getSkillCatalog() {
+  return loadSkillsFromDir();
+}
+function getSkillById(id) {
+  const def = getSkillCatalog().find((s) => s.id === id);
+  if (!def) return void 0;
+  return { id: def.id, label: def.label, content: def.content, sourcePath: def.sourcePath };
+}
+
+// src/mcp/catalog.ts
+var BUILTIN_MCP = [
+  {
+    id: "context7",
+    label: "Context7",
+    description: "Fetch up-to-date library documentation via Context7.",
+    config: {
+      command: "npx",
+      args: ["-y", "@upstash/context7-mcp@latest"]
+    }
+  },
+  {
+    id: "sequential-thinking",
+    label: "Sequential Thinking",
+    description: "Step-by-step reasoning MCP server for complex problem solving.",
+    config: {
+      command: "npx",
+      args: ["-y", "@anthropic/sequential-thinking-mcp@latest"]
+    }
+  },
+  {
+    id: "filesystem",
+    label: "Filesystem",
+    description: "Read/write project files via MCP.",
+    config: {
+      command: "npx",
+      args: ["-y", "@anthropic/filesystem-mcp@latest"]
+    }
+  },
+  {
+    id: "exa-search",
+    label: "Exa Search",
+    description: "Neural web search for real-time information.",
+    config: {
+      command: "npx",
+      args: ["-y", "exa-mcp-server@latest"],
+      env: {
+        EXA_API_KEY: "<your-exa-api-key>"
+      }
+    }
+  }
+];
+function getMcpCatalog() {
+  return BUILTIN_MCP;
+}
+function getMcpById(id) {
+  const def = BUILTIN_MCP.find((m) => m.id === id);
+  if (!def) return void 0;
+  return { id: def.id, label: def.label, config: def.config };
+}
+
+// src/prompts/init-prompts.ts
+async function runInitPrompts() {
+  const response = await prompts(
+    [
+      {
+        type: "text",
+        name: "projectName",
+        message: "Project name:",
+        validate: (v) => v.trim() ? true : "Project name is required"
+      },
+      {
+        type: "text",
+        name: "projectPath",
+        message: "Project path:",
+        initial: (prev) => `./${prev}`,
+        format: (v) => path2.resolve(v)
+      },
+      {
+        type: "select",
+        name: "framework",
+        message: "Frontend framework:",
+        choices: FRAMEWORKS.map((f) => ({ title: f.charAt(0).toUpperCase() + f.slice(1), value: f }))
+      },
+      {
+        type: "select",
+        name: "router",
+        message: "Router:",
+        choices: (_prev, answers) => {
+          const fw = answers.framework;
+          return [{ title: ROUTERS[fw], value: ROUTERS[fw] }];
+        }
+      },
+      {
+        type: "select",
+        name: "stateManagement",
+        message: "State management:",
+        choices: (_prev, answers) => {
+          const fw = answers.framework;
+          return STATE_MANAGERS[fw].map((s) => ({ title: s, value: s }));
+        }
+      },
+      {
+        type: "select",
+        name: "bundler",
+        message: "Build tool:",
+        choices: BUNDLERS.map((b) => ({ title: b.charAt(0).toUpperCase() + b.slice(1), value: b }))
+      },
+      {
+        type: "multiselect",
+        name: "lintTools",
+        message: "Code quality tools (space to toggle):",
+        choices: LINT_TOOLS.map((t) => ({
+          title: t,
+          value: t,
+          selected: true
+        })),
+        hint: "ESLint + Prettier recommended"
+      },
+      {
+        type: "multiselect",
+        name: "devTools",
+        message: "Dev tools to configure:",
+        choices: DEV_TOOLS.map((t) => ({ title: t, value: t, selected: t === "cursor" })),
+        min: 1,
+        hint: "Select at least one"
+      },
+      {
+        type: "multiselect",
+        name: "skills",
+        message: "Built-in Skills to enable:",
+        choices: getSkillCatalog().map((s) => ({
+          title: `${s.label} \u2014 ${s.description}`,
+          value: s.id,
+          selected: false
+        }))
+      },
+      {
+        type: "multiselect",
+        name: "mcpServers",
+        message: "MCP servers to enable:",
+        choices: getMcpCatalog().map((m) => ({
+          title: `${m.label} \u2014 ${m.description}`,
+          value: m.id,
+          selected: false
+        }))
+      }
+    ],
+    { onCancel: () => process.exit(0) }
+  );
+  if (!response.projectName) return null;
+  return response;
+}
+
+// src/generators/project-generator.ts
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs2 from "fs-extra";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (msg) => console.log(pc.cyan("\u2139"), msg),
+  success: (msg) => console.log(pc.green("\u2714"), msg),
+  warn: (msg) => console.log(pc.yellow("\u26A0"), msg),
+  error: (msg) => console.error(pc.red("\u2716"), msg),
+  step: (msg) => console.log(pc.blue("\u2192"), msg)
+};
+
+// src/generators/project-generator.ts
+var __dirname = path3.dirname(fileURLToPath2(import.meta.url));
+function templateDir(framework, bundler) {
+  return path3.resolve(__dirname, "..", "templates", `${framework}-${bundler}-ts`);
+}
+async function generateProject(answers) {
+  const { projectPath, projectName, framework, bundler, router, stateManagement } = answers;
+  await fs2.ensureDir(projectPath);
+  const srcTemplate = templateDir(framework, bundler);
+  if (await fs2.pathExists(srcTemplate)) {
+    await fs2.copy(srcTemplate, projectPath, { overwrite: false });
+    logger.success(`Template ${framework}-${bundler}-ts copied`);
+  } else {
+    logger.warn(`No full template for ${framework}-${bundler}-ts. Generating minimal project.`);
+    await generateMinimalProject(answers);
+  }
+  await patchPackageJson(projectPath, projectName, framework, bundler, router, stateManagement);
+  logger.success("package.json configured");
+  await ensureNextStyleScaffold(projectPath, framework);
+}
+async function ensureNextStyleScaffold(projectPath, framework) {
+  const dirs = [
+    path3.join(projectPath, "public"),
+    path3.join(projectPath, "src", "app"),
+    path3.join(projectPath, "src", "components"),
+    path3.join(projectPath, "src", "hooks"),
+    path3.join(projectPath, "src", "lib"),
+    path3.join(projectPath, "src", "styles")
+  ];
+  await Promise.all(dirs.map((d) => fs2.ensureDir(d)));
+  const keepFiles = [
+    path3.join(projectPath, "src", "app", ".gitkeep"),
+    path3.join(projectPath, "src", "components", ".gitkeep"),
+    path3.join(projectPath, "src", "hooks", ".gitkeep"),
+    path3.join(projectPath, "src", "lib", ".gitkeep"),
+    path3.join(projectPath, "src", "styles", ".gitkeep"),
+    path3.join(projectPath, "public", ".gitkeep")
+  ];
+  await Promise.all(keepFiles.map((p) => fs2.ensureFile(p)));
+  if (framework === "vue") {
+    await fs2.ensureFile(path3.join(projectPath, "src", "hooks", "README.md"));
+    await fs2.writeFile(
+      path3.join(projectPath, "src", "hooks", "README.md"),
+      ["# hooks/", "", "Vue \u9879\u76EE\u91CC\u8FD9\u91CC\u66F4\u5E38\u653E `composables/`\uFF08\u53EF\u6309\u56E2\u961F\u4E60\u60EF\u91CD\u547D\u540D\uFF09\u3002", ""].join("\n"),
+      "utf-8"
+    );
+  }
+}
+async function generateMinimalProject(answers) {
+  const { projectPath, framework, bundler } = answers;
+  const srcDir = path3.join(projectPath, "src");
+  await fs2.ensureDir(srcDir);
+  const mainFile = framework === "react" ? "main.tsx" : "main.ts";
+  const mainContent = framework === "react" ? [
+    "import React from 'react';",
+    "import ReactDOM from 'react-dom/client';",
+    "import App from './App';",
+    "",
+    "ReactDOM.createRoot(document.getElementById('root')!).render(",
+    "  <React.StrictMode>",
+    "    <App />",
+    "  </React.StrictMode>,",
+    ");"
+  ].join("\n") : [
+    "import { createApp } from 'vue';",
+    "import App from './App.vue';",
+    "",
+    "createApp(App).mount('#app');"
+  ].join("\n");
+  await fs2.writeFile(path3.join(srcDir, mainFile), mainContent, "utf-8");
+  if (framework === "react") {
+    await fs2.writeFile(
+      path3.join(srcDir, "App.tsx"),
+      [
+        "import React from 'react';",
+        "",
+        "function App() {",
+        "  return <div>Hello fe-kit</div>;",
+        "}",
+        "",
+        "export default App;"
+      ].join("\n"),
+      "utf-8"
+    );
+  } else {
+    await fs2.writeFile(
+      path3.join(srcDir, "App.vue"),
+      [
+        '<script setup lang="ts">',
+        "const msg = 'Hello fe-kit';",
+        "</script>",
+        "",
+        "<template>",
+        "  <div>{{ msg }}</div>",
+        "</template>"
+      ].join("\n"),
+      "utf-8"
+    );
+  }
+  await fs2.writeFile(
+    path3.join(projectPath, "index.html"),
+    [
+      "<!DOCTYPE html>",
+      '<html lang="en">',
+      "<head>",
+      '  <meta charset="UTF-8" />',
+      '  <meta name="viewport" content="width=device-width, initial-scale=1.0" />',
+      "  <title>fe-kit project</title>",
+      "</head>",
+      "<body>",
+      `  <div id="${framework === "react" ? "root" : "app"}"></div>`,
+      `  <script type="module" src="/src/${mainFile}"></script>`,
+      "</body>",
+      "</html>"
+    ].join("\n"),
+    "utf-8"
+  );
+  const tsconfig = {
+    compilerOptions: {
+      target: "ES2020",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      jsx: framework === "react" ? "react-jsx" : "preserve",
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      baseUrl: ".",
+      paths: { "@/*": ["src/*"] }
+    },
+    include: ["src"]
+  };
+  await fs2.writeJson(path3.join(projectPath, "tsconfig.json"), tsconfig, { spaces: 2 });
+  await writeBundlerConfig(projectPath, framework, bundler);
+}
+async function writeBundlerConfig(projectPath, framework, bundler) {
+  if (bundler === "vite") {
+    const plugin = framework === "react" ? "import react from '@vitejs/plugin-react';" : "import vue from '@vitejs/plugin-vue';";
+    const pluginCall = framework === "react" ? "react()" : "vue()";
+    await fs2.writeFile(
+      path3.join(projectPath, "vite.config.ts"),
+      [
+        "import { defineConfig } from 'vite';",
+        plugin,
+        "",
+        "export default defineConfig({",
+        `  plugins: [${pluginCall}],`,
+        "  resolve: {",
+        "    alias: { '@': '/src' },",
+        "  },",
+        "});"
+      ].join("\n"),
+      "utf-8"
+    );
+  } else if (bundler === "webpack") {
+    await fs2.writeFile(
+      path3.join(projectPath, "webpack.config.ts"),
+      [
+        "// Webpack config placeholder \u2014 full template coming in P1",
+        "import path from 'path';",
+        "",
+        "export default {",
+        "  mode: 'development',",
+        "  entry: './src/main." + (framework === "react" ? "tsx" : "ts") + "',",
+        "  resolve: {",
+        "    extensions: ['.ts', '.tsx', '.js', '.jsx', '.vue'],",
+        "  },",
+        "};"
+      ].join("\n"),
+      "utf-8"
+    );
+  } else if (bundler === "rspack") {
+    await fs2.writeFile(
+      path3.join(projectPath, "rspack.config.ts"),
+      [
+        "// Rspack config placeholder \u2014 full template coming in P1",
+        "import { defineConfig } from '@rspack/cli';",
+        "",
+        "export default defineConfig({",
+        "  entry: { main: './src/main." + (framework === "react" ? "tsx" : "ts") + "' },",
+        "});"
+      ].join("\n"),
+      "utf-8"
+    );
+  }
+}
+async function patchPackageJson(projectPath, name, framework, bundler, router, stateManagement) {
+  const pkgPath = path3.join(projectPath, "package.json");
+  const existing = await fs2.pathExists(pkgPath) ? await fs2.readJson(pkgPath) : {};
+  const deps = { ...existing.dependencies };
+  const devDeps = { ...existing.devDependencies };
+  if (framework === "vue") {
+    deps.vue = "^3.5.0";
+    if (router === "vue-router") deps["vue-router"] = "^4.5.0";
+    if (stateManagement === "pinia") deps.pinia = "^2.3.0";
+    if (stateManagement === "vuex") deps.vuex = "^4.1.0";
+  } else {
+    deps.react = "^19.0.0";
+    deps["react-dom"] = "^19.0.0";
+    devDeps["@types/react"] = "^19.0.0";
+    devDeps["@types/react-dom"] = "^19.0.0";
+    if (router === "react-router") deps["react-router-dom"] = "^7.0.0";
+    if (stateManagement === "redux-toolkit") {
+      deps["@reduxjs/toolkit"] = "^2.6.0";
+      deps["react-redux"] = "^9.2.0";
+    }
+    if (stateManagement === "zustand") deps.zustand = "^5.0.0";
+    if (stateManagement === "mobx") {
+      deps.mobx = "^6.13.0";
+      deps["mobx-react-lite"] = "^4.1.0";
+    }
+  }
+  devDeps.typescript = "^5.8.0";
+  if (bundler === "vite") {
+    devDeps.vite = "^6.3.0";
+    if (framework === "react") devDeps["@vitejs/plugin-react"] = "^4.4.0";
+    if (framework === "vue") devDeps["@vitejs/plugin-vue"] = "^5.2.0";
+  } else if (bundler === "webpack") {
+    devDeps.webpack = "^5.99.0";
+    devDeps["webpack-cli"] = "^6.0.0";
+    devDeps["ts-loader"] = "^9.5.0";
+  } else if (bundler === "rspack") {
+    devDeps["@rspack/core"] = "^1.3.0";
+    devDeps["@rspack/cli"] = "^1.3.0";
+  }
+  const scripts = { ...existing.scripts };
+  if (bundler === "vite") {
+    scripts.dev = "vite";
+    scripts.build = "vite build";
+    scripts.preview = "vite preview";
+  } else if (bundler === "webpack") {
+    scripts.dev = "webpack serve --mode development";
+    scripts.build = "webpack --mode production";
+  } else if (bundler === "rspack") {
+    scripts.dev = "rspack serve";
+    scripts.build = "rspack build";
+  }
+  const pkg = {
+    ...existing,
+    name,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts,
+    dependencies: deps,
+    devDependencies: devDeps
+  };
+  await fs2.writeJson(pkgPath, pkg, { spaces: 2 });
+}
+
+// src/generators/lint-generator.ts
+import path4 from "path";
+import fs3 from "fs-extra";
+async function generateLintConfigs(answers) {
+  const { projectPath, lintTools, framework } = answers;
+  for (const tool of lintTools) {
+    await GENERATORS[tool]?.(projectPath, framework);
+  }
+}
+var GENERATORS = {
+  eslint: generateEslint,
+  stylelint: generateStylelint,
+  prettier: generatePrettier,
+  editorconfig: generateEditorConfig
+};
+async function generateEslint(root, fw) {
+  const pkgPath = path4.join(root, "package.json");
+  const pkg = await fs3.readJson(pkgPath);
+  const devDeps = pkg.devDependencies ?? {};
+  devDeps.eslint = "^9.25.0";
+  devDeps["@eslint/js"] = "^9.25.0";
+  devDeps["typescript-eslint"] = "^8.30.0";
+  devDeps.globals = "^16.0.0";
+  if (fw === "vue") {
+    devDeps["eslint-plugin-vue"] = "^10.0.0";
+  } else {
+    devDeps["eslint-plugin-react-hooks"] = "^5.2.0";
+    devDeps["eslint-plugin-react-refresh"] = "^0.4.0";
+  }
+  pkg.devDependencies = devDeps;
+  await fs3.writeJson(pkgPath, pkg, { spaces: 2 });
+  const configLines = fw === "vue" ? [
+    "import js from '@eslint/js';",
+    "import tseslint from 'typescript-eslint';",
+    "import pluginVue from 'eslint-plugin-vue';",
+    "",
+    "export default tseslint.config(",
+    "  js.configs.recommended,",
+    "  ...tseslint.configs.recommended,",
+    "  ...pluginVue.configs['flat/recommended'],",
+    "  {",
+    "    files: ['**/*.vue'],",
+    "    languageOptions: {",
+    "      parserOptions: { parser: tseslint.parser },",
+    "    },",
+    "  },",
+    ");"
+  ] : [
+    "import js from '@eslint/js';",
+    "import tseslint from 'typescript-eslint';",
+    "import reactHooks from 'eslint-plugin-react-hooks';",
+    "import reactRefresh from 'eslint-plugin-react-refresh';",
+    "import globals from 'globals';",
+    "",
+    "export default tseslint.config(",
+    "  js.configs.recommended,",
+    "  ...tseslint.configs.recommended,",
+    "  {",
+    "    files: ['**/*.{ts,tsx}'],",
+    "    plugins: {",
+    "      'react-hooks': reactHooks,",
+    "      'react-refresh': reactRefresh,",
+    "    },",
+    "    languageOptions: {",
+    "      globals: globals.browser,",
+    "    },",
+    "    rules: {",
+    "      ...reactHooks.configs.recommended.rules,",
+    "      'react-refresh/only-export-components': ['warn', { allowConstantExport: true }],",
+    "    },",
+    "  },",
+    ");"
+  ];
+  await fs3.writeFile(path4.join(root, "eslint.config.mjs"), configLines.join("\n"), "utf-8");
+  logger.success("ESLint 9 flat config generated");
+}
+async function generateStylelint(root) {
+  const pkgPath = path4.join(root, "package.json");
+  const pkg = await fs3.readJson(pkgPath);
+  pkg.devDependencies = {
+    ...pkg.devDependencies,
+    stylelint: "^16.17.0",
+    "stylelint-config-standard": "^37.0.0"
+  };
+  await fs3.writeJson(pkgPath, pkg, { spaces: 2 });
+  await fs3.writeJson(
+    path4.join(root, ".stylelintrc.json"),
+    { extends: ["stylelint-config-standard"] },
+    { spaces: 2 }
+  );
+  logger.success("Stylelint config generated");
+}
+async function generatePrettier(root) {
+  const pkgPath = path4.join(root, "package.json");
+  const pkg = await fs3.readJson(pkgPath);
+  pkg.devDependencies = { ...pkg.devDependencies, prettier: "^3.5.0" };
+  await fs3.writeJson(pkgPath, pkg, { spaces: 2 });
+  const config = {
+    semi: true,
+    singleQuote: true,
+    tabWidth: 2,
+    trailingComma: "all",
+    printWidth: 100
+  };
+  await fs3.writeJson(path4.join(root, ".prettierrc.json"), config, { spaces: 2 });
+  logger.success("Prettier config generated");
+}
+async function generateEditorConfig(root) {
+  const content = [
+    "root = true",
+    "",
+    "[*]",
+    "indent_style = space",
+    "indent_size = 2",
+    "end_of_line = lf",
+    "charset = utf-8",
+    "trim_trailing_whitespace = true",
+    "insert_final_newline = true"
+  ].join("\n");
+  await fs3.writeFile(path4.join(root, ".editorconfig"), content, "utf-8");
+  logger.success("EditorConfig generated");
+}
+
+// src/generators/fe-kit-meta-generator.ts
+import path7 from "path";
+import fs6 from "fs-extra";
+
+// src/utils/fs.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+async function readJsonSafe(filePath) {
+  try {
+    return await fs4.readJson(filePath);
+  } catch {
+    return void 0;
+  }
+}
+async function writeJsonSafe(filePath, data) {
+  await fs4.ensureDir(path5.dirname(filePath));
+  await fs4.writeJson(filePath, data, { spaces: 2 });
+}
+
+// src/core/merge-config.ts
+import deepmerge from "deepmerge";
+function mergeConfig(base, incoming) {
+  return deepmerge(base, incoming, {
+    arrayMerge: idempotentArrayMerge
+  });
+}
+function idempotentArrayMerge(target, source) {
+  if (isIdArray(target) || isIdArray(source)) {
+    return mergeById(target, source);
+  }
+  return [.../* @__PURE__ */ new Set([...target, ...source])];
+}
+function isIdArray(arr) {
+  return arr.length > 0 && typeof arr[0] === "object" && arr[0] !== null && "id" in arr[0];
+}
+function mergeById(target, source) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of target) map.set(item.id, item);
+  for (const item of source) {
+    const existing = map.get(item.id);
+    map.set(item.id, existing ? deepmerge(existing, item) : item);
+  }
+  return [...map.values()];
+}
+
+// src/core/write-rules.ts
+import path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import fs5 from "fs-extra";
+var __dirname2 = path6.dirname(fileURLToPath3(import.meta.url));
+function rulesSourceDir() {
+  return path6.resolve(__dirname2, "..", "rules");
+}
+async function writeRules(projectRoot, framework) {
+  const targetDir = path6.join(projectRoot, META_DIR, "rules");
+  const srcBase = rulesSourceDir();
+  const frameworkDir = mapFrameworkRulesDir(framework);
+  const dirs = [
+    ...frameworkDir ? [path6.join(srcBase, frameworkDir)] : [],
+    path6.join(srcBase, "common")
+  ];
+  for (const dir of dirs) {
+    if (!await fs5.pathExists(dir)) continue;
+    const relative = path6.basename(dir);
+    await fs5.copy(dir, path6.join(targetDir, relative), { overwrite: false });
+  }
+  logger.success(`Rules for ${framework} written to ${META_DIR}/rules/`);
+}
+function mapFrameworkRulesDir(fw) {
+  if (fw === "vue" || fw === "nuxt") return "vue";
+  if (fw === "react" || fw === "next") return "react";
+  return null;
+}
+
+// src/generators/fe-kit-meta-generator.ts
+function metaDir(root) {
+  return path7.join(root, META_DIR);
+}
+async function writeFeKitMeta(answers) {
+  const dir = metaDir(answers.projectPath);
+  await fs6.ensureDir(dir);
+  const project = {
+    name: answers.projectName,
+    framework: answers.framework,
+    router: answers.router,
+    stateManagement: answers.stateManagement,
+    bundler: answers.bundler,
+    typescript: true,
+    lintTools: answers.lintTools,
+    templateVersion: "0.1.0",
+    rulesVersion: "0.1.0",
+    cliVersion: CLI_VERSION
+  };
+  const skills = {
+    enabled: answers.skills.map((id) => ({
+      id,
+      source: "builtin",
+      targets: answers.devTools,
+      version: CLI_VERSION
+    }))
+  };
+  const mcp = {
+    enabled: answers.mcpServers.map((id) => ({
+      id,
+      adapterStatus: Object.fromEntries(answers.devTools.map((t) => [t, "written"])),
+      version: CLI_VERSION
+    })),
+    configVersion: CLI_VERSION
+  };
+  const tools = {
+    selectedTools: answers.devTools,
+    paths: {},
+    extensionRecommendations: []
+  };
+  await Promise.all([
+    writeJsonSafe(path7.join(dir, "project.json"), project),
+    writeJsonSafe(path7.join(dir, "skills.json"), skills),
+    writeJsonSafe(path7.join(dir, "mcp.json"), mcp),
+    writeJsonSafe(path7.join(dir, "tools.json"), tools)
+  ]);
+  await writeRules(answers.projectPath, answers.framework);
+  logger.success(`.fe-kit/ metadata written`);
+}
+async function updateFeKitMeta(projectRoot, detection, answers) {
+  const dir = metaDir(projectRoot);
+  await fs6.ensureDir(dir);
+  const fw = detection.framework;
+  const isClassicDetection = "router" in detection;
+  const projectPath = path7.join(dir, "project.json");
+  const existingProject = await readJsonSafe(projectPath) ?? {
+    name: detection.name,
+    framework: fw,
+    router: isClassicDetection ? detection.router ?? "" : "",
+    stateManagement: isClassicDetection ? detection.stateManagement ?? "" : "",
+    bundler: detection.bundler ?? "vite",
+    typescript: true,
+    lintTools: [],
+    templateVersion: "0.1.0",
+    rulesVersion: "0.1.0",
+    cliVersion: CLI_VERSION
+  };
+  await writeJsonSafe(projectPath, { ...existingProject, cliVersion: CLI_VERSION });
+  const skillsPath = path7.join(dir, "skills.json");
+  const existingSkills = await readJsonSafe(skillsPath) ?? { enabled: [] };
+  const newSkillEntries = answers.skills.map((id) => ({
+    id,
+    source: "builtin",
+    targets: answers.devTools,
+    version: CLI_VERSION
+  }));
+  await writeJsonSafe(
+    skillsPath,
+    mergeConfig(existingSkills, { enabled: newSkillEntries })
+  );
+  const mcpPath = path7.join(dir, "mcp.json");
+  const existingMcp = await readJsonSafe(mcpPath) ?? {
+    enabled: [],
+    configVersion: CLI_VERSION
+  };
+  const newMcpEntries = answers.mcpServers.map((id) => ({
+    id,
+    adapterStatus: Object.fromEntries(answers.devTools.map((t) => [t, "written"])),
+    version: CLI_VERSION
+  }));
+  await writeJsonSafe(
+    mcpPath,
+    mergeConfig(existingMcp, { enabled: newMcpEntries, configVersion: CLI_VERSION })
+  );
+  const toolsPath = path7.join(dir, "tools.json");
+  const existingTools = await readJsonSafe(toolsPath) ?? {
+    selectedTools: [],
+    paths: {},
+    extensionRecommendations: []
+  };
+  await writeJsonSafe(
+    toolsPath,
+    mergeConfig(existingTools, { selectedTools: answers.devTools })
+  );
+  await writeRules(projectRoot, fw);
+  logger.success(`.fe-kit/ metadata updated`);
+}
+
+// src/generators/readme-generator.ts
+import path8 from "path";
+import fs7 from "fs-extra";
+function scriptBlock(bundler) {
+  if (bundler === "vite") {
+    return [
+      "- `pnpm dev`\uFF1A\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668",
+      "- `pnpm build`\uFF1A\u6784\u5EFA\u751F\u4EA7\u4EA7\u7269",
+      "- `pnpm preview`\uFF1A\u672C\u5730\u9884\u89C8\u751F\u4EA7\u6784\u5EFA"
+    ].join("\n");
+  }
+  if (bundler === "webpack") {
+    return [
+      "- `pnpm dev`\uFF1A\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668",
+      "- `pnpm build`\uFF1A\u6784\u5EFA\u751F\u4EA7\u4EA7\u7269"
+    ].join("\n");
+  }
+  return [
+    "- `pnpm dev`\uFF1A\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668",
+    "- `pnpm build`\uFF1A\u6784\u5EFA\u751F\u4EA7\u4EA7\u7269"
+  ].join("\n");
+}
+function structureBlock(framework) {
+  const lines = [
+    "```text",
+    ".",
+    "\u251C\u2500 public/                     # \u9759\u6001\u8D44\u6E90\uFF08\u4E0D\u7ECF\u6784\u5EFA\u76F4\u63A5\u8F93\u51FA\uFF09",
+    "\u251C\u2500 src/",
+    "\u2502  \u251C\u2500 app/                     # \u201C\u5E94\u7528\u5C42\u201D\u7EC4\u7EC7",
+    "\u2502  \u251C\u2500 components/              # \u4E1A\u52A1/\u901A\u7528\u7EC4\u4EF6",
+    "\u2502  \u251C\u2500 hooks/                   # React Hooks / Vue Composables\uFF08\u6309\u9700\u653E\uFF09",
+    "\u2502  \u251C\u2500 lib/                     # \u5DE5\u5177\u51FD\u6570\u3001\u8BF7\u6C42\u5C01\u88C5\u3001\u7EAF\u903B\u8F91\uFF08\u4E0D\u76F4\u63A5\u4F9D\u8D56 UI\uFF09",
+    "\u2502  \u251C\u2500 styles/                  # \u6837\u5F0F\u4E0E\u8BBE\u8BA1 token\uFF08\u6309\u9700\u653E\uFF09",
+    "\u2502  \u2514\u2500 " + (framework === "react" ? "main.tsx" : "main.ts") + "               # \u5165\u53E3\u6587\u4EF6",
+    "\u251C\u2500 .fe-kit/                    # fe-kit \u751F\u6210\u7684\u5143\u6570\u636E\u4E0E\u89C4\u5219",
+    "\u251C\u2500 package.json",
+    "\u251C\u2500 tsconfig.json",
+    "\u2514\u2500 README.md",
+    "```"
+  ];
+  return lines.join("\n");
+}
+async function generateReadme(answers) {
+  const outPath = path8.join(answers.projectPath, "README.md");
+  const content = [
+    `# ${answers.projectName}`,
+    "",
+    "\u4E00\u4E2A\u7531 **fe-kit** \u521D\u59CB\u5316\u7684\u524D\u7AEF\u5DE5\u7A0B\u9AA8\u67B6\u3002",
+    "",
+    "## \u73AF\u5883\u8981\u6C42",
+    "",
+    "- Node.js >= 18",
+    "- pnpm\uFF08\u63A8\u8350\uFF09",
+    "",
+    "## \u5FEB\u901F\u5F00\u59CB",
+    "",
+    "\u5B89\u88C5\u4F9D\u8D56\uFF1A",
+    "",
+    "```bash",
+    "pnpm install",
+    "```",
+    "",
+    "\u5E38\u7528\u811A\u672C\uFF1A",
+    "",
+    scriptBlock(answers.bundler),
+    "",
+    "## \u76EE\u5F55\u7ED3\u6784",
+    "",
+    structureBlock(answers.framework),
+    "",
+    "## \u7EA6\u5B9A\u8BF4\u660E\uFF08\u91CD\u8981\uFF09",
+    "",
+    "- **\u4E0D\u5305\u542B service/back-end \u5185\u5BB9**\uFF1A\u672C\u9AA8\u67B6\u4E0D\u751F\u6210\u4EFB\u4F55\u670D\u52A1\u7AEF\u76EE\u5F55\u4E0E API \u8DEF\u7531\u3002",
+    "- **\u5E94\u7528\u5C42\u7EC4\u7EC7**\uFF1A`src/app/` \u4EC5\u4F5C\u4E3A\u4EE3\u7801\u7EC4\u7EC7\u7EA6\u5B9A\uFF0C\u4E0D\u5F3A\u7ED1\u5B9A\u5177\u4F53\u6846\u67B6\u8FD0\u884C\u65F6\u3002",
+    ""
+  ].join("\n");
+  await fs7.writeFile(outPath, content, "utf-8");
+  logger.success("README.md generated");
+}
+
+// src/adapters/cursor.ts
+import path10 from "path";
+import fs9 from "fs-extra";
+
+// src/core/paths.ts
+var TOOL_CONFIG_PATHS = {
+  cursor: ".cursor",
+  "claude-code": ".claude",
+  vscode: ".vscode",
+  "codebuddy-cn": ".codebuddy",
+  trae: ".trae",
+  idea: ".idea"
+};
+
+// src/core/rule-writers.ts
+import path9 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import fs8 from "fs-extra";
+var __dirname3 = path9.dirname(fileURLToPath4(import.meta.url));
+function rulesSourceDir2() {
+  return path9.resolve(__dirname3, "..", "rules");
+}
+function mapFrameworkDir(fw) {
+  if (fw === "vue" || fw === "nuxt") return "vue";
+  if (fw === "react" || fw === "next") return "react";
+  return null;
+}
+async function loadRuleSources(framework) {
+  const srcBase = rulesSourceDir2();
+  const fwDir = mapFrameworkDir(framework);
+  const dirs = [
+    { dir: path9.join(srcBase, "common"), category: "common" }
+  ];
+  if (fwDir) {
+    dirs.push({ dir: path9.join(srcBase, fwDir), category: fwDir });
+  }
+  const rules = [];
+  for (const { dir, category } of dirs) {
+    if (!await fs8.pathExists(dir)) continue;
+    const files = await fs8.readdir(dir);
+    for (const file of files) {
+      if (!file.endsWith(".md")) continue;
+      const content = await fs8.readFile(path9.join(dir, file), "utf-8");
+      rules.push({
+        name: path9.basename(file, ".md"),
+        category,
+        content: content.trim()
+      });
+    }
+  }
+  return rules;
+}
+function toMdcContent(rule, globs) {
+  const globLine = globs ? `globs: ${JSON.stringify(globs)}` : "";
+  const lines = [
+    "---",
+    `description: ${rule.category}/${rule.name} conventions`,
+    ...globLine ? [globLine] : [],
+    "alwaysApply: true",
+    "---",
+    "",
+    rule.content,
+    ""
+  ];
+  return lines.join("\n");
+}
+function ruleGlobs(rule) {
+  if (rule.category === "react") return ["**/*.{tsx,jsx,ts,js}"];
+  if (rule.category === "vue") return ["**/*.{vue,ts,js}"];
+  return void 0;
+}
+async function writeCursorRules(projectRoot, framework) {
+  const rules = await loadRuleSources(framework);
+  const dir = path9.join(projectRoot, ".cursor", "rules");
+  await fs8.ensureDir(dir);
+  for (const rule of rules) {
+    const filename = `${rule.category}-${rule.name}.mdc`;
+    await fs8.writeFile(path9.join(dir, filename), toMdcContent(rule, ruleGlobs(rule)), "utf-8");
+  }
+}
+async function writeCodeBuddyRules(projectRoot, framework) {
+  const rules = await loadRuleSources(framework);
+  const dir = path9.join(projectRoot, ".codebuddy", "rules");
+  await fs8.ensureDir(dir);
+  for (const rule of rules) {
+    const filename = `${rule.category}-${rule.name}.mdc`;
+    await fs8.writeFile(path9.join(dir, filename), toMdcContent(rule, ruleGlobs(rule)), "utf-8");
+  }
+}
+async function writeCopilotInstructions(projectRoot, framework) {
+  const rules = await loadRuleSources(framework);
+  const dir = path9.join(projectRoot, ".github");
+  await fs8.ensureDir(dir);
+  const sections = rules.map((r) => r.content);
+  const body = [
+    "# Project Coding Guidelines",
+    "",
+    ...sections.flatMap((s) => [s, ""])
+  ].join("\n");
+  await fs8.writeFile(path9.join(dir, "copilot-instructions.md"), body, "utf-8");
+}
+
+// src/adapters/cursor.ts
+var cursorAdapter = {
+  id: "cursor",
+  async applySkills(_ctx, skills) {
+    if (skills.length === 0) return;
+    logger.info("Cursor: skills are applied via rules \u2014 no separate skills directory needed.");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const configPath = path10.join(ctx.projectRoot, TOOL_CONFIG_PATHS.cursor, "mcp.json");
+    await fs9.ensureDir(path10.dirname(configPath));
+    const existing = await readJsonSafe(configPath) ?? {};
+    const mcpSection = existing.mcpServers ?? {};
+    for (const m of mcp) {
+      mcpSection[m.id] = m.config;
+    }
+    await writeJsonSafe(configPath, mergeConfig(existing, { mcpServers: mcpSection }));
+    logger.success("Cursor: MCP config written to .cursor/mcp.json");
+  },
+  async applyRules(ctx) {
+    await writeCursorRules(ctx.projectRoot, ctx.framework);
+    logger.success("Cursor: rules written to .cursor/rules/*.mdc");
+  }
+};
+
+// src/adapters/claude-code.ts
+import path11 from "path";
+import fs10 from "fs-extra";
+var claudeCodeAdapter = {
+  id: "claude-code",
+  async applySkills(ctx, skills) {
+    if (skills.length === 0) return;
+    const skillsRoot = path11.join(ctx.projectRoot, TOOL_CONFIG_PATHS["claude-code"], "skills");
+    await fs10.ensureDir(skillsRoot);
+    for (const skill of skills) {
+      const targetDir = path11.join(skillsRoot, skill.id);
+      await fs10.ensureDir(targetDir);
+      if (skill.sourcePath) {
+        const sourceDir = path11.dirname(skill.sourcePath);
+        await fs10.copy(sourceDir, targetDir, { overwrite: true });
+      } else {
+        await fs10.writeFile(path11.join(targetDir, "SKILL.md"), skill.content, "utf-8");
+      }
+    }
+    logger.success("Claude Code: skills copied to .claude/skills/<skill>/SKILL.md");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const configPath = path11.join(ctx.projectRoot, ".mcp.json");
+    const existing = await readJsonSafe(configPath) ?? {};
+    const mcpSection = existing.mcpServers ?? {};
+    for (const m of mcp) {
+      mcpSection[m.id] = m.config;
+    }
+    await writeJsonSafe(configPath, mergeConfig(existing, { mcpServers: mcpSection }));
+    logger.success("Claude Code: MCP config written to .mcp.json");
+  },
+  async applyRules(ctx) {
+    const rulesDir = path11.join(ctx.projectRoot, TOOL_CONFIG_PATHS["claude-code"], "rules");
+    await fs10.ensureDir(rulesDir);
+    const rules = await loadRuleSources(ctx.framework);
+    for (const rule of rules) {
+      const filename = `${rule.category}-${rule.name}.md`;
+      await fs10.writeFile(path11.join(rulesDir, filename), rule.content + "\n", "utf-8");
+    }
+    logger.success("Claude Code: rules written to .claude/rules/");
+  }
+};
+
+// src/adapters/vscode.ts
+import path12 from "path";
+import fs11 from "fs-extra";
+var vscodeAdapter = {
+  id: "vscode",
+  async applySkills(_ctx, skills) {
+    if (skills.length === 0) return;
+    logger.info("VS Code: skills are applied via Copilot instructions \u2014 no separate skills directory.");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const dir = path12.join(ctx.projectRoot, TOOL_CONFIG_PATHS.vscode);
+    await fs11.ensureDir(dir);
+    const configPath = path12.join(dir, "mcp.json");
+    const existing = await readJsonSafe(configPath) ?? {};
+    const serversSection = existing.servers ?? {};
+    for (const m of mcp) {
+      serversSection[m.id] = m.config;
+    }
+    await writeJsonSafe(configPath, mergeConfig(existing, { servers: serversSection }));
+    logger.success("VS Code: MCP config written to .vscode/mcp.json (servers)");
+  },
+  async applyRules(ctx) {
+    const dir = path12.join(ctx.projectRoot, TOOL_CONFIG_PATHS.vscode);
+    await fs11.ensureDir(dir);
+    const extensionsPath = path12.join(dir, "extensions.json");
+    const existing = await readJsonSafe(extensionsPath) ?? {};
+    const recs = new Set(existing.recommendations ?? []);
+    const recommended = [
+      "dbaeumer.vscode-eslint",
+      "esbenp.prettier-vscode",
+      "stylelint.vscode-stylelint"
+    ];
+    if (ctx.framework === "vue") recommended.push("Vue.volar");
+    for (const ext of recommended) recs.add(ext);
+    await writeJsonSafe(extensionsPath, { recommendations: [...recs] });
+    await writeCopilotInstructions(ctx.projectRoot, ctx.framework);
+    logger.success("VS Code: extensions.json + .github/copilot-instructions.md updated");
+  }
+};
+
+// src/adapters/codebuddy-cn.ts
+import path13 from "path";
+var codebuddyCnAdapter = {
+  id: "codebuddy-cn",
+  async applySkills(_ctx, skills) {
+    if (skills.length === 0) return;
+    logger.info("CodeBuddy: skills are applied via rules \u2014 no separate skills directory needed.");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const configPath = path13.join(ctx.projectRoot, ".mcp.json");
+    const existing = await readJsonSafe(configPath) ?? {};
+    const mcpSection = existing.mcpServers ?? {};
+    for (const m of mcp) {
+      mcpSection[m.id] = m.config;
+    }
+    await writeJsonSafe(configPath, mergeConfig(existing, { mcpServers: mcpSection }));
+    logger.success("CodeBuddy: MCP config written to .mcp.json");
+  },
+  async applyRules(ctx) {
+    await writeCodeBuddyRules(ctx.projectRoot, ctx.framework);
+    logger.success("CodeBuddy: rules written to .codebuddy/rules/*.mdc");
+  }
+};
+
+// src/adapters/trae.ts
+import path14 from "path";
+import fs12 from "fs-extra";
+var traeAdapter = {
+  id: "trae",
+  async applySkills(ctx, skills) {
+    if (skills.length === 0) return;
+    const dir = path14.join(ctx.projectRoot, TOOL_CONFIG_PATHS.trae, "rules");
+    await fs12.ensureDir(dir);
+    for (const skill of skills) {
+      const filePath = path14.join(dir, `${skill.id}.md`);
+      await fs12.writeFile(filePath, skill.content, "utf-8");
+    }
+    logger.success("Trae: skills written to .trae/rules/");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const configPath = path14.join(ctx.projectRoot, TOOL_CONFIG_PATHS.trae, "mcp.json");
+    await fs12.ensureDir(path14.dirname(configPath));
+    const existing = await readJsonSafe(configPath) ?? {};
+    const mcpSection = existing.mcpServers ?? {};
+    for (const m of mcp) {
+      mcpSection[m.id] = m.config;
+    }
+    await writeJsonSafe(configPath, mergeConfig(existing, { mcpServers: mcpSection }));
+    logger.success("Trae: MCP config written to .trae/mcp.json");
+  },
+  async applyRules(ctx) {
+    const rulesDir = path14.join(ctx.projectRoot, TOOL_CONFIG_PATHS.trae, "rules");
+    await fs12.ensureDir(rulesDir);
+    const rules = await loadRuleSources(ctx.framework);
+    for (const rule of rules) {
+      const filename = `${rule.category}-${rule.name}.md`;
+      await fs12.writeFile(path14.join(rulesDir, filename), rule.content + "\n", "utf-8");
+    }
+    logger.success("Trae: rules written to .trae/rules/");
+  }
+};
+
+// src/adapters/idea.ts
+import path15 from "path";
+import fs13 from "fs-extra";
+var ideaAdapter = {
+  id: "idea",
+  async applySkills(ctx, skills) {
+    if (skills.length === 0) return;
+    const dir = path15.join(ctx.projectRoot, TOOL_CONFIG_PATHS.idea);
+    await fs13.ensureDir(dir);
+    logger.info("IDEA: skill integration is a placeholder \u2014 manual config may be needed.");
+  },
+  async applyMcp(ctx, mcp) {
+    if (mcp.length === 0) return;
+    const dir = path15.join(ctx.projectRoot, TOOL_CONFIG_PATHS.idea);
+    await fs13.ensureDir(dir);
+    logger.info("IDEA: MCP integration is a placeholder \u2014 manual config may be needed.");
+  },
+  async applyRules(ctx) {
+    const dir = path15.join(ctx.projectRoot, TOOL_CONFIG_PATHS.idea);
+    await fs13.ensureDir(dir);
+    logger.info("IDEA: rules integration is a placeholder.");
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = {
+  cursor: cursorAdapter,
+  "claude-code": claudeCodeAdapter,
+  vscode: vscodeAdapter,
+  "codebuddy-cn": codebuddyCnAdapter,
+  trae: traeAdapter,
+  idea: ideaAdapter
+};
+function getAdapters(ids) {
+  return ids.map((id) => adapters[id]);
+}
+
+// src/core/apply-adapters.ts
+async function applyAdapters(projectRoot, input) {
+  const adapters2 = getAdapters(input.devTools);
+  const ctx = { projectRoot, framework: input.framework };
+  const skills = input.skills.map(getSkillById).filter((s) => s !== void 0);
+  const mcp = input.mcpServers.map(getMcpById).filter((m) => m !== void 0);
+  for (const adapter of adapters2) {
+    logger.step(`Applying config for ${adapter.id}...`);
+    await adapter.applySkills(ctx, skills);
+    await adapter.applyMcp(ctx, mcp);
+    await adapter.applyRules(ctx);
+  }
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  logger.step("Starting new project initialization...");
+  const answers = await runInitPrompts();
+  if (!answers) return;
+  await generateProject(answers);
+  await generateLintConfigs(answers);
+  await writeFeKitMeta(answers);
+  await generateReadme(answers);
+  await applyAdapters(answers.projectPath, answers);
+  logger.success(`Project "${answers.projectName}" created at ${answers.projectPath}`);
+}
+
+// src/commands/enhance.ts
+import path19 from "path";
+import fs17 from "fs-extra";
+
+// src/core/detect-project.ts
+import path16 from "path";
+import fs14 from "fs-extra";
+async function detectProject(root) {
+  const pkgPath = path16.join(root, "package.json");
+  if (!await fs14.pathExists(pkgPath)) return null;
+  const pkg = await readJsonSafe(pkgPath);
+  if (!pkg) return null;
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const framework = detectFramework(allDeps);
+  if (!framework) return null;
+  return {
+    name: pkg.name ?? path16.basename(root),
+    framework,
+    router: detectRouter(allDeps, framework),
+    stateManagement: detectStateManagement(allDeps, framework),
+    bundler: detectBundler(allDeps),
+    hasTypeScript: "typescript" in allDeps || await fs14.pathExists(path16.join(root, "tsconfig.json"))
+  };
+}
+function detectFramework(deps) {
+  if ("vue" in deps) return "vue";
+  if ("react" in deps) return "react";
+  return null;
+}
+function detectRouter(deps, fw) {
+  if (fw === "vue" && "vue-router" in deps) return "vue-router";
+  if (fw === "react" && "react-router" in deps) return "react-router";
+  if (fw === "react" && "react-router-dom" in deps) return "react-router";
+  return void 0;
+}
+function detectStateManagement(deps, fw) {
+  if (fw === "vue") {
+    if ("pinia" in deps) return "pinia";
+    if ("vuex" in deps) return "vuex";
+  }
+  if (fw === "react") {
+    if ("@reduxjs/toolkit" in deps) return "redux-toolkit";
+    if ("zustand" in deps) return "zustand";
+    if ("mobx" in deps) return "mobx";
+  }
+  return void 0;
+}
+function detectBundler(deps) {
+  if ("vite" in deps) return "vite";
+  if ("webpack" in deps) return "webpack";
+  if ("@rspack/cli" in deps || "@rspack/core" in deps) return "rspack";
+  return void 0;
+}
+
+// src/core/detect-stack.ts
+import path17 from "path";
+import fs15 from "fs-extra";
+async function detectStack(root) {
+  const pkgPath = path17.join(root, "package.json");
+  if (!await fs15.pathExists(pkgPath)) return null;
+  const pkg = await readJsonSafe(pkgPath);
+  if (!pkg) return null;
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const framework = inferFramework(allDeps);
+  const bundler = inferBundler(allDeps);
+  const hasTypeScript = "typescript" in allDeps || await fs15.pathExists(path17.join(root, "tsconfig.json"));
+  const hasGit = await fs15.pathExists(path17.join(root, ".git"));
+  return {
+    name: pkg.name ?? path17.basename(root),
+    projectKind: inferProjectKind(pkg, allDeps, framework),
+    framework,
+    bundler,
+    hasTypeScript,
+    hasGit
+  };
+}
+function inferFramework(deps) {
+  if ("nuxt" in deps) return "nuxt";
+  if ("next" in deps) return "next";
+  if ("vue" in deps) return "vue";
+  if ("react" in deps) return "react";
+  return "unknown";
+}
+function inferBundler(deps) {
+  if ("vite" in deps) return "vite";
+  if ("webpack" in deps) return "webpack";
+  if ("@rspack/cli" in deps || "@rspack/core" in deps) return "rspack";
+  return void 0;
+}
+function inferProjectKind(pkg, deps, framework) {
+  if (framework !== "unknown") return "frontend";
+  const hasNodeSignals = pkg.bin !== void 0 || pkg.main !== void 0 || pkg.exports !== void 0 || "express" in deps || "fastify" in deps || "koa" in deps || "@types/node" in deps;
+  if (hasNodeSignals) return "node";
+  return "unknown";
+}
+function summarizeStack(stack) {
+  const parts = [];
+  if (stack.framework !== "unknown") {
+    parts.push(stack.framework.charAt(0).toUpperCase() + stack.framework.slice(1));
+  } else if (stack.projectKind === "node") {
+    parts.push("Node");
+  } else {
+    parts.push("JavaScript/TypeScript");
+  }
+  if (stack.bundler) {
+    parts.push(stack.bundler.charAt(0).toUpperCase() + stack.bundler.slice(1));
+  }
+  if (stack.hasTypeScript) parts.push("TypeScript");
+  return parts.join(" + ");
+}
+
+// src/prompts/enhance-prompts.ts
+import prompts2 from "prompts";
+function getApplicableTools(stack) {
+  const tools = [];
+  tools.push({
+    id: "eslint",
+    label: "ESLint",
+    description: "Linting for JavaScript / TypeScript",
+    selected: true
+  });
+  tools.push({
+    id: "prettier",
+    label: "Prettier",
+    description: "Code formatting",
+    selected: true
+  });
+  tools.push({
+    id: "editorconfig",
+    label: "EditorConfig",
+    description: "Cross-editor indentation & whitespace settings",
+    selected: true
+  });
+  if (stack.projectKind === "frontend") {
+    tools.push({
+      id: "stylelint",
+      label: "Stylelint",
+      description: "CSS / SCSS linting",
+      selected: false
+    });
+  }
+  tools.push({
+    id: "commitlint",
+    label: "commitlint",
+    description: "Enforce conventional commit messages",
+    selected: false
+  });
+  return tools;
+}
+async function runEnhancePrompts(stack) {
+  const stackLabel = summarizeStack(stack);
+  const applicableTools = getApplicableTools(stack);
+  const response = await prompts2(
+    [
+      {
+        type: "multiselect",
+        name: "devTools",
+        message: `Dev tools to configure for this ${stackLabel} project:`,
+        choices: DEV_TOOLS.map((t) => ({ title: t, value: t, selected: t === "cursor" })),
+        min: 1,
+        hint: "Select at least one"
+      },
+      {
+        type: "multiselect",
+        name: "qualityTools",
+        message: "Code quality tools to install & configure:",
+        choices: applicableTools.map((t) => ({
+          title: `${t.label} \u2014 ${t.description}`,
+          value: t.id,
+          selected: t.selected
+        })),
+        hint: "Space to toggle, Enter to confirm"
+      },
+      {
+        type: "multiselect",
+        name: "skills",
+        message: "Skills to add:",
+        choices: getSkillCatalog().map((s) => ({
+          title: `${s.label} \u2014 ${s.description}`,
+          value: s.id,
+          selected: false
+        }))
+      },
+      {
+        type: "multiselect",
+        name: "mcpServers",
+        message: "MCP servers to add:",
+        choices: getMcpCatalog().map((m) => ({
+          title: `${m.label} \u2014 ${m.description}`,
+          value: m.id,
+          selected: false
+        }))
+      }
+    ],
+    { onCancel: () => process.exit(0) }
+  );
+  if (!response.devTools) return null;
+  return {
+    devTools: response.devTools,
+    qualityTools: response.qualityTools ?? [],
+    skills: response.skills ?? [],
+    mcpServers: response.mcpServers ?? []
+  };
+}
+
+// src/generators/quality-generator.ts
+import path18 from "path";
+import fs16 from "fs-extra";
+var GENERATORS2 = {
+  eslint: generateEslint2,
+  stylelint: generateStylelint2,
+  prettier: generatePrettier2,
+  editorconfig: generateEditorConfig2,
+  commitlint: generateCommitlint
+};
+async function generateQualityTooling(root, stack, tools) {
+  for (const tool of tools) {
+    await GENERATORS2[tool](root, stack);
+  }
+}
+async function generateEslint2(root, stack) {
+  const pkg = await readPkg(root);
+  const devDeps = {
+    ...pkg.devDependencies
+  };
+  devDeps.eslint = "^9.25.0";
+  devDeps["@eslint/js"] = "^9.25.0";
+  devDeps.globals = "^16.0.0";
+  if (stack.hasTypeScript) {
+    devDeps["typescript-eslint"] = "^8.30.0";
+  }
+  addFrameworkEslintDeps(devDeps, stack.framework);
+  addBundlerEslintPlugin(devDeps, stack);
+  pkg.devDependencies = devDeps;
+  await writePkg(root, pkg);
+  const configContent = buildEslintConfig(stack);
+  await fs16.writeFile(path18.join(root, "eslint.config.mjs"), configContent, "utf-8");
+  logger.success("ESLint 9 flat config generated");
+}
+function addFrameworkEslintDeps(devDeps, fw) {
+  if (fw === "vue" || fw === "nuxt") {
+    devDeps["eslint-plugin-vue"] = "^10.0.0";
+  } else if (fw === "react" || fw === "next") {
+    devDeps["eslint-plugin-react-hooks"] = "^5.2.0";
+    devDeps["eslint-plugin-react-refresh"] = "^0.4.0";
+  }
+}
+function addBundlerEslintPlugin(devDeps, stack) {
+  if (stack.projectKind !== "frontend") return;
+  if (stack.bundler === "vite") {
+    devDeps["vite-plugin-eslint2"] = "^5.0.0";
+  } else if (stack.bundler === "webpack" || stack.bundler === "rspack") {
+    devDeps["eslint-webpack-plugin"] = "^4.2.0";
+  }
+}
+function buildEslintConfig(stack) {
+  const fw = stack.framework;
+  if (fw === "vue" || fw === "nuxt") return buildVueEslintConfig(stack);
+  if (fw === "react" || fw === "next") return buildReactEslintConfig(stack);
+  return buildGenericEslintConfig(stack);
+}
+function buildVueEslintConfig(stack) {
+  const lines = [
+    "import js from '@eslint/js';",
+    ...stack.hasTypeScript ? ["import tseslint from 'typescript-eslint';"] : [],
+    "import pluginVue from 'eslint-plugin-vue';",
+    "",
+    ...stack.hasTypeScript ? [
+      "export default tseslint.config(",
+      "  js.configs.recommended,",
+      "  ...tseslint.configs.recommended,"
+    ] : ["export default [", "  js.configs.recommended,"],
+    "  ...pluginVue.configs['flat/recommended'],",
+    ...stack.hasTypeScript ? [
+      "  {",
+      "    files: ['**/*.vue'],",
+      "    languageOptions: {",
+      "      parserOptions: { parser: tseslint.parser },",
+      "    },",
+      "  },",
+      ");"
+    ] : ["];"]
+  ];
+  return lines.join("\n");
+}
+function buildReactEslintConfig(stack) {
+  const lines = [
+    "import js from '@eslint/js';",
+    ...stack.hasTypeScript ? ["import tseslint from 'typescript-eslint';"] : [],
+    "import reactHooks from 'eslint-plugin-react-hooks';",
+    "import reactRefresh from 'eslint-plugin-react-refresh';",
+    "import globals from 'globals';",
+    "",
+    ...stack.hasTypeScript ? [
+      "export default tseslint.config(",
+      "  js.configs.recommended,",
+      "  ...tseslint.configs.recommended,"
+    ] : ["export default [", "  js.configs.recommended,"],
+    "  {",
+    "    files: ['**/*.{ts,tsx,js,jsx}'],",
+    "    plugins: {",
+    "      'react-hooks': reactHooks,",
+    "      'react-refresh': reactRefresh,",
+    "    },",
+    "    languageOptions: {",
+    "      globals: globals.browser,",
+    "    },",
+    "    rules: {",
+    "      ...reactHooks.configs.recommended.rules,",
+    "      'react-refresh/only-export-components': ['warn', { allowConstantExport: true }],",
+    "    },",
+    "  },",
+    ...stack.hasTypeScript ? [");"] : ["];"]
+  ];
+  return lines.join("\n");
+}
+function buildGenericEslintConfig(stack) {
+  const lines = [
+    "import js from '@eslint/js';",
+    ...stack.hasTypeScript ? ["import tseslint from 'typescript-eslint';"] : [],
+    "import globals from 'globals';",
+    "",
+    ...stack.hasTypeScript ? [
+      "export default tseslint.config(",
+      "  js.configs.recommended,",
+      "  ...tseslint.configs.recommended,"
+    ] : ["export default [", "  js.configs.recommended,"],
+    "  {",
+    "    files: ['**/*.{ts,js}'],",
+    "    languageOptions: {",
+    "      globals: {",
+    "        ...globals.node,",
+    "      },",
+    "    },",
+    "  },",
+    ...stack.hasTypeScript ? [");"] : ["];"]
+  ];
+  return lines.join("\n");
+}
+async function generateStylelint2(root, stack) {
+  const pkg = await readPkg(root);
+  const devDeps = {
+    ...pkg.devDependencies,
+    stylelint: "^16.17.0",
+    "stylelint-config-standard": "^37.0.0"
+  };
+  const fw = stack.framework;
+  if (fw === "vue" || fw === "nuxt") {
+    devDeps["stylelint-config-standard-vue"] = "^1.0.0";
+  }
+  pkg.devDependencies = devDeps;
+  await writePkg(root, pkg);
+  const extendsArr = ["stylelint-config-standard"];
+  if (fw === "vue" || fw === "nuxt") {
+    extendsArr.push("stylelint-config-standard-vue");
+  }
+  await fs16.writeJson(
+    path18.join(root, ".stylelintrc.json"),
+    { extends: extendsArr },
+    { spaces: 2 }
+  );
+  logger.success("Stylelint config generated");
+}
+async function generatePrettier2(root) {
+  const pkg = await readPkg(root);
+  pkg.devDependencies = {
+    ...pkg.devDependencies,
+    prettier: "^3.5.0"
+  };
+  await writePkg(root, pkg);
+  const config = {
+    semi: true,
+    singleQuote: true,
+    tabWidth: 2,
+    trailingComma: "all",
+    printWidth: 100
+  };
+  await fs16.writeJson(path18.join(root, ".prettierrc.json"), config, { spaces: 2 });
+  logger.success("Prettier config generated");
+}
+async function generateEditorConfig2(root) {
+  const content = [
+    "root = true",
+    "",
+    "[*]",
+    "indent_style = space",
+    "indent_size = 2",
+    "end_of_line = lf",
+    "charset = utf-8",
+    "trim_trailing_whitespace = true",
+    "insert_final_newline = true"
+  ].join("\n");
+  await fs16.writeFile(path18.join(root, ".editorconfig"), content, "utf-8");
+  logger.success("EditorConfig generated");
+}
+async function generateCommitlint(root, stack) {
+  const pkg = await readPkg(root);
+  const devDeps = {
+    ...pkg.devDependencies,
+    "@commitlint/cli": "^19.8.0",
+    "@commitlint/config-conventional": "^19.8.0"
+  };
+  devDeps.husky = "^9.1.0";
+  pkg.devDependencies = devDeps;
+  const scripts = pkg.scripts ?? {};
+  scripts.prepare ??= "husky";
+  pkg.scripts = scripts;
+  await writePkg(root, pkg);
+  const isESM = pkg.type === "module";
+  const configName = isESM ? "commitlint.config.cjs" : "commitlint.config.js";
+  const configContent = [
+    "module.exports = { extends: ['@commitlint/config-conventional'] };",
+    ""
+  ].join("\n");
+  await fs16.writeFile(path18.join(root, configName), configContent, "utf-8");
+  await fs16.ensureDir(path18.join(root, ".husky"));
+  const hookContent = 'npx --no -- commitlint --edit "$1"\n';
+  await fs16.writeFile(path18.join(root, ".husky", "commit-msg"), hookContent, "utf-8");
+  if (!stack.hasGit) {
+    logger.warn("No .git directory detected \u2014 commitlint hooks will activate after git init.");
+  }
+  logger.success("commitlint + husky generated");
+}
+async function readPkg(root) {
+  return fs16.readJson(path18.join(root, "package.json"));
+}
+async function writePkg(root, data) {
+  await fs16.writeJson(path18.join(root, "package.json"), data, { spaces: 2 });
+}
+
+// src/commands/enhance.ts
+async function enhanceCommand() {
+  logger.step("Analyzing current project...");
+  const projectRoot = process.cwd();
+  const classicDetection = await detectProject(projectRoot);
+  const stack = classicDetection ? await toStackDetection(projectRoot, classicDetection) : await detectStack(projectRoot);
+  if (!stack) {
+    logger.error(
+      "Could not detect a project in the current directory. Make sure package.json exists."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  logger.info(`Detected: ${summarizeStack(stack)}`);
+  const answers = await runEnhancePrompts(stack);
+  if (!answers) return;
+  await updateFeKitMeta(projectRoot, classicDetection ?? stack, answers);
+  if (answers.qualityTools.length > 0) {
+    await generateQualityTooling(projectRoot, stack, answers.qualityTools);
+  }
+  await applyAdapters(projectRoot, {
+    framework: stack.framework,
+    ...answers
+  });
+  logger.success("Project enhanced successfully.");
+}
+async function toStackDetection(root, d) {
+  return {
+    name: d.name,
+    projectKind: "frontend",
+    framework: d.framework,
+    bundler: d.bundler,
+    hasTypeScript: d.hasTypeScript,
+    hasGit: await fs17.pathExists(path19.join(root, ".git"))
+  };
+}
+
+// src/cli.ts
+var program = new Command();
+program.name(CLI_NAME).description("Frontend project scaffold CLI \u2014 init, enhance, and manage your dev environment.").version(CLI_VERSION);
+program.command("init").description("Initialize a new frontend project with Vue or React + TypeScript").action(async () => {
+  try {
+    await initCommand();
+  } catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+  }
+});
+program.command("enhance").description("Enhance an existing frontend project with dev tools, skills, MCP, and rules").action(async () => {
+  try {
+    await enhanceCommand();
+  } catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.mjs.map