vscode-autoconfig 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryo Kasai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# vscode-autoconfig
+
+[![CI](https://github.com/RKasai127/vscode-autoconfig/actions/workflows/ci.yml/badge.svg)](https://github.com/RKasai127/vscode-autoconfig/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/vscode-autoconfig.svg)](https://www.npmjs.com/package/vscode-autoconfig)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Analyze your project's manifest files (`package.json`, `requirements.txt`, `pyproject.toml`, ...) and generate `.vscode/settings.json` + `.vscode/extensions.json` recommendations — using a plain rule table.
+
+## Usage
+
+```bash
+npx vscode-autoconfig          # dry-run: shows what would change, writes nothing
+npx vscode-autoconfig --write  # applies the changes shown by the dry-run above
+```
+
+The dry-run is always the default. Nothing is ever written to disk unless you pass `--write` (or `-w`).
+
+### Example dry-run output
+
+```
+vscode-autoconfig — dry run (no files written)
+
+Detected
+  node    typescript (devDependency)
+  node    react (dependency)
+
+.vscode/settings.json (will be created)
+  + typescript.tsdk: "node_modules/typescript/lib"
+
+.vscode/extensions.json (will be created)
+  + dbaeumer.vscode-eslint
+  + dsznajder.es7-react-js-snippets
+
+2 settings, 2 extensions would be added.
+Run again with --write to apply.
+```
+
+## Flags
+
+| Flag                  | Description                                                                                                   |
+| --------------------- | ------------------------------------------------------------------------------------------------------------- |
+| `-w, --write`         | Apply changes. Without it, the command only previews changes (dry-run).                                       |
+| `--ecosystems <list>` | Comma-separated list of ecosystems to detect, e.g. `--ecosystems node`. Defaults to all supported ecosystems. |
+| `--rules <path>`      | Path to an external rule file (JSON or YAML). Merged with the built-in rules by default.                      |
+| `--no-builtin-rules`  | Ignore the built-in rules; use only the file passed via `--rules`.                                            |
+| `--json`              | Print machine-readable JSON instead of the terminal report.                                                   |
+
+There is intentionally no `--cwd` flag: the tool always operates on the current directory. `cd` into the project you want to configure before running it.
+
+## How it works
+
+1. **Detectors** scan the current directory (non-recursively — files inside `node_modules/`, `.venv/`, etc. are never inspected) and produce a flat list of _findings_: which manifest files exist, which dependencies/devDependencies are declared, which config files are present.
+2. **Rules** (plain JSON, see `src/rules/*.json`) declare a condition over findings and, when satisfied, contribute VS Code settings and/or extension recommendations.
+3. The matched rules are aggregated into one settings patch and one extension list, then merged into your existing `.vscode/settings.json` / `.vscode/extensions.json` — additively, never overwriting a value you already set.
+
+### Supported ecosystems (v1)
+
+- **Node.js** — `package.json` dependencies/devDependencies, plus common config files (`tsconfig.json`, ESLint/Prettier configs).
+- **Python** — `requirements.txt` and `pyproject.toml` (both PEP 621 `project.dependencies` and Poetry's `tool.poetry.dependencies`).
+
+## Merging behavior
+
+- Settings/extensions you already have are **never overwritten**. Only missing keys/extensions are added.
+- For `.vscode/extensions.json`, if you manually remove an ID from `recommendations`, it will simply be re-added the next time you run `--write` (deletions are not tracked). If you don't want an extension recommended again, add it to `unwantedRecommendations` yourself.
+- Rules are merged in a fixed order (built-in rules, then any `--rules` file). If two rules propose conflicting values for the same settings key, the first one wins and the rest are reported as skipped — nothing is silently overwritten.
+
+## External rule files (`--rules`)
+
+External rule files (JSON or YAML) let you extend or fully replace the built-in rule table without forking this tool. **Only use rule files from sources you trust** — treat them like any other executable configuration you'd run on your machine, and never run one handed to you by someone you don't trust.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,873 @@
+#!/usr/bin/env node
+
+// src/cli/args.ts
+import { Command } from "commander";
+function parseArgs(argv) {
+  const program = new Command();
+  program.name("vscode-autoconfig").description(
+    "Analyze your project's manifests and generate .vscode/settings.json + extensions.json recommendations"
+  ).option("-w, --write", "apply changes (default: dry-run only, writes nothing)", false).option("--ecosystems <list>", "comma-separated list of ecosystems to detect (node,python)").option(
+    "--rules <path>",
+    "path to an external rule file (JSON or YAML), merged with the built-in rules"
+  ).option("--no-builtin-rules", "ignore the built-in rules; use only the file passed via --rules").option("--json", "output machine-readable JSON instead of a terminal report", false).version("0.1.0");
+  program.parse(argv);
+  const opts = program.opts();
+  return {
+    write: opts.write,
+    ecosystems: opts.ecosystems ? opts.ecosystems.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    rules: opts.rules,
+    builtinRules: opts.builtinRules,
+    json: opts.json
+  };
+}
+
+// src/cli/run.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+
+// src/core/aggregate.ts
+function deepEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLanguageOverrideKey(key) {
+  return /^\[.+]$/.test(key);
+}
+function mergeKey(target, key, patchValue, depthRemaining, pathLabel, ruleId, owners, conflicts) {
+  if (!(key in target)) {
+    target[key] = structuredClone(patchValue);
+    owners.set(pathLabel, ruleId);
+    return;
+  }
+  const currentValue = target[key];
+  if (deepEqual(currentValue, patchValue)) return;
+  if (depthRemaining > 0 && isPlainObject(currentValue) && isPlainObject(patchValue)) {
+    for (const [subKey, subValue] of Object.entries(patchValue)) {
+      mergeKey(
+        currentValue,
+        subKey,
+        subValue,
+        depthRemaining - 1,
+        `${pathLabel}.${subKey}`,
+        ruleId,
+        owners,
+        conflicts
+      );
+    }
+    return;
+  }
+  const existingConflict = conflicts.get(pathLabel);
+  if (existingConflict) {
+    existingConflict.ignoredRuleIds.push(ruleId);
+  } else {
+    conflicts.set(pathLabel, {
+      key: pathLabel,
+      winningRuleId: owners.get(pathLabel) ?? ruleId,
+      ignoredRuleIds: [ruleId]
+    });
+  }
+}
+function aggregate(matchedRules) {
+  const settings = {};
+  const owners = /* @__PURE__ */ new Map();
+  const conflictsByKey = /* @__PURE__ */ new Map();
+  const extensionIds = /* @__PURE__ */ new Map();
+  for (const rule of matchedRules) {
+    for (const [key, value] of Object.entries(rule.settings ?? {})) {
+      const maxDepth = isLanguageOverrideKey(key) ? 2 : 1;
+      mergeKey(settings, key, value, maxDepth, key, rule.id, owners, conflictsByKey);
+    }
+    for (const extensionId of rule.extensions ?? []) {
+      const lower = extensionId.toLowerCase();
+      if (!extensionIds.has(lower)) {
+        extensionIds.set(lower, extensionId);
+      }
+    }
+  }
+  return {
+    matchedRuleIds: matchedRules.map((rule) => rule.id),
+    settings,
+    extensions: [...extensionIds.values()].sort((a, b) => a.localeCompare(b)),
+    conflicts: [...conflictsByKey.values()]
+  };
+}
+
+// src/core/engine.ts
+function isFindingMatcher(condition) {
+  return !("all" in condition) && !("any" in condition) && !("not" in condition);
+}
+function matchesFinding(matcher, finding) {
+  if (matcher.ecosystem !== void 0 && matcher.ecosystem !== finding.ecosystem) return false;
+  if (matcher.kind !== void 0 && matcher.kind !== finding.kind) return false;
+  if (matcher.name !== void 0 && matcher.name !== finding.name) return false;
+  return true;
+}
+function matchesCondition(condition, findings) {
+  if ("all" in condition) {
+    return condition.all.every((sub) => matchesCondition(sub, findings));
+  }
+  if ("any" in condition) {
+    return condition.any.some((sub) => matchesCondition(sub, findings));
+  }
+  if ("not" in condition) {
+    return !matchesCondition(condition.not, findings);
+  }
+  if (isFindingMatcher(condition)) {
+    return findings.some((finding) => matchesFinding(condition, finding));
+  }
+  return false;
+}
+function evaluateRules(findings, rules) {
+  return rules.filter((rule) => matchesCondition(rule.when, findings));
+}
+
+// src/detectors/node.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// src/detectors/types.ts
+var DetectorError = class extends Error {
+};
+
+// src/detectors/node.ts
+var NODE_CONFIG_FILENAMES = [
+  "tsconfig.json",
+  ".eslintrc",
+  ".eslintrc.json",
+  ".eslintrc.js",
+  ".eslintrc.cjs",
+  ".eslintrc.yml",
+  ".eslintrc.yaml",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  ".prettierrc",
+  ".prettierrc.json",
+  ".prettierrc.js",
+  ".prettierrc.cjs",
+  ".prettierrc.yml",
+  ".prettierrc.yaml",
+  "prettier.config.js",
+  "prettier.config.cjs"
+];
+var nodeDetector = {
+  ecosystem: "node",
+  detect(ctx) {
+    const findings = [];
+    const pkgPath = join(ctx.cwd, "package.json");
+    if (existsSync(pkgPath)) {
+      findings.push({ ecosystem: "node", kind: "manifestPresence", name: "package.json" });
+      let pkg;
+      try {
+        pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      } catch (error) {
+        throw new DetectorError(`Failed to parse package.json: ${error.message}`);
+      }
+      for (const name of Object.keys(pkg.dependencies ?? {})) {
+        findings.push({ ecosystem: "node", kind: "dependency", name });
+      }
+      for (const name of Object.keys(pkg.devDependencies ?? {})) {
+        findings.push({ ecosystem: "node", kind: "devDependency", name });
+      }
+      for (const name of Object.keys(pkg.scripts ?? {})) {
+        findings.push({ ecosystem: "node", kind: "scriptPresence", name });
+      }
+    }
+    for (const filename of NODE_CONFIG_FILENAMES) {
+      if (existsSync(join(ctx.cwd, filename))) {
+        findings.push({ ecosystem: "node", kind: "configFilePresence", name: filename });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/detectors/python.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { parse as parseToml } from "smol-toml";
+function parsePackageName(spec) {
+  const match = spec.trim().match(/^([A-Za-z0-9_.-]+)/);
+  return match?.[1] ?? null;
+}
+function parseRequirementsTxt(content) {
+  const names = [];
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.split("#")[0]?.trim() ?? "";
+    if (!line || line.startsWith("-")) continue;
+    const name = parsePackageName(line);
+    if (name) names.push(name);
+  }
+  return names;
+}
+function parsePyprojectToml(content) {
+  const doc = parseToml(content);
+  const dependencies = [];
+  const devDependencies = [];
+  const pep621Deps = doc.project?.dependencies;
+  if (Array.isArray(pep621Deps)) {
+    for (const spec of pep621Deps) {
+      if (typeof spec !== "string") continue;
+      const name = parsePackageName(spec);
+      if (name) dependencies.push(name);
+    }
+  }
+  const poetryDeps = doc.tool?.poetry?.dependencies ?? {};
+  for (const name of Object.keys(poetryDeps)) {
+    if (name === "python") continue;
+    dependencies.push(name);
+  }
+  const poetryDevDeps = doc.tool?.poetry?.group?.dev?.dependencies ?? doc.tool?.poetry?.["dev-dependencies"] ?? {};
+  for (const name of Object.keys(poetryDevDeps)) {
+    devDependencies.push(name);
+  }
+  return { dependencies, devDependencies };
+}
+var pythonDetector = {
+  ecosystem: "python",
+  detect(ctx) {
+    const findings = [];
+    const requirementsPath = join2(ctx.cwd, "requirements.txt");
+    if (existsSync2(requirementsPath)) {
+      findings.push({ ecosystem: "python", kind: "manifestPresence", name: "requirements.txt" });
+      const names = parseRequirementsTxt(readFileSync2(requirementsPath, "utf-8"));
+      for (const name of names) {
+        findings.push({ ecosystem: "python", kind: "dependency", name });
+      }
+    }
+    const pyprojectPath = join2(ctx.cwd, "pyproject.toml");
+    if (existsSync2(pyprojectPath)) {
+      findings.push({ ecosystem: "python", kind: "manifestPresence", name: "pyproject.toml" });
+      let parsed;
+      try {
+        parsed = parsePyprojectToml(readFileSync2(pyprojectPath, "utf-8"));
+      } catch (error) {
+        throw new DetectorError(`Failed to parse pyproject.toml: ${error.message}`);
+      }
+      for (const name of parsed.dependencies) {
+        findings.push({ ecosystem: "python", kind: "dependency", name });
+      }
+      for (const name of parsed.devDependencies) {
+        findings.push({ ecosystem: "python", kind: "devDependency", name });
+      }
+    }
+    return findings;
+  }
+};
+
+// src/detectors/registry.ts
+var detectorRegistry = [nodeDetector, pythonDetector];
+
+// src/detectors/collect.ts
+function collectFindings(ctx, options = {}, detectors = detectorRegistry) {
+  const findings = [];
+  const errors = [];
+  const activeDetectors = options.ecosystems ? detectors.filter((detector) => options.ecosystems.includes(detector.ecosystem)) : detectors;
+  for (const detector of activeDetectors) {
+    try {
+      findings.push(...detector.detect(ctx));
+    } catch (error) {
+      errors.push(`[${detector.ecosystem}] ${error.message}`);
+    }
+  }
+  return { findings, errors };
+}
+
+// src/vscode/jsonc.ts
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+function lineFromOffset(text, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === "\n") line++;
+  }
+  return line;
+}
+function parseJsonc(text) {
+  const rawErrors = [];
+  const value = parse(text, rawErrors, { allowTrailingComma: true });
+  const errors = rawErrors.map((error) => ({
+    message: printParseErrorCode(error.error),
+    line: lineFromOffset(text, error.offset)
+  }));
+  return { value: errors.length > 0 ? void 0 : value, errors };
+}
+var FORMATTING_OPTIONS = { insertSpaces: true, tabSize: 2, eol: "\n" };
+function setJsoncValue(text, path, value) {
+  const edits = modify(text, path, value, { formattingOptions: FORMATTING_OPTIONS });
+  return applyEdits(text, edits);
+}
+function insertJsoncArrayItem(text, path, index, value) {
+  const edits = modify(text, [...path, index], value, {
+    isArrayInsertion: true,
+    formattingOptions: FORMATTING_OPTIONS
+  });
+  return applyEdits(text, edits);
+}
+
+// src/vscode/extensions-merge.ts
+function readRecommendations(text) {
+  const parsed = parseJsonc(text);
+  return parsed.value?.recommendations ?? [];
+}
+function mergeExtensions(existingText, ids) {
+  const baseText = existingText && existingText.trim().length > 0 ? existingText : "{}";
+  const parsed = parseJsonc(baseText);
+  const unwanted = new Set(
+    (parsed.value?.unwantedRecommendations ?? []).map((id) => id.toLowerCase())
+  );
+  const seen = new Set((parsed.value?.recommendations ?? []).map((id) => id.toLowerCase()));
+  let text = baseText;
+  const added = [];
+  const alreadyPresent = [];
+  const skippedUnwanted = [];
+  for (const id of ids) {
+    const lower = id.toLowerCase();
+    if (seen.has(lower)) {
+      alreadyPresent.push(id);
+      continue;
+    }
+    if (unwanted.has(lower)) {
+      skippedUnwanted.push(id);
+      continue;
+    }
+    const currentLength = readRecommendations(text).length;
+    text = insertJsoncArrayItem(text, ["recommendations"], currentLength, id);
+    seen.add(lower);
+    added.push(id);
+  }
+  return { nextText: text, added, alreadyPresent, skippedUnwanted };
+}
+
+// src/vscode/settings-merge.ts
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLanguageOverrideKey2(key) {
+  return /^\[.+]$/.test(key);
+}
+function planNested(path, currentValue, patchValue, depthRemaining, additions, skipped) {
+  if (depthRemaining <= 0 || !isPlainObject2(currentValue) || !isPlainObject2(patchValue)) {
+    skipped[path.join(".")] = "existing";
+    return;
+  }
+  for (const [subKey, subValue] of Object.entries(patchValue)) {
+    const subPath = [...path, subKey];
+    if (!(subKey in currentValue)) {
+      additions.push({ path: subPath, value: subValue });
+      continue;
+    }
+    planNested(subPath, currentValue[subKey], subValue, depthRemaining - 1, additions, skipped);
+  }
+}
+function planSettingsPatch(current, patch) {
+  const additions = [];
+  const skipped = {};
+  for (const [key, value] of Object.entries(patch)) {
+    if (!(key in current)) {
+      additions.push({ path: [key], value });
+      continue;
+    }
+    const maxDepth = isLanguageOverrideKey2(key) ? 2 : 1;
+    planNested([key], current[key], value, maxDepth, additions, skipped);
+  }
+  return { additions, skipped };
+}
+function mergeSettings(existingText, patch) {
+  const baseText = existingText && existingText.trim().length > 0 ? existingText : "{}";
+  const parsed = parseJsonc(baseText);
+  const current = parsed.value ?? {};
+  const { additions, skipped } = planSettingsPatch(current, patch);
+  let text = baseText;
+  const added = {};
+  for (const addition of additions) {
+    text = setJsoncValue(text, addition.path, addition.value);
+    added[addition.path.join(".")] = addition.value;
+  }
+  return { nextText: text, added, skipped };
+}
+
+// src/diff/preview.ts
+function checkParseError(text) {
+  if (text === void 0) return void 0;
+  const parsed = parseJsonc(text);
+  if (parsed.errors.length === 0) return void 0;
+  const first = parsed.errors[0];
+  return { line: first.line, message: first.message };
+}
+function buildPreview(params) {
+  const {
+    mode,
+    findings,
+    ecosystems,
+    aggregated,
+    settingsPath,
+    extensionsPath,
+    settingsText,
+    extensionsText
+  } = params;
+  const files = [];
+  const skippedFiles = [];
+  let settingsAdded = {};
+  let settingsSkipped = {};
+  const settingsError = checkParseError(settingsText);
+  if (settingsError) {
+    skippedFiles.push({
+      file: settingsPath,
+      reason: `Syntax error near line ${settingsError.line} of settings.json (${settingsError.message}). This file was skipped.`,
+      line: settingsError.line
+    });
+  } else {
+    const result = mergeSettings(settingsText, aggregated.settings);
+    settingsAdded = result.added;
+    settingsSkipped = result.skipped;
+    files.push({
+      path: settingsPath,
+      label: "settings.json",
+      existed: settingsText !== void 0,
+      before: settingsText ?? "",
+      after: result.nextText
+    });
+  }
+  let extensionsAdded = [];
+  let extensionsAlreadyPresent = [];
+  let extensionsUnwanted = [];
+  const extensionsError = checkParseError(extensionsText);
+  if (extensionsError) {
+    skippedFiles.push({
+      file: extensionsPath,
+      reason: `Syntax error near line ${extensionsError.line} of extensions.json (${extensionsError.message}). This file was skipped.`,
+      line: extensionsError.line
+    });
+  } else {
+    const result = mergeExtensions(extensionsText, aggregated.extensions);
+    extensionsAdded = result.added;
+    extensionsAlreadyPresent = result.alreadyPresent;
+    extensionsUnwanted = result.skippedUnwanted;
+    files.push({
+      path: extensionsPath,
+      label: "extensions.json",
+      existed: extensionsText !== void 0,
+      before: extensionsText ?? "",
+      after: result.nextText
+    });
+  }
+  const json = {
+    mode,
+    detected: { ecosystems, findings },
+    matchedRules: aggregated.matchedRuleIds,
+    settings: { added: settingsAdded, skipped: settingsSkipped },
+    extensions: {
+      added: extensionsAdded,
+      alreadyPresent: extensionsAlreadyPresent,
+      unwanted: extensionsUnwanted
+    },
+    conflicts: aggregated.conflicts,
+    skippedFiles
+  };
+  return { json, files };
+}
+
+// src/diff/render.ts
+import { diffLines } from "diff";
+import pc from "picocolors";
+function renderJson(json) {
+  return JSON.stringify(json, null, 2);
+}
+function renderTerminal(json, files) {
+  const lines = [];
+  const title = json.mode === "dry-run" ? "vscode-autoconfig \u2014 dry run (no files written)" : "vscode-autoconfig \u2014 applying changes";
+  lines.push(pc.bold(title));
+  lines.push("");
+  if (json.detected.findings.length > 0) {
+    lines.push(pc.bold("Detected"));
+    for (const finding of json.detected.findings) {
+      lines.push(`  ${finding.ecosystem.padEnd(7)} ${finding.name} (${finding.kind})`);
+    }
+    lines.push("");
+  }
+  for (const file of files) {
+    if (file.before === file.after) continue;
+    lines.push(pc.bold(`${file.path}${file.existed ? "" : " (will be created)"}`));
+    for (const part of diffLines(file.before, file.after)) {
+      if (part.removed) continue;
+      const prefix = part.added ? "+" : " ";
+      const colorize = part.added ? pc.green : (s) => s;
+      for (const line of part.value.split("\n")) {
+        if (line.length === 0) continue;
+        lines.push(colorize(`  ${prefix} ${line}`));
+      }
+    }
+    lines.push("");
+  }
+  if (json.conflicts.length > 0) {
+    lines.push(pc.yellow("Conflicts (first matching rule wins, no overwrite):"));
+    for (const conflict of json.conflicts) {
+      lines.push(
+        `  ${conflict.key}: "${conflict.winningRuleId}" wins over ${conflict.ignoredRuleIds.join(", ")}`
+      );
+    }
+    lines.push("");
+  }
+  if (json.skippedFiles.length > 0) {
+    lines.push(pc.red("Skipped files:"));
+    for (const skipped of json.skippedFiles) {
+      lines.push(`  ${skipped.file}: ${skipped.reason}`);
+    }
+    lines.push("");
+  }
+  const settingsAddedCount = Object.keys(json.settings.added).length;
+  const extensionsAddedCount = json.extensions.added.length;
+  lines.push(`${settingsAddedCount} settings, ${extensionsAddedCount} extensions would be added.`);
+  if (json.mode === "dry-run") {
+    lines.push("Run again with --write to apply.");
+  }
+  return lines.join("\n");
+}
+
+// src/rules/loader.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { extname } from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/rules/schema.ts
+import { z } from "zod";
+
+// src/core/types.ts
+var RULE_SCHEMA_VERSION = 1;
+
+// src/rules/schema.ts
+var ecosystemSchema = z.enum(["node", "python"]);
+var findingKindSchema = z.enum([
+  "dependency",
+  "devDependency",
+  "manifestPresence",
+  "configFilePresence",
+  "scriptPresence"
+]);
+var findingMatcherSchema = z.object({
+  ecosystem: ecosystemSchema.optional(),
+  kind: findingKindSchema.optional(),
+  name: z.string().optional()
+}).strict();
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema)
+  ])
+);
+var ruleConditionSchema = z.lazy(
+  () => z.union([
+    z.object({ all: z.array(ruleConditionSchema) }).strict(),
+    z.object({ any: z.array(ruleConditionSchema) }).strict(),
+    z.object({ not: ruleConditionSchema }).strict(),
+    findingMatcherSchema
+  ])
+);
+var ruleSchema = z.object({
+  id: z.string().min(1),
+  description: z.string().optional(),
+  when: ruleConditionSchema,
+  settings: z.record(jsonValueSchema).optional(),
+  extensions: z.array(z.string()).optional()
+});
+var ruleFileSchema = z.object({
+  schemaVersion: z.number().int(),
+  rules: z.array(ruleSchema)
+}).superRefine((file, ctx) => {
+  if (file.schemaVersion !== RULE_SCHEMA_VERSION) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["schemaVersion"],
+      message: `This rule file has schemaVersion ${file.schemaVersion}, but this tool only supports version ${RULE_SCHEMA_VERSION}.`
+    });
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const [index, rule] of file.rules.entries()) {
+    if (seenIds.has(rule.id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["rules", index, "id"],
+        message: `Rule id "${rule.id}" is duplicated. Rule ids must be unique.`
+      });
+    }
+    seenIds.add(rule.id);
+  }
+});
+
+// src/rules/node.json
+var node_default = {
+  schemaVersion: 1,
+  rules: [
+    {
+      id: "node-typescript-presence",
+      description: "TypeScript project detected via tsconfig.json or a typescript devDependency",
+      when: {
+        any: [
+          { ecosystem: "node", kind: "configFilePresence", name: "tsconfig.json" },
+          { ecosystem: "node", kind: "devDependency", name: "typescript" }
+        ]
+      },
+      settings: {
+        "js/ts.tsdk.path": "./node_modules/typescript/lib"
+      },
+      extensions: ["dbaeumer.vscode-eslint"]
+    },
+    {
+      id: "node-eslint-config-presence",
+      description: "ESLint config file or eslint devDependency detected",
+      when: {
+        any: [
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc.json" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc.js" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc.cjs" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc.yml" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".eslintrc.yaml" },
+          { ecosystem: "node", kind: "configFilePresence", name: "eslint.config.js" },
+          { ecosystem: "node", kind: "configFilePresence", name: "eslint.config.mjs" },
+          { ecosystem: "node", kind: "configFilePresence", name: "eslint.config.cjs" },
+          { ecosystem: "node", kind: "configFilePresence", name: "eslint.config.ts" },
+          { ecosystem: "node", kind: "devDependency", name: "eslint" }
+        ]
+      },
+      settings: {
+        "eslint.enable": true,
+        "editor.codeActionsOnSave": { "source.fixAll.eslint": "explicit" }
+      },
+      extensions: ["dbaeumer.vscode-eslint"]
+    },
+    {
+      id: "node-prettier-config-presence",
+      description: "Prettier config file or prettier devDependency detected",
+      when: {
+        any: [
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc.json" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc.js" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc.cjs" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc.yml" },
+          { ecosystem: "node", kind: "configFilePresence", name: ".prettierrc.yaml" },
+          { ecosystem: "node", kind: "configFilePresence", name: "prettier.config.js" },
+          { ecosystem: "node", kind: "configFilePresence", name: "prettier.config.cjs" },
+          { ecosystem: "node", kind: "devDependency", name: "prettier" }
+        ]
+      },
+      settings: {
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+      },
+      extensions: ["esbenp.prettier-vscode"]
+    },
+    {
+      id: "node-react-dependency",
+      description: "React dependency detected",
+      when: { ecosystem: "node", kind: "dependency", name: "react" },
+      extensions: ["dsznajder.es7-react-js-snippets"]
+    },
+    {
+      id: "node-vue-dependency",
+      description: "Vue dependency detected",
+      when: { ecosystem: "node", kind: "dependency", name: "vue" },
+      extensions: ["Vue.volar"]
+    },
+    {
+      id: "node-next-dependency",
+      description: "Next.js dependency detected",
+      when: { ecosystem: "node", kind: "dependency", name: "next" },
+      extensions: ["dsznajder.es7-react-js-snippets"]
+    },
+    {
+      id: "node-tailwind-dependency",
+      description: "Tailwind CSS dependency detected",
+      when: { ecosystem: "node", kind: "dependency", name: "tailwindcss" },
+      extensions: ["bradlc.vscode-tailwindcss"]
+    }
+  ]
+};
+
+// src/rules/python.json
+var python_default = {
+  schemaVersion: 1,
+  rules: [
+    {
+      id: "python-manifest-presence",
+      description: "requirements.txt or pyproject.toml detected",
+      when: {
+        any: [
+          { ecosystem: "python", kind: "manifestPresence", name: "requirements.txt" },
+          { ecosystem: "python", kind: "manifestPresence", name: "pyproject.toml" }
+        ]
+      },
+      extensions: ["ms-python.python", "ms-python.vscode-pylance"]
+    },
+    {
+      id: "python-black-dependency",
+      description: "black dependency detected",
+      when: {
+        any: [
+          { ecosystem: "python", kind: "dependency", name: "black" },
+          { ecosystem: "python", kind: "devDependency", name: "black" }
+        ]
+      },
+      settings: {
+        "[python]": {
+          "editor.defaultFormatter": "ms-python.black-formatter",
+          "editor.formatOnSave": true
+        }
+      },
+      extensions: ["ms-python.black-formatter"]
+    },
+    {
+      id: "python-ruff-dependency",
+      description: "ruff dependency detected",
+      when: {
+        any: [
+          { ecosystem: "python", kind: "dependency", name: "ruff" },
+          { ecosystem: "python", kind: "devDependency", name: "ruff" }
+        ]
+      },
+      settings: {
+        "[python]": {
+          "editor.codeActionsOnSave": { "source.fixAll.ruff": true }
+        }
+      },
+      extensions: ["charliermarsh.ruff"]
+    },
+    {
+      id: "python-mypy-dependency",
+      description: "mypy dependency detected",
+      when: {
+        any: [
+          { ecosystem: "python", kind: "dependency", name: "mypy" },
+          { ecosystem: "python", kind: "devDependency", name: "mypy" }
+        ]
+      },
+      extensions: ["ms-python.mypy-type-checker"]
+    }
+  ]
+};
+
+// src/rules/loader.ts
+var RuleFileValidationError = class extends Error {
+};
+function validate(source, raw) {
+  const result = ruleFileSchema.safeParse(raw);
+  if (!result.success) {
+    const messages = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+    throw new RuleFileValidationError(`Rule file "${source}" failed validation:
+${messages}`);
+  }
+  return result.data.rules;
+}
+function loadBuiltinRules() {
+  return [...validate("node.json", node_default), ...validate("python.json", python_default)];
+}
+function loadExternalRules(path) {
+  const raw = readFileSync3(path, "utf-8");
+  const ext = extname(path).toLowerCase();
+  const parsed = ext === ".yaml" || ext === ".yml" ? parseYaml(raw) : JSON.parse(raw);
+  return validate(path, parsed);
+}
+function checkForDuplicateIds(rules) {
+  const ruleIds = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (ruleIds.has(rule.id)) {
+      throw new RuleFileValidationError(
+        `Rule id "${rule.id}" is duplicated across the built-in and external rule sets. Rule ids must be unique.`
+      );
+    }
+    ruleIds.add(rule.id);
+  }
+}
+function loadRules({ externalPath, useBuiltinRules = true } = {}) {
+  const externalRules = externalPath ? loadExternalRules(externalPath) : [];
+  const rules = useBuiltinRules ? [...loadBuiltinRules(), ...externalRules] : externalRules;
+  checkForDuplicateIds(rules);
+  return rules;
+}
+
+// src/vscode/paths.ts
+import { join as join3 } from "path";
+function vscodeDir(cwd) {
+  return join3(cwd, ".vscode");
+}
+function settingsJsonPath(cwd) {
+  return join3(cwd, ".vscode", "settings.json");
+}
+function extensionsJsonPath(cwd) {
+  return join3(cwd, ".vscode", "extensions.json");
+}
+
+// src/cli/run.ts
+function run(options) {
+  try {
+    const rules = loadRules({
+      externalPath: options.rulesPath,
+      useBuiltinRules: options.builtinRules
+    });
+    const { findings, errors } = collectFindings(
+      { cwd: options.cwd },
+      { ecosystems: options.ecosystems }
+    );
+    const matchedRules = evaluateRules(findings, rules);
+    const aggregated = aggregate(matchedRules);
+    const settingsPath = settingsJsonPath(options.cwd);
+    const extensionsPath = extensionsJsonPath(options.cwd);
+    const settingsText = existsSync3(settingsPath) ? readFileSync4(settingsPath, "utf-8") : void 0;
+    const extensionsText = existsSync3(extensionsPath) ? readFileSync4(extensionsPath, "utf-8") : void 0;
+    const ecosystemsDetected = [...new Set(findings.map((s) => s.ecosystem))];
+    const preview = buildPreview({
+      mode: options.write ? "write" : "dry-run",
+      findings,
+      ecosystems: ecosystemsDetected,
+      aggregated,
+      settingsPath,
+      extensionsPath,
+      settingsText,
+      extensionsText
+    });
+    const hasDiff = Object.keys(preview.json.settings.added).length > 0 || preview.json.extensions.added.length > 0;
+    const hasErrors = errors.length > 0 || preview.json.skippedFiles.length > 0;
+    const reportLines = errors.map((error) => `Error: ${error}`);
+    const report = options.json ? renderJson(preview.json) : renderTerminal(preview.json, preview.files);
+    const outputLines = [...reportLines, report];
+    if (options.write && hasDiff) {
+      mkdirSync(vscodeDir(options.cwd), { recursive: true });
+      for (const file of preview.files) {
+        if (file.before !== file.after) {
+          writeFileSync(file.path, file.after, "utf-8");
+        }
+      }
+    }
+    return { exitCode: hasErrors ? 2 : hasDiff ? 1 : 0, output: outputLines.join("\n") };
+  } catch (error) {
+    if (error instanceof RuleFileValidationError) {
+      return { exitCode: 2, output: `Error: ${error.message}` };
+    }
+    throw error;
+  }
+}
+
+// src/cli.ts
+async function main() {
+  const cliArgs = parseArgs(process.argv);
+  const runResutl = run({
+    cwd: process.cwd(),
+    write: cliArgs.write,
+    ecosystems: cliArgs.ecosystems,
+    rulesPath: cliArgs.rules,
+    builtinRules: cliArgs.builtinRules,
+    json: cliArgs.json
+  });
+  console.log(runResutl.output);
+  process.exitCode = runResutl.exitCode;
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 2;
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "vscode-autoconfig",
+  "version": "0.1.0",
+  "description": "Analyze your project's manifests and auto-generate .vscode/settings.json and .vscode/extensions.json via rule-based detection (no AI/LLM).",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "vscode-autoconfig": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepublishOnly": "npm run typecheck && npm run lint && npm test && npm run build"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "diff": "^5.2.0",
+    "jsonc-parser": "^3.3.1",
+    "picocolors": "^1.0.1",
+    "smol-toml": "^1.3.0",
+    "yaml": "^2.5.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.7.0",
+    "@types/diff": "^5.2.1",
+    "@types/node": "^20.14.0",
+    "eslint": "^9.7.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.1.0",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^2.0.0"
+  }
+}