@luxkit/cli 1.1.0 → 1.1.1

package/README.md

@@ -111,6 +111,7 @@ lux fmt <preset> [options]
   --dry-run       Preview without writing files
   --stylelint     Include Stylelint config generation (opt-in)
   --editorconfig  Include EditorConfig config generation (opt-in)
+  --reset         Reset local preset and re-create from built-in defaults
 ```
 
 <br />
@@ -124,6 +125,12 @@ lux fmt web-vue
   Parse CLI args ──► Resolve preset (fuzzy match on typo)
        │
        ▼
+  Local preset exists in ~/.lux/preset/?
+       │
+       ├── Yes ──► Copy files from local preset (editable, survives updates)
+       └── No  ──► Generate from built-in ──► Save to ~/.lux/preset/ for reuse
+       │
+       ▼
   For each config file:
        │
        ├── File not found? ──► Create

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 = {
@@ -979,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 = {};
@@ -998,58 +1340,30 @@ function isNotEditorconfigDep(dep) {
 }
 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("--stylelint", "Include Stylelint config generation").option("--editorconfig", "Include EditorConfig 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 !== 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 (!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");
+      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;
         }
-        return;
       }
-      if (opts.dryRun) {
-        logger.log(`[dry-run] Would install: ${finalDeps.join(", ")}`);
-        return;
+      if (options.reset) {
+        resetLocalPreset("fmt", presetName);
       }
-      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.`);
+      const useLocal = localPresetExists("fmt", presetName);
+      if (useLocal) {
+        await executeLocalPath(cwd, presetName, options);
+      } else {
+        await executeBuiltinPath(cwd, presetName, preset, options);
       }
     }
   );
@@ -1059,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) {
@@ -1086,6 +1533,23 @@ function logGenerationResult(result, dryRun) {
     );
   }
 }
+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" : ""} from local preset`
+    );
+  }
+  if (result.skipped.length > 0) {
+    logger.log(
+      `Skipped ${result.skipped.length} file${result.skipped.length > 1 ? "s" : ""} (already exists)`
+    );
+  }
+}
 function warnMissingPackageJson(preset, installEnabled) {
   const tasks = [];
   if (preset.scripts) tasks.push("script injection");
@@ -1106,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");
@@ -1159,18 +1623,18 @@ var INIT_TOOLS = [
 ];
 
 // src/generators/init.ts
-import fs2 from "fs";
-import path5 from "path";
+import fs4 from "fs";
+import path6 from "path";
 function resolveSkillsDir() {
-  const entryDir = path5.dirname(process.argv[1] ?? "");
-  return path5.resolve(entryDir, "skills");
+  const entryDir = path6.dirname(process.argv[1] ?? "");
+  return path6.resolve(entryDir, "skills");
 }
 function listFilesRecursive(dir, base) {
-  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  const entries = fs4.readdirSync(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const childBase = `${base}/${entry.name}`;
-    const fullPath = path5.join(dir, entry.name);
+    const fullPath = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...listFilesRecursive(fullPath, childBase));
     } else {
@@ -1181,20 +1645,20 @@ function listFilesRecursive(dir, base) {
 }
 function generateInitSkills(targetBaseDir, cwd) {
   const skillsDir = resolveSkillsDir();
-  if (!fs2.existsSync(skillsDir)) {
+  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 = path5.resolve(cwd, targetBaseDir);
+  const targetPath = path6.resolve(cwd, targetBaseDir);
   try {
-    fs2.cpSync(skillsDir, targetPath, { recursive: true, force: true });
+    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 = fs2.existsSync(targetPath) ? listFilesRecursive(targetPath, targetBaseDir) : [];
+  const copiedFiles = fs4.existsSync(targetPath) ? listFilesRecursive(targetPath, targetBaseDir) : [];
   return { copiedFiles, targetDir: targetBaseDir };
 }
 
@@ -1232,18 +1696,18 @@ function registerInitCommand(program2) {
 }
 
 // src/utils/config.ts
-import fs3 from "fs";
-import os from "os";
-import path6 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 path6.join(os.homedir(), CONFIG_DIR, ENV_FILE);
+  return path7.join(os2.homedir(), CONFIG_DIR, ENV_FILE);
 }
 function getEnvConfig() {
   let content;
   try {
-    content = fs3.readFileSync(getEnvConfigPath(), "utf-8");
+    content = fs5.readFileSync(getEnvConfigPath(), "utf-8");
   } catch {
     return {};
   }
@@ -1266,7 +1730,7 @@ function setEnvConfig(data) {
 }
 function clearEnvConfig() {
   try {
-    fs3.unlinkSync(getEnvConfigPath());
+    fs5.unlinkSync(getEnvConfigPath());
   } catch {
   }
 }
@@ -2116,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) {
@@ -2176,7 +2595,7 @@ 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`;
@@ -2212,7 +2631,7 @@ function generateVscodeSettings(preset, opts) {
 }
 function generateVscodeExtensions(preset, opts) {
   if (opts.dryRun) return "created";
-  const extensions = opts.noStylelint ? preset.extensions().filter((ext) => ext !== STYLELINT_EXTENSION) : preset.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) {
@@ -2231,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) {
@@ -2248,29 +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("--stylelint", "Include 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 !== 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 (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(() => {
@@ -2279,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";

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@luxkit/cli",
-   "version": "1.1.0",
+   "version": "1.1.1",
    "description": "One-click project formatting & VSCode config CLI",
    "type": "module",
    "bin": {