@luxkit/cli 1.0.8 → 1.1.1

package/dist/index.js

@@ -4,7 +4,8 @@
 import { program } from "commander";
 
 // src/commands/fmt.ts
-import path4 from "path";
+import fs3 from "fs";
+import path5 from "path";
 
 // src/presets/fmt/electron-vue.ts
 var electronVueFmt = {
@@ -114,8 +115,8 @@ trim_trailing_whitespace = false
     ]
   },
   scripts: {
-    lint: "eslint .",
-    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix',
+    lint: "eslint . --cache --cache-location node_modules/.cache/.eslintcache",
+    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix --cache --cache-location node_modules/.cache/.eslintcache',
     format: 'prettier --write "src/**/*.{ts,js,json,vue,css,scss}"',
     "format:check": 'prettier --check "src/**/*.{ts,js,json,vue,css,scss}"',
     stylelint: 'stylelint "src/**/*.{css,scss,vue}"',
@@ -297,8 +298,8 @@ trim_trailing_whitespace = false
     ]
   },
   scripts: {
-    lint: "eslint .",
-    "lint:fix": 'eslint "src/**/*.{js,ts}" --fix',
+    lint: "eslint . --cache --cache-location node_modules/.cache/.eslintcache",
+    "lint:fix": 'eslint "src/**/*.{js,ts}" --fix --cache --cache-location node_modules/.cache/.eslintcache',
     format: 'prettier --write "src/**/*.{ts,js,json}"',
     "format:check": 'prettier --check "src/**/*.{ts,js,json}"',
     cspell: 'cspell --gitignore "src/**/*"',
@@ -416,8 +417,8 @@ trim_trailing_whitespace = false
     ]
   },
   scripts: {
-    lint: "eslint .",
-    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix',
+    lint: "eslint . --cache --cache-location node_modules/.cache/.eslintcache",
+    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix --cache --cache-location node_modules/.cache/.eslintcache',
     format: 'prettier --write "src/**/*.{ts,js,json,vue,css,scss}"',
     "format:check": 'prettier --check "src/**/*.{ts,js,json,vue,css,scss}"',
     stylelint: 'stylelint "src/**/*.{css,scss,vue}"',
@@ -431,6 +432,134 @@ trim_trailing_whitespace = false
   }
 };
 
+// src/presets/fmt/web-react.ts
+var webReactFmt = {
+  name: "web-react",
+  description: "React Web frontend (Vite + React + TypeScript)",
+  eslint: () => `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'
+import prettierConfig from 'eslint-config-prettier'
+
+export default tseslint.config(
+  { ignores: ['dist'] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ['**/*.{ts,tsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      'react-refresh/only-export-components': ['warn', { allowConstantExport: true }],
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }],
+    },
+  },
+  prettierConfig,
+)
+`,
+  prettier: () => JSON.stringify(
+    {
+      semi: false,
+      singleQuote: true,
+      tabWidth: 2,
+      trailingComma: "all",
+      printWidth: 100,
+      endOfLine: "lf"
+    },
+    null,
+    2
+  ) + "\n",
+  prettierIgnore: () => `node_modules/
+<lockfile>
+dist/
+coverage/
+`,
+  stylelint: () => `export default {
+  plugins: ['stylelint-order', '@stylistic/stylelint-plugin'],
+  extends: [
+    'stylelint-config-standard-scss',
+    'stylelint-config-recess-order',
+  ],
+  rules: {
+    'selector-class-pattern': null,
+    'scss/dollar-variable-pattern': null,
+    'scss/percent-placeholder-pattern': null,
+    'scss/at-mixin-pattern': null,
+    'order/properties-order': null,
+  },
+}
+`,
+  stylelintIgnore: () => `node_modules/
+dist/
+`,
+  cspell: () => JSON.stringify(
+    {
+      $schema: "https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json",
+      version: "0.2",
+      language: "en,en-US",
+      allowCompoundWords: true,
+      words: ["vite", "react", "zustand", "tanstack"]
+    },
+    null,
+    2
+  ) + "\n",
+  editorconfig: () => `root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+`,
+  dependencies: {
+    dev: [
+      "eslint",
+      "@eslint/js",
+      "typescript-eslint",
+      "eslint-plugin-react-hooks",
+      "eslint-plugin-react-refresh",
+      "eslint-config-prettier",
+      "globals",
+      "prettier",
+      "stylelint",
+      "stylelint-config-standard-scss",
+      "stylelint-order",
+      "stylelint-scss",
+      "@stylistic/stylelint-plugin",
+      "postcss-scss",
+      "cspell"
+    ]
+  },
+  scripts: {
+    lint: "eslint . --cache --cache-location node_modules/.cache/.eslintcache",
+    "lint:fix": 'eslint "src/**/*.{js,ts,jsx,tsx}" --fix --cache --cache-location node_modules/.cache/.eslintcache',
+    format: 'prettier --write "src/**/*.{ts,js,json,jsx,tsx,css,scss}"',
+    "format:check": 'prettier --check "src/**/*.{ts,js,json,jsx,tsx,css,scss}"',
+    stylelint: 'stylelint "src/**/*.{css,scss}"',
+    "stylelint:fix": 'stylelint "src/**/*.{css,scss}" --fix',
+    cspell: 'cspell --gitignore "src/**/*"',
+    "type:check": "tsc --noEmit",
+    "code:check": "<pm> lint && <pm> format:check",
+    "code:fix": "<pm> lint:fix && <pm> format",
+    "code:check:all": "<pm> lint && <pm> format:check && <pm> stylelint && <pm> cspell",
+    "code:fix:all": "<pm> lint:fix && <pm> format && <pm> stylelint:fix"
+  }
+};
+
 // src/presets/fmt/web-vue.ts
 var webVueFmt = {
   name: "web-vue",
@@ -535,8 +664,8 @@ trim_trailing_whitespace = false
     ]
   },
   scripts: {
-    lint: "eslint .",
-    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix',
+    lint: "eslint . --cache --cache-location node_modules/.cache/.eslintcache",
+    "lint:fix": 'eslint "src/**/*.{js,ts,vue}" --fix --cache --cache-location node_modules/.cache/.eslintcache',
     format: 'prettier --write "src/**/*.{ts,js,json,vue,css,scss}"',
     "format:check": 'prettier --check "src/**/*.{ts,js,json,vue,css,scss}"',
     stylelint: 'stylelint "src/**/*.{css,scss,vue}"',
@@ -551,7 +680,14 @@ trim_trailing_whitespace = false
 };
 
 // src/presets/fmt/index.ts
-var FMT_PRESETS = [webVueFmt, electronVueFmt, uniappFmt, nodeFmt, nestFmt];
+var FMT_PRESETS = [
+  webVueFmt,
+  webReactFmt,
+  electronVueFmt,
+  uniappFmt,
+  nodeFmt,
+  nestFmt
+];
 
 // src/utils/logger.ts
 import chalk from "chalk";
@@ -667,7 +803,10 @@ function readJson(filePath) {
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
-  } catch {
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to read or parse ${path.basename(filePath)}: ${message}`);
     return null;
   }
 }
@@ -693,13 +832,20 @@ function generateConfigFile(preset, filename, content, opts) {
   if (action === "skip") return "skipped";
   if (opts.dryRun) return exists ? "overwritten" : "created";
   const resolved = opts.lockfile ? content.replace(/<lockfile>/g, opts.lockfile) : content.replace(/<lockfile>\n?/g, "");
-  writeFile(filepath, resolved);
+  try {
+    writeFile(filepath, resolved);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to write ${filename}: ${message}`);
+    return null;
+  }
   return exists ? "overwritten" : "created";
 }
 function generateAllFmt(preset, opts) {
   const result = { created: [], overwritten: [], skipped: [] };
   for (const { filename, getContent } of CONFIG_FILES) {
     if (opts.noStylelint && filename.includes("stylelint")) continue;
+    if (opts.noEditorconfig && filename === ".editorconfig") continue;
     const content = getContent(preset);
     if (content === void 0) continue;
     const action = generateConfigFile(preset, filename, content, opts);
@@ -713,6 +859,29 @@ function generateAllFmt(preset, opts) {
 // src/utils/deps.ts
 import path3 from "path";
 import { spawn } from "child_process";
+
+// src/utils/execFileNoThrow.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function execFileNoThrow(command, args, options) {
+  const cmdStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+  try {
+    const { stdout, stderr } = await execAsync(cmdStr, {
+      cwd: options?.cwd
+    });
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
+  } catch (err) {
+    const error = err;
+    return {
+      stdout: (error.stdout ?? "").trim(),
+      stderr: (error.stderr ?? "").trim(),
+      exitCode: error.code === "ENOENT" ? null : 1
+    };
+  }
+}
+
+// src/utils/deps.ts
 function detectPackageManager(cwd) {
   if (fileExists(`${cwd}/bun.lockb`) || fileExists(`${cwd}/bun.lock`)) return "bun";
   if (fileExists(`${cwd}/pnpm-lock.yaml`)) return "pnpm";
@@ -743,6 +912,37 @@ function getRunPrefix(pm) {
       return "npm run";
   }
 }
+async function fetchPackageVersion(pkg) {
+  const { stdout, exitCode } = await execFileNoThrow("npm", ["view", pkg, "version"]);
+  if (exitCode !== 0 || !stdout) {
+    throw new Error(`Failed to fetch version for "${pkg}" from npm registry.`);
+  }
+  const lines = stdout.split("\n").filter((line) => line.trim().length > 0);
+  return lines[lines.length - 1].trim();
+}
+async function addDepsToManifest(packages, cwd) {
+  const pkgPath = path3.join(cwd, "package.json");
+  const pkg = readJson(pkgPath);
+  if (!pkg) {
+    throw new Error("package.json not found");
+  }
+  const devDeps = pkg.devDependencies ?? {};
+  const missing = packages.filter((p) => !devDeps[p]);
+  if (missing.length === 0) return [];
+  const results = await Promise.all(
+    missing.map(async (pkgName) => {
+      const version = await fetchPackageVersion(pkgName);
+      return { pkgName, version };
+    })
+  );
+  const updatedDevDeps = { ...devDeps };
+  for (const { pkgName, version } of results) {
+    updatedDevDeps[pkgName] = `^${version}`;
+  }
+  pkg.devDependencies = updatedDevDeps;
+  writeJson(pkgPath, pkg);
+  return results.map((r) => r.pkgName);
+}
 async function installDevDeps(packages, cwd, pm) {
   const manager = pm ?? detectPackageManager(cwd);
   const pkg = readJson(path3.join(cwd, "package.json"));
@@ -780,6 +980,347 @@ async function installDevDeps(packages, cwd, pm) {
   }
 }
 
+// src/core/local-preset.ts
+import fs2 from "fs";
+import os from "os";
+import path4 from "path";
+
+// src/core/merge-settings.ts
+var USER_PRIORITY_KEYS = /* @__PURE__ */ new Set([
+  // Cursor/animation
+  "editor.cursorBlinking",
+  "editor.cursorSmoothCaretAnimation",
+  "editor.renderWhitespace",
+  "editor.guides.indentation",
+  "editor.largeFileOptimizations",
+  // Theme/appearance
+  "workbench.iconTheme",
+  "workbench.colorTheme",
+  // Suggestions
+  "editor.inlineSuggest.enabled",
+  "editor.suggestSelection",
+  "editor.acceptSuggestionOnEnter",
+  "editor.bracketPairColorization.enabled",
+  "editor.autoClosingBrackets",
+  "editor.autoClosingOvertype"
+]);
+function mergeVscodeSettings(preset, existing) {
+  const result = { ...existing };
+  for (const [key, presetVal] of Object.entries(preset)) {
+    const existingVal = existing[key];
+    if (existingVal === void 0) {
+      result[key] = presetVal;
+      continue;
+    }
+    if (USER_PRIORITY_KEYS.has(key)) {
+      continue;
+    }
+    if (isPlainObject(presetVal) && isPlainObject(existingVal)) {
+      result[key] = mergeVscodeSettings(
+        presetVal,
+        existingVal
+      );
+      continue;
+    }
+    result[key] = presetVal;
+  }
+  return result;
+}
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+// src/core/local-preset.ts
+var CONFIG_GETTERS = [
+  { filename: "eslint.config.mjs", getContent: (p) => p.eslint?.() },
+  { filename: ".prettierrc", getContent: (p) => p.prettier?.() },
+  { filename: ".prettierignore", getContent: (p) => p.prettierIgnore?.() },
+  { filename: "stylelint.config.mjs", getContent: (p) => p.stylelint?.() },
+  { filename: ".stylelintignore", getContent: (p) => p.stylelintIgnore?.() },
+  { filename: "cspell.json", getContent: (p) => p.cspell?.() },
+  { filename: ".editorconfig", getContent: (p) => p.editorconfig?.() }
+];
+var STYLELINT_FILES = /* @__PURE__ */ new Set(["stylelint.config.mjs", ".stylelintignore"]);
+var EDITORCONFIG_FILE = ".editorconfig";
+var STYLELINT_SETTINGS_PREFIXES = [
+  "stylelint.",
+  "css.validate",
+  "less.validate",
+  "scss.validate"
+];
+var STYLELINT_DEPS = /* @__PURE__ */ new Set([
+  "stylelint",
+  "stylelint-config-standard-scss",
+  "stylelint-order",
+  "stylelint-scss",
+  "@stylistic/stylelint-plugin",
+  "postcss-html",
+  "postcss-scss"
+]);
+var STYLELINT_EXTENSION = "stylelint.vscode-stylelint";
+function getLuxDir() {
+  return process.env.LUX_HOME || path4.join(os.homedir(), ".lux");
+}
+function getLocalPresetDir(type, presetName) {
+  if (!isValidPresetName(presetName)) {
+    throw new Error(`Invalid preset name: "${presetName}"`);
+  }
+  return path4.join(getLuxDir(), "preset", type, presetName);
+}
+function isValidPresetName(name) {
+  return name.length > 0 && !name.includes("/") && !name.includes("\\") && !name.includes("..");
+}
+function localPresetExists(type, presetName) {
+  const dir = getLocalPresetDir(type, presetName);
+  return fs2.existsSync(dir);
+}
+function resetLocalPreset(type, presetName) {
+  const dir = getLocalPresetDir(type, presetName);
+  if (fs2.existsSync(dir)) {
+    fs2.rmSync(dir, { recursive: true, force: true });
+    logger.log(`Reset local preset: ${dir}`);
+  }
+}
+function materializeFmtPreset(presetName, preset, opts) {
+  if (opts.dryRun) {
+    logger.log("[dry-run] Would materialize local preset to ~/.lux/preset/fmt/" + presetName);
+    return;
+  }
+  const presetDir = getLocalPresetDir("fmt", presetName);
+  ensureDir(presetDir);
+  for (const { filename, getContent } of CONFIG_GETTERS) {
+    const content = getContent(preset);
+    if (content === void 0) continue;
+    const resolved = opts.lockfile ? content.replace(/<lockfile>/g, opts.lockfile) : content.replace(/<lockfile>\n?/g, "");
+    writeFile(path4.join(presetDir, filename), resolved);
+  }
+  const templatePkg = buildTemplatePackageJson(preset);
+  writeJson(path4.join(presetDir, "package.json"), templatePkg);
+  logger.log(`Local preset created at ${presetDir}`);
+}
+function materializeVscodePreset(cwd, presetName) {
+  const presetDir = getLocalPresetDir("vscode", presetName);
+  ensureDir(presetDir);
+  const settingsSrc = path4.join(cwd, ".vscode", "settings.json");
+  if (fileExists(settingsSrc)) {
+    const content = fs2.readFileSync(settingsSrc, "utf-8");
+    writeFile(path4.join(presetDir, "settings.json"), content);
+  }
+  const extensionsSrc = path4.join(cwd, ".vscode", "extensions.json");
+  if (fileExists(extensionsSrc)) {
+    const content = fs2.readFileSync(extensionsSrc, "utf-8");
+    writeFile(path4.join(presetDir, "extensions.json"), content);
+  }
+  logger.log(`Local preset created at ${presetDir}`);
+}
+var InvalidPackageJsonError = class extends Error {
+  constructor(filePath) {
+    super(`package.json exists but is not valid JSON: ${filePath}`);
+    this.filePath = filePath;
+  }
+  filePath;
+};
+function applyLocalFmtPreset(cwd, presetName, opts) {
+  const result = {
+    created: [],
+    overwritten: [],
+    skipped: [],
+    scriptsAdded: 0,
+    scriptsSkipped: 0
+  };
+  const presetDir = getLocalPresetDir("fmt", presetName);
+  if (!fs2.existsSync(presetDir)) {
+    logger.warn(`Local preset not found at ${presetDir}`);
+    return result;
+  }
+  const projectPkgPath = path4.join(cwd, "package.json");
+  if (fileExists(projectPkgPath)) {
+    try {
+      JSON.parse(fs2.readFileSync(projectPkgPath, "utf-8"));
+    } catch {
+      throw new InvalidPackageJsonError(projectPkgPath);
+    }
+  }
+  const entries = fs2.readdirSync(presetDir).filter((name) => name !== "package.json" && fs2.statSync(path4.join(presetDir, name)).isFile());
+  for (const filename of entries) {
+    if (opts.noStylelint && STYLELINT_FILES.has(filename)) continue;
+    if (opts.noEditorconfig && filename === EDITORCONFIG_FILE) continue;
+    const destPath = path4.join(cwd, filename);
+    const exists = fileExists(destPath);
+    if (exists && !opts.force) {
+      result.skipped.push(filename);
+      if (opts.dryRun) {
+        logger.log(`[dry-run] Skipped ${filename} (already exists)`);
+      }
+      continue;
+    }
+    if (opts.dryRun) {
+      (exists ? result.overwritten : result.created).push(filename);
+      logger.log(`[dry-run] Would copy ${filename} from local preset`);
+      continue;
+    }
+    const content = fs2.readFileSync(path4.join(presetDir, filename), "utf-8");
+    writeFile(destPath, content);
+    (exists ? result.overwritten : result.created).push(filename);
+  }
+  const templatePkg = readJson(path4.join(presetDir, "package.json"));
+  const projectPkg = readJson(projectPkgPath);
+  if (templatePkg && projectPkg) {
+    const pm = fileExists(path4.join(cwd, "package.json")) ? detectPackageManager(cwd) : void 0;
+    const merged = mergeTemplateIntoProject(templatePkg, projectPkg, pm, opts, result);
+    if (!opts.dryRun) {
+      writeJson(projectPkgPath, merged);
+    }
+  }
+  return result;
+}
+function applyLocalVscodePreset(cwd, presetName, opts) {
+  const result = {
+    created: [],
+    overwritten: [],
+    skipped: [],
+    scriptsAdded: 0,
+    scriptsSkipped: 0
+  };
+  const presetDir = getLocalPresetDir("vscode", presetName);
+  if (!fs2.existsSync(presetDir)) {
+    logger.warn(`Local preset not found at ${presetDir}`);
+    return result;
+  }
+  const settingsSrc = path4.join(presetDir, "settings.json");
+  if (fileExists(settingsSrc)) {
+    const presetSettings = readJson(settingsSrc);
+    const filteredSettings = opts.noStylelint ? filterStylelintSettings(presetSettings ?? {}) : presetSettings;
+    if (filteredSettings) {
+      const settingsDest = path4.join(cwd, ".vscode", "settings.json");
+      const existingSettings = readJson(settingsDest);
+      if (existingSettings) {
+        if (opts.dryRun) {
+          result.overwritten.push(".vscode/settings.json");
+          logger.log("[dry-run] Would merge .vscode/settings.json from local preset");
+        } else {
+          const merged = mergeVscodeSettings(filteredSettings, existingSettings);
+          writeJson(settingsDest, merged);
+          result.overwritten.push(".vscode/settings.json");
+        }
+      } else {
+        if (opts.dryRun) {
+          result.created.push(".vscode/settings.json");
+          logger.log("[dry-run] Would create .vscode/settings.json from local preset");
+        } else {
+          writeJson(settingsDest, filteredSettings);
+          result.created.push(".vscode/settings.json");
+        }
+      }
+    }
+  }
+  const extensionsSrc = path4.join(presetDir, "extensions.json");
+  if (fileExists(extensionsSrc)) {
+    const extensionsData = readJson(extensionsSrc);
+    if (extensionsData) {
+      let presetRecommendations = extensionsData.recommendations ?? [];
+      if (opts.noStylelint) {
+        presetRecommendations = presetRecommendations.filter((ext) => ext !== STYLELINT_EXTENSION);
+      }
+      if (opts.dryRun) {
+        result.created.push(".vscode/extensions.json");
+        logger.log("[dry-run] Would create .vscode/extensions.json from local preset");
+      } else {
+        const extensionsDest = path4.join(cwd, ".vscode", "extensions.json");
+        const existingExtensions = readJson(extensionsDest);
+        const existingRecommendations = existingExtensions?.recommendations ?? [];
+        const merged = [.../* @__PURE__ */ new Set([...existingRecommendations, ...presetRecommendations])];
+        writeJson(extensionsDest, { recommendations: merged });
+        result.created.push(".vscode/extensions.json");
+      }
+    }
+  }
+  return result;
+}
+function buildTemplatePackageJson(preset) {
+  const deps = {};
+  if (preset.dependencies?.dev) {
+    for (const dep of preset.dependencies.dev) {
+      deps[dep] = "<latest>";
+    }
+  }
+  const scripts = preset.scripts ? { ...preset.scripts } : void 0;
+  const result = {};
+  if (Object.keys(deps).length > 0) {
+    result.devDependencies = deps;
+  }
+  if (scripts && Object.keys(scripts).length > 0) {
+    result.scripts = scripts;
+  }
+  return result;
+}
+function mergeTemplateIntoProject(templatePkg, projectPkg, pm, opts, result) {
+  const merged = { ...projectPkg };
+  const prefix = pm ? getRunPrefix(pm) : "";
+  if (templatePkg.devDependencies) {
+    const existingDeps = merged.devDependencies ?? {};
+    const newDeps = { ...existingDeps };
+    for (const [dep, version] of Object.entries(templatePkg.devDependencies)) {
+      if (opts.noStylelint && STYLELINT_DEPS.has(dep)) continue;
+      if (opts.noEditorconfig && dep.includes("editorconfig")) continue;
+      if (existingDeps[dep] === void 0 && version !== "<latest>") {
+        newDeps[dep] = version;
+      }
+    }
+    merged.devDependencies = newDeps;
+  }
+  if (templatePkg.scripts) {
+    const existingScripts = merged.scripts ?? {};
+    const newScripts = { ...existingScripts };
+    for (const [key, value] of Object.entries(templatePkg.scripts)) {
+      if (opts.noStylelint && key.startsWith("stylelint")) continue;
+      const resolved = value.replace(/<pm>/g, prefix);
+      if (existingScripts[key] !== void 0 && !opts.force) {
+        result.scriptsSkipped++;
+        if (opts.dryRun) {
+          logger.log(`[dry-run] Skipped script "${key}" (already exists)`);
+        } else {
+          logger.log(`Skipped script "${key}" (already exists)`);
+        }
+        continue;
+      }
+      if (opts.dryRun) {
+        result.scriptsAdded++;
+        logger.log(`[dry-run] Would add script "${key}"`);
+        continue;
+      }
+      newScripts[key] = resolved;
+      result.scriptsAdded++;
+    }
+    merged.scripts = newScripts;
+  }
+  return merged;
+}
+function filterStylelintSettings(settings) {
+  const filtered = Object.fromEntries(
+    Object.entries(settings).filter(
+      ([key]) => !STYLELINT_SETTINGS_PREFIXES.some((prefix) => key.startsWith(prefix))
+    )
+  );
+  if (typeof filtered["editor.codeActionsOnSave"] === "object" && filtered["editor.codeActionsOnSave"] !== null) {
+    const actions = { ...filtered["editor.codeActionsOnSave"] };
+    delete actions["source.fixAll.stylelint"];
+    filtered["editor.codeActionsOnSave"] = actions;
+  }
+  return filtered;
+}
+function resolveLocalDeps(deps) {
+  const packages = [];
+  for (const [name, version] of Object.entries(deps)) {
+    if (version === "<latest>") {
+      packages.push(name);
+    } else {
+      packages.push(`${name}@${version}`);
+    }
+  }
+  return packages;
+}
+
 // src/commands/fmt.ts
 function filterStylelintScripts(scripts) {
   const filtered = {};
@@ -794,52 +1335,35 @@ function isNotStylelintDep(dep) {
   if (dep === "postcss-html" || dep === "postcss-scss") return false;
   return true;
 }
+function isNotEditorconfigDep(dep) {
+  return !dep.includes("editorconfig");
+}
 function registerFmtCommand(program2) {
   const fmt = program2.command("fmt").description("Initialize formatting config with preset");
-  fmt.argument("<preset>").option("-F, --force", "Force overwrite existing files").option("--no-install", "Skip dependency installation").option("--dry-run", "Preview without writing files").option("--no-stylelint", "Skip Stylelint config generation").action(
+  fmt.argument("<preset>").option("-F, --force", "Force overwrite existing files").option("--no-install", "Skip dependency installation").option("--dry-run", "Preview without writing files").option("--stylelint", "Include Stylelint config generation").option("--editorconfig", "Include EditorConfig config generation").option("--reset", "Reset local preset and re-materialize from built-in").action(
     async (presetName, options) => {
       const preset = resolvePreset(FMT_PRESETS, presetName);
       if (!preset) return;
       const cwd = process.cwd();
-      const pm = fileExists(path4.join(cwd, "package.json")) ? detectPackageManager(cwd) : void 0;
-      const opts = {
-        cwd,
-        force: options.force ?? false,
-        dryRun: options.dryRun ?? false,
-        noStylelint: options.stylelint === false,
-        lockfile: pm ? getLockfileName(pm) : void 0
-      };
-      const result = generateAllFmt(preset, opts);
-      const allFiles = [...result.created, ...result.overwritten];
-      if (allFiles.length === 0 && result.skipped.length === 0) {
-        logger.warn("No files to generate for this preset");
-        return;
+      const pkgPath = path5.join(cwd, "package.json");
+      if (fileExists(pkgPath)) {
+        try {
+          JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+        } catch {
+          logger.error(
+            "package.json exists but is not valid JSON. Fix it first, then re-run this command."
+          );
+          return;
+        }
       }
-      logGenerationResult(result, opts.dryRun);
-      if (!pm) {
-        warnMissingPackageJson(preset, options.install !== false);
-        return;
+      if (options.reset) {
+        resetLocalPreset("fmt", presetName);
       }
-      const scripts = opts.noStylelint && preset.scripts ? filterStylelintScripts(preset.scripts) : preset.scripts;
-      if (scripts) {
-        await injectScripts(scripts, opts, pm);
-      }
-      if (!preset.dependencies?.dev) return;
-      const devDeps = opts.noStylelint ? preset.dependencies.dev.filter(isNotStylelintDep) : preset.dependencies.dev;
-      if (options.install === false) {
-        logger.log(`Dependencies: ${devDeps.join(", ")}`);
-        return;
-      }
-      if (opts.dryRun) {
-        logger.log(`[dry-run] Would install: ${devDeps.join(", ")}`);
-        return;
-      }
-      try {
-        logger.log(`Installing dependencies with ${pm}...`);
-        await installDevDeps(devDeps, cwd, pm);
-        logger.success("Dependencies installed successfully");
-      } catch {
-        logger.warn("Dependency installation failed. You can install manually.");
+      const useLocal = localPresetExists("fmt", presetName);
+      if (useLocal) {
+        await executeLocalPath(cwd, presetName, options);
+      } else {
+        await executeBuiltinPath(cwd, presetName, preset, options);
       }
     }
   );
@@ -849,6 +1373,139 @@ function registerFmtCommand(program2) {
     }
   });
 }
+async function executeLocalPath(cwd, presetName, options) {
+  logger.log("Using local custom preset");
+  const opts = {
+    cwd,
+    force: options.force ?? false,
+    dryRun: options.dryRun ?? false,
+    noStylelint: options.stylelint !== true,
+    noEditorconfig: options.editorconfig !== true
+  };
+  let result;
+  try {
+    result = applyLocalFmtPreset(cwd, presetName, opts);
+  } catch (error) {
+    if (error instanceof InvalidPackageJsonError) {
+      logger.error(
+        "package.json exists but is not valid JSON. Fix it first, then re-run this command."
+      );
+      return;
+    }
+    throw error;
+  }
+  const allFiles = [...result.created, ...result.overwritten];
+  if (allFiles.length > 0 || result.skipped.length > 0) {
+    logApplyResult(result);
+  }
+  if (result.scriptsAdded > 0 || result.scriptsSkipped > 0) {
+    logger.log(
+      `Added ${result.scriptsAdded} script${result.scriptsAdded > 1 ? "s" : ""} to package.json${result.scriptsSkipped > 0 ? ` (${result.scriptsSkipped} skipped)` : ""}`
+    );
+  }
+  const pm = fileExists(path5.join(cwd, "package.json")) ? detectPackageManager(cwd) : void 0;
+  if (!pm) return;
+  const templatePkgPath = path5.join(getLocalPresetDir("fmt", presetName), "package.json");
+  const templatePkg = readJson(templatePkgPath);
+  if (!templatePkg?.devDependencies) return;
+  const depsToInstall = filterDeps(
+    Object.keys(templatePkg.devDependencies),
+    opts.noStylelint,
+    opts.noEditorconfig
+  );
+  const projectPkgPath = path5.join(cwd, "package.json");
+  const projectPkg = readJson(projectPkgPath);
+  if (!projectPkg) return;
+  const existingDeps = projectPkg.devDependencies ?? {};
+  const missing = depsToInstall.filter((dep) => !existingDeps[dep]);
+  if (missing.length === 0) return;
+  if (options.install === false) {
+    const resolved = resolveLocalDeps(templatePkg.devDependencies);
+    const added = await addDepsToManifest(resolved, cwd);
+    if (added.length > 0) {
+      logger.success(`Added to package.json (skipped install): ${added.join(", ")}`);
+    } else {
+      logger.log("All dependencies already in package.json");
+    }
+    return;
+  }
+  if (opts.dryRun) {
+    logger.log(`[dry-run] Would install: ${missing.join(", ")}`);
+    return;
+  }
+  try {
+    logger.log(`Installing dependencies with ${pm}...`);
+    const resolved = resolveLocalDeps(
+      Object.fromEntries(
+        Object.entries(templatePkg.devDependencies).filter(([k]) => missing.includes(k))
+      )
+    );
+    await installDevDeps(resolved, cwd, pm);
+    logger.success("Dependencies installed successfully");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Dependency installation failed: ${message}. You can install manually.`);
+  }
+}
+async function executeBuiltinPath(cwd, presetName, preset, options) {
+  const pm = fileExists(path5.join(cwd, "package.json")) ? detectPackageManager(cwd) : void 0;
+  const opts = {
+    cwd,
+    force: options.force ?? false,
+    dryRun: options.dryRun ?? false,
+    noStylelint: options.stylelint !== true,
+    noEditorconfig: options.editorconfig !== true,
+    lockfile: pm ? getLockfileName(pm) : void 0
+  };
+  const result = generateAllFmt(preset, opts);
+  const allFiles = [...result.created, ...result.overwritten];
+  if (allFiles.length === 0 && result.skipped.length === 0) {
+    logger.warn("No files to generate for this preset");
+    return;
+  }
+  logGenerationResult(result, opts.dryRun);
+  if (!opts.dryRun) {
+    materializeFmtPreset(presetName, preset, opts);
+  }
+  if (!pm) {
+    warnMissingPackageJson(preset, options.install !== false);
+    return;
+  }
+  const scripts = opts.noStylelint && preset.scripts ? filterStylelintScripts(preset.scripts) : preset.scripts;
+  if (scripts) {
+    await injectScripts(scripts, opts, pm);
+  }
+  if (!preset.dependencies?.dev) return;
+  const devDeps = opts.noStylelint ? preset.dependencies.dev.filter(isNotStylelintDep) : preset.dependencies.dev;
+  const finalDeps = opts.noEditorconfig ? devDeps.filter(isNotEditorconfigDep) : devDeps;
+  if (options.install === false) {
+    const added = await addDepsToManifest(finalDeps, cwd);
+    if (added.length > 0) {
+      logger.success(`Added to package.json (skipped install): ${added.join(", ")}`);
+    } else {
+      logger.log("All dependencies already in package.json");
+    }
+    return;
+  }
+  if (opts.dryRun) {
+    logger.log(`[dry-run] Would install: ${finalDeps.join(", ")}`);
+    return;
+  }
+  try {
+    logger.log(`Installing dependencies with ${pm}...`);
+    await installDevDeps(finalDeps, cwd, pm);
+    logger.success("Dependencies installed successfully");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Dependency installation failed: ${message}. You can install manually.`);
+  }
+}
+function filterDeps(deps, noStylelint, noEditorconfig) {
+  let filtered = deps;
+  if (noStylelint) filtered = filtered.filter(isNotStylelintDep);
+  if (noEditorconfig) filtered = filtered.filter(isNotEditorconfigDep);
+  return filtered;
+}
 function logGenerationResult(result, dryRun) {
   const files = [...result.created, ...result.overwritten];
   if (dryRun) {
@@ -862,12 +1519,29 @@ function logGenerationResult(result, dryRun) {
   }
   if (result.created.length > 0) {
     logger.log(
-      `Created ${summarizeFiles(result.created)} config ${result.created.length} file${result.created.length > 1 ? "s" : ""}`
+      `Created ${summarizeFiles(result.created)} config ${result.created.length} file${result.created.length > 1 ? "s" : ""}`
+    );
+  }
+  if (result.overwritten.length > 0) {
+    logger.log(
+      `Overwritten ${summarizeFiles(result.overwritten)} config ${result.overwritten.length} file${result.overwritten.length > 1 ? "s" : ""}`
+    );
+  }
+  if (result.skipped.length > 0) {
+    logger.log(
+      `Skipped ${result.skipped.length} file${result.skipped.length > 1 ? "s" : ""} (already exists)`
+    );
+  }
+}
+function logApplyResult(result) {
+  if (result.created.length > 0) {
+    logger.log(
+      `Created ${summarizeFiles(result.created)} config ${result.created.length} file${result.created.length > 1 ? "s" : ""} from local preset`
     );
   }
   if (result.overwritten.length > 0) {
     logger.log(
-      `Overwritten ${summarizeFiles(result.overwritten)} config ${result.overwritten.length} file${result.overwritten.length > 1 ? "s" : ""}`
+      `Overwritten ${summarizeFiles(result.overwritten)} config ${result.overwritten.length} file${result.overwritten.length > 1 ? "s" : ""} from local preset`
     );
   }
   if (result.skipped.length > 0) {
@@ -896,7 +1570,7 @@ function summarizeFiles(filenames) {
   return [...categories].join(", ");
 }
 async function injectScripts(scripts, opts, pm) {
-  const pkgPath = path4.join(opts.cwd, "package.json");
+  const pkgPath = path5.join(opts.cwd, "package.json");
   const pkg = readJson(pkgPath);
   if (!pkg) {
     logger.warn("package.json not found, skipping script injection");
@@ -931,19 +1605,109 @@ async function injectScripts(scripts, opts, pm) {
   }
 }
 
+// src/commands/init.ts
+import { select, isCancel, cancel, outro } from "@clack/prompts";
+
+// src/presets/init.ts
+var INIT_TOOLS = [
+  {
+    name: "claude",
+    label: "Claude Code",
+    targetDir: ".claude/skills"
+  },
+  {
+    name: "opencode",
+    label: "OpenCode",
+    targetDir: ".opencode/skills"
+  }
+];
+
+// src/generators/init.ts
+import fs4 from "fs";
+import path6 from "path";
+function resolveSkillsDir() {
+  const entryDir = path6.dirname(process.argv[1] ?? "");
+  return path6.resolve(entryDir, "skills");
+}
+function listFilesRecursive(dir, base) {
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const childBase = `${base}/${entry.name}`;
+    const fullPath = path6.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listFilesRecursive(fullPath, childBase));
+    } else {
+      files.push(childBase);
+    }
+  }
+  return files;
+}
+function generateInitSkills(targetBaseDir, cwd) {
+  const skillsDir = resolveSkillsDir();
+  if (!fs4.existsSync(skillsDir)) {
+    logger.error(`Bundled skills directory not found: ${skillsDir}`);
+    logger.error('Please run "lux build" or reinstall lux.');
+    return { copiedFiles: [], targetDir: targetBaseDir };
+  }
+  const targetPath = path6.resolve(cwd, targetBaseDir);
+  try {
+    fs4.cpSync(skillsDir, targetPath, { recursive: true, force: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to copy skills to ${targetPath}: ${message}`);
+    return { copiedFiles: [], targetDir: targetBaseDir };
+  }
+  const copiedFiles = fs4.existsSync(targetPath) ? listFilesRecursive(targetPath, targetBaseDir) : [];
+  return { copiedFiles, targetDir: targetBaseDir };
+}
+
+// src/commands/init.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize AI coding tool skills in current project").action(async () => {
+    const toolOptions = INIT_TOOLS.map((tool2) => ({
+      value: tool2.name,
+      label: tool2.label
+    }));
+    const selected = await select({
+      message: "Which AI coding tool do you use?",
+      options: toolOptions
+    });
+    if (isCancel(selected)) {
+      cancel("Operation cancelled.");
+      return;
+    }
+    const tool = INIT_TOOLS.find((t) => t.name === selected);
+    if (!tool) {
+      logger.error(`Unknown tool: ${String(selected)}`);
+      return;
+    }
+    const cwd = process.cwd();
+    const result = generateInitSkills(tool.targetDir, cwd);
+    if (result.copiedFiles.length === 0) {
+      logger.warn("No skill files were copied.");
+      return;
+    }
+    for (const file of result.copiedFiles) {
+      logger.log(`  ${file}`);
+    }
+    outro(`Skills installed to ${tool.targetDir}/`);
+  });
+}
+
 // src/utils/config.ts
-import fs2 from "fs";
-import os from "os";
-import path5 from "path";
+import fs5 from "fs";
+import os2 from "os";
+import path7 from "path";
 var CONFIG_DIR = ".lux";
 var ENV_FILE = "env.txt";
 function getEnvConfigPath() {
-  return path5.join(os.homedir(), CONFIG_DIR, ENV_FILE);
+  return path7.join(os2.homedir(), CONFIG_DIR, ENV_FILE);
 }
 function getEnvConfig() {
   let content;
   try {
-    content = fs2.readFileSync(getEnvConfigPath(), "utf-8");
+    content = fs5.readFileSync(getEnvConfigPath(), "utf-8");
   } catch {
     return {};
   }
@@ -966,7 +1730,7 @@ function setEnvConfig(data) {
 }
 function clearEnvConfig() {
   try {
-    fs2.unlinkSync(getEnvConfigPath());
+    fs5.unlinkSync(getEnvConfigPath());
   } catch {
   }
 }
@@ -988,27 +1752,6 @@ function registerShowCommand(program2) {
   show.command("env").description("Display stored proxy environment variables").action(() => handleShowEnv());
 }
 
-// src/utils/execFileNoThrow.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-async function execFileNoThrow(command, args, options) {
-  const cmdStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-  try {
-    const { stdout, stderr } = await execAsync(cmdStr, {
-      cwd: options?.cwd
-    });
-    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode: 0 };
-  } catch (err) {
-    const error = err;
-    return {
-      stdout: (error.stdout ?? "").trim(),
-      stderr: (error.stderr ?? "").trim(),
-      exitCode: error.code === "ENOENT" ? null : 1
-    };
-  }
-}
-
 // src/utils/version.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -1206,6 +1949,138 @@ var webVueVscode = {
   ]
 };
 
+// src/presets/vscode/web-react.ts
+var webReactVscode = {
+  name: "web-react",
+  description: "VSCode config for React Web",
+  settings: () => ({
+    // ===== Editor Preferences =====
+    "editor.tabSize": 2,
+    "editor.detectIndentation": false,
+    "editor.insertSpaces": true,
+    "editor.renderWhitespace": "selection",
+    "editor.guides.indentation": true,
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll.eslint": "explicit",
+      "source.fixAll.stylelint": "explicit",
+      "source.organizeImports": "never"
+    },
+    // Cursor & Animation
+    "editor.cursorBlinking": "expand",
+    "editor.cursorSmoothCaretAnimation": "on",
+    "editor.largeFileOptimizations": true,
+    // Code Assistance
+    "editor.inlineSuggest.enabled": true,
+    "editor.suggestSelection": "recentlyUsedByPrefix",
+    "editor.acceptSuggestionOnEnter": "smart",
+    "editor.bracketPairColorization.enabled": true,
+    "editor.autoClosingBrackets": "beforeWhitespace",
+    "editor.autoClosingOvertype": "always",
+    // ===== TypeScript =====
+    "js/ts.inlayHints.enumMemberValues.enabled": true,
+    "js/ts.preferences.preferTypeOnlyAutoImports": true,
+    "js/ts.preferences.includePackageJsonAutoImports": "on",
+    "js/ts.preferences.importModuleSpecifier": "relative",
+    "js/ts.suggest.autoImports": true,
+    "js/ts.tsserver.exclude": ["**/node_modules", "**/dist", "**/.turbo"],
+    // ===== Language-specific Formatting =====
+    "[html]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+    "[css]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+    "[scss]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+    "[typescript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode",
+      "editor.formatOnSave": true
+    },
+    "[javascript]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode",
+      "editor.formatOnSave": true
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode",
+      "editor.formatOnSave": true
+    },
+    "[javascriptreact]": {
+      "editor.defaultFormatter": "esbenp.prettier-vscode",
+      "editor.formatOnSave": true
+    },
+    "[json]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+    "[jsonc]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
+    // ===== Terminal =====
+    "terminal.integrated.cursorBlinking": true,
+    "terminal.integrated.tabs.enabled": true,
+    "terminal.integrated.scrollback": 1e4,
+    // ===== File Exclusion =====
+    "files.watcherExclude": {
+      "**/.git/objects/**": true,
+      "**/.git/subtree-cache/**": true,
+      "**/.vscode/**": true,
+      "**/node_modules/**": true,
+      "**/tmp/**": true,
+      "**/dist/**": true,
+      "**/pnpm-lock.yaml": true,
+      "**/package-lock.json": true,
+      "**/bun.lock": true,
+      "**/yarn.lock": true
+    },
+    "search.exclude": {
+      "**/node_modules": true,
+      "**/*.log": true,
+      "**/*.log*": true,
+      "**/dist": true,
+      "**/.git": true,
+      "**/.vscode": false,
+      "**/tmp": true,
+      node_modules: true,
+      "**/pnpm-lock.yaml": true,
+      "**/package-lock.json": true,
+      "**/bun.lock": true,
+      "**/yarn.lock": true
+    },
+    // ===== File Nesting =====
+    "explorer.fileNesting.enabled": true,
+    "explorer.fileNesting.expand": false,
+    "explorer.fileNesting.patterns": {
+      "package.json": "pnpm-lock.yaml,yarn.lock,bun.lock, .gitignore, .browserslistrc, .npmrc, cspell.json,README.md, LICENSE*,.editorconfig",
+      "eslint.config.mjs": ".prettierignore, .prettierrc, .prettierrc.json, .editorconfig",
+      "tsconfig.json": "tsconfig.*.json",
+      "tailwind.config.js": "postcss.config.js",
+      "vite.config.{js,ts}": "vite.*.{js,ts}",
+      ".env": ".env.*"
+    },
+    // ===== ESLint =====
+    "eslint.validate": [
+      "javascript",
+      "typescript",
+      "javascriptreact",
+      "typescriptreact",
+      "html",
+      "markdown",
+      "json",
+      "jsonc",
+      "json5"
+    ],
+    // ===== Stylelint =====
+    "stylelint.enable": true,
+    "stylelint.validate": ["css", "scss"],
+    "stylelint.snippet": ["css", "scss"],
+    "css.validate": false,
+    "less.validate": false,
+    "scss.validate": false,
+    // ===== CSpell =====
+    "cSpell.language": "en"
+  }),
+  extensions: () => [
+    "dbaeumer.vscode-eslint",
+    "esbenp.prettier-vscode",
+    "stylelint.vscode-stylelint",
+    "mrmlnc.vscode-scss",
+    "streetsidesoftware.code-spell-checker",
+    "editorconfig.editorconfig"
+  ]
+};
+
 // src/presets/vscode/electron.ts
 var electronVueVscode = {
   name: "electron-vue",
@@ -1697,6 +2572,7 @@ var goVscode = {
 // src/presets/vscode/index.ts
 var VSCODE_PRESETS = [
   webVueVscode,
+  webReactVscode,
   electronVueVscode,
   uniappVscode,
   nodeVscode,
@@ -1704,59 +2580,14 @@ var VSCODE_PRESETS = [
   goVscode
 ];
 
-// src/core/merge-settings.ts
-var USER_PRIORITY_KEYS = /* @__PURE__ */ new Set([
-  // Cursor/animation
-  "editor.cursorBlinking",
-  "editor.cursorSmoothCaretAnimation",
-  "editor.renderWhitespace",
-  "editor.guides.indentation",
-  "editor.largeFileOptimizations",
-  // Theme/appearance
-  "workbench.iconTheme",
-  "workbench.colorTheme",
-  // Suggestions
-  "editor.inlineSuggest.enabled",
-  "editor.suggestSelection",
-  "editor.acceptSuggestionOnEnter",
-  "editor.bracketPairColorization.enabled",
-  "editor.autoClosingBrackets",
-  "editor.autoClosingOvertype"
-]);
-function mergeVscodeSettings(preset, existing) {
-  const result = { ...existing };
-  for (const [key, presetVal] of Object.entries(preset)) {
-    const existingVal = existing[key];
-    if (existingVal === void 0) {
-      result[key] = presetVal;
-      continue;
-    }
-    if (USER_PRIORITY_KEYS.has(key)) {
-      continue;
-    }
-    if (isPlainObject(presetVal) && isPlainObject(existingVal)) {
-      result[key] = mergeVscodeSettings(
-        presetVal,
-        existingVal
-      );
-      continue;
-    }
-    result[key] = presetVal;
-  }
-  return result;
-}
-function isPlainObject(val) {
-  return typeof val === "object" && val !== null && !Array.isArray(val);
-}
-
 // src/generators/vscode.ts
-var STYLELINT_SETTINGS_PREFIXES = [
+var STYLELINT_SETTINGS_PREFIXES2 = [
   "stylelint.",
   "css.validate",
   "less.validate",
   "scss.validate"
 ];
-var STYLELINT_EXTENSION = "stylelint.vscode-stylelint";
+var STYLELINT_EXTENSION2 = "stylelint.vscode-stylelint";
 function generateVscodeSettings(preset, opts) {
   const settingsPath = `${opts.cwd}/.vscode/settings.json`;
   if (opts.dryRun) {
@@ -1764,25 +2595,50 @@ function generateVscodeSettings(preset, opts) {
     return existingSettings2 ? "overwritten" : "created";
   }
   const rawSettings = preset.settings();
-  const presetSettings = opts.noStylelint ? filterStylelintSettings(rawSettings) : rawSettings;
+  const presetSettings = opts.noStylelint ? filterStylelintSettings2(rawSettings) : rawSettings;
   const existingSettings = readJson(settingsPath);
   if (existingSettings) {
     const backupPath = `${settingsPath}.bak`;
     if (!fileExists(backupPath)) {
-      writeFile(backupPath, JSON.stringify(existingSettings, null, 2) + "\n");
-      logger.log(`Backed up .vscode/settings.json \u2192 settings.json.bak`);
+      try {
+        writeFile(backupPath, JSON.stringify(existingSettings, null, 2) + "\n");
+        logger.log("Backed up .vscode/settings.json \u2192 settings.json.bak");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(
+          `Failed to backup .vscode/settings.json: ${message}. Continuing without backup.`
+        );
+      }
+    }
+    try {
+      const merged = mergeVscodeSettings(presetSettings, existingSettings);
+      writeJson(settingsPath, merged);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to write .vscode/settings.json: ${msg}`);
+      return null;
     }
-    const merged = mergeVscodeSettings(presetSettings, existingSettings);
-    writeJson(settingsPath, merged);
     return "overwritten";
   }
-  writeJson(settingsPath, presetSettings);
+  try {
+    writeJson(settingsPath, presetSettings);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to write .vscode/settings.json: ${msg}`);
+    return null;
+  }
   return "created";
 }
 function generateVscodeExtensions(preset, opts) {
   if (opts.dryRun) return "created";
-  const extensions = opts.noStylelint ? preset.extensions().filter((ext) => ext !== STYLELINT_EXTENSION) : preset.extensions();
-  writeJson(`${opts.cwd}/.vscode/extensions.json`, { recommendations: extensions });
+  const extensions = opts.noStylelint ? preset.extensions().filter((ext) => ext !== STYLELINT_EXTENSION2) : preset.extensions();
+  try {
+    writeJson(`${opts.cwd}/.vscode/extensions.json`, { recommendations: extensions });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    logger.error(`Failed to write .vscode/extensions.json: ${msg}`);
+    return null;
+  }
   return "created";
 }
 function generateAllVscode(preset, opts) {
@@ -1794,10 +2650,10 @@ function generateAllVscode(preset, opts) {
   if (extAction === "created") result.created.push(".vscode/extensions.json");
   return result;
 }
-function filterStylelintSettings(settings) {
+function filterStylelintSettings2(settings) {
   const filtered = Object.fromEntries(
     Object.entries(settings).filter(
-      ([key]) => !STYLELINT_SETTINGS_PREFIXES.some((prefix) => key.startsWith(prefix))
+      ([key]) => !STYLELINT_SETTINGS_PREFIXES2.some((prefix) => key.startsWith(prefix))
     )
   );
   if (typeof filtered["editor.codeActionsOnSave"] === "object" && filtered["editor.codeActionsOnSave"] !== null) {
@@ -1811,28 +2667,20 @@ function filterStylelintSettings(settings) {
 // src/commands/vscode.ts
 function registerVscodeCommand(program2) {
   const vscode = program2.command("vscode").description("Initialize VSCode config with preset");
-  vscode.argument("<preset>").option("-F, --force", "Force overwrite existing files").option("--dry-run", "Preview without writing files").option("--no-stylelint", "Skip Stylelint settings and extension").action(
+  vscode.argument("<preset>").option("-F, --force", "Force overwrite existing files").option("--dry-run", "Preview without writing files").option("--stylelint", "Include Stylelint settings and extension").option("--reset", "Reset local preset and re-materialize from built-in").action(
     async (presetName, options) => {
       const preset = resolvePreset(VSCODE_PRESETS, presetName);
       if (!preset) return;
       const cwd = process.cwd();
-      const opts = {
-        cwd,
-        force: options.force ?? false,
-        dryRun: options.dryRun ?? false,
-        noStylelint: options.stylelint === false
-      };
-      const result = generateAllVscode(preset, opts);
-      const files = [...result.created, ...result.overwritten];
-      if (files.length === 0) {
-        logger.warn("No files generated");
-        return;
+      if (options.reset) {
+        resetLocalPreset("vscode", presetName);
       }
-      if (opts.dryRun) {
-        logger.log(`[dry-run] Would create ${files.join(", ")}`);
-        return;
+      const useLocal = localPresetExists("vscode", presetName);
+      if (useLocal) {
+        executeVscodeLocalPath(cwd, presetName, options);
+      } else {
+        executeVscodeBuiltinPath(cwd, presetName, preset, options);
       }
-      logger.log(`Created ${files.join(", ")}`);
     }
   );
   vscode.command("list").description("List available vscode presets").action(() => {
@@ -1841,6 +2689,48 @@ function registerVscodeCommand(program2) {
     }
   });
 }
+function executeVscodeLocalPath(cwd, presetName, options) {
+  logger.log("Using local custom preset");
+  const opts = {
+    cwd,
+    force: options.force ?? false,
+    dryRun: options.dryRun ?? false,
+    noStylelint: options.stylelint !== true,
+    noEditorconfig: false
+  };
+  const result = applyLocalVscodePreset(cwd, presetName, opts);
+  const files = [...result.created, ...result.overwritten];
+  if (files.length === 0) {
+    logger.warn("No files generated");
+    return;
+  }
+  if (opts.dryRun) {
+    logger.log(`[dry-run] Would create ${files.join(", ")} from local preset`);
+    return;
+  }
+  logger.log(`Created ${files.join(", ")} from local preset`);
+}
+function executeVscodeBuiltinPath(cwd, presetName, preset, options) {
+  const opts = {
+    cwd,
+    force: options.force ?? false,
+    dryRun: options.dryRun ?? false,
+    noStylelint: options.stylelint !== true,
+    noEditorconfig: false
+  };
+  const result = generateAllVscode(preset, opts);
+  const files = [...result.created, ...result.overwritten];
+  if (files.length === 0) {
+    logger.warn("No files generated");
+    return;
+  }
+  if (opts.dryRun) {
+    logger.log(`[dry-run] Would create ${files.join(", ")}`);
+    return;
+  }
+  logger.log(`Created ${files.join(", ")}`);
+  materializeVscodePreset(cwd, presetName);
+}
 
 // src/commands/vpn.ts
 import { spawnSync } from "child_process";
@@ -1921,6 +2811,7 @@ function registerVpnCommand(program2) {
 // src/index.ts
 program.name("lux").description("One-click project formatting & VSCode config CLI").version(getCurrentVersion());
 registerFmtCommand(program);
+registerInitCommand(program);
 registerVscodeCommand(program);
 registerVpnCommand(program);
 registerShowCommand(program);