@dimensional-innovations/tool-config 5.0.0 → 5.0.1

package/dist/cli/index.js

@@ -0,0 +1,1812 @@
+#!/usr/bin/env node
+import { existsSync, rmSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import pc from 'picocolors';
+import prompts from 'prompts';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/types.ts
+var ConfigError;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    ConfigError = class _ConfigError extends Error {
+      context;
+      constructor(message, context) {
+        super(message);
+        this.name = "ConfigError";
+        this.context = context;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, _ConfigError);
+        }
+      }
+    };
+  }
+});
+function detectTypeChecker(framework, preference = "auto", cwd = process.cwd()) {
+  if (preference === "legacy") {
+    return framework === "vue" ? "vue-tsc" : "tsc";
+  }
+  if (preference === "modern") {
+    return "tsgo";
+  }
+  if (preference === "auto") {
+    if (framework === "vue") {
+      const hasVueTsc = hasPackageInstalled("vue-tsc", cwd);
+      if (hasVueTsc) return "vue-tsc";
+      console.warn(
+        "\u26A0\uFE0F  Vue project detected but vue-tsc not found.\n   Install with: npm install -D vue-tsc\n   Falling back to tsgo/tsc (won't check .vue files)"
+      );
+    }
+    const hasTsgo = hasPackageInstalled("@typescript/native-preview", cwd);
+    if (hasTsgo) {
+      return "tsgo";
+    }
+    return "tsc";
+  }
+  throw new ConfigError(`Unknown checker preference: "${preference}"`, {
+    received: preference,
+    validOptions: ["auto", "modern", "legacy"]
+  });
+}
+function hasPackageInstalled(packageName, cwd) {
+  try {
+    const packagePath = join(cwd, "node_modules", packageName, "package.json");
+    return existsSync(packagePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: Error checking for ${packageName}: ${message}`);
+    return false;
+  }
+}
+function getTypeCheckCommand(checker, options = {}) {
+  const { watch = false, noEmit = true, project = "." } = options;
+  const baseCmd = checker;
+  const flags = [];
+  if (noEmit) flags.push("--noEmit");
+  if (watch) flags.push("--watch");
+  if (project !== ".") flags.push(`-p ${project}`);
+  return `${baseCmd} ${flags.join(" ")}`.trim();
+}
+var init_checker_detection = __esm({
+  "src/tools/typescript/checker-detection.ts"() {
+    init_types();
+  }
+});
+
+// src/tools/typescript/presets/base.ts
+var basePreset, base_default;
+var init_base = __esm({
+  "src/tools/typescript/presets/base.ts"() {
+    basePreset = {
+      compilerOptions: {
+        // Language and Environment
+        target: "ES2022",
+        lib: ["ES2022"],
+        // Modules
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        resolveJsonModule: true,
+        // Emit
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true,
+        removeComments: false,
+        // Interop Constraints
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        forceConsistentCasingInFileNames: true,
+        isolatedModules: true,
+        // Type Checking (Strict Mode)
+        strict: true,
+        noImplicitAny: true,
+        strictNullChecks: true,
+        strictFunctionTypes: true,
+        strictBindCallApply: true,
+        strictPropertyInitialization: true,
+        noImplicitThis: true,
+        alwaysStrict: true,
+        // Additional Checks
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noImplicitReturns: true,
+        noFallthroughCasesInSwitch: true,
+        noUncheckedIndexedAccess: true,
+        noImplicitOverride: true,
+        noPropertyAccessFromIndexSignature: false,
+        // Completeness
+        skipLibCheck: true,
+        // Faster, skip checking .d.ts files
+        // Advanced
+        allowUnusedLabels: false,
+        allowUnreachableCode: false
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist", "build", "out", "coverage", ".nyc_output"]
+    };
+    base_default = basePreset;
+  }
+});
+
+// src/tools/typescript/presets/environments/browser.ts
+var browserPreset, browser_default;
+var init_browser = __esm({
+  "src/tools/typescript/presets/environments/browser.ts"() {
+    browserPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        target: "ES2020"
+        // Good browser support
+      }
+    };
+    browser_default = browserPreset;
+  }
+});
+
+// src/tools/typescript/presets/environments/node.ts
+var nodePreset, node_default;
+var init_node = __esm({
+  "src/tools/typescript/presets/environments/node.ts"() {
+    nodePreset = {
+      compilerOptions: {
+        lib: ["ES2024"],
+        target: "ES2024",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        types: ["node"]
+      }
+    };
+    node_default = nodePreset;
+  }
+});
+
+// src/tools/typescript/presets/environments/universal.ts
+var universalPreset, universal_default;
+var init_universal = __esm({
+  "src/tools/typescript/presets/environments/universal.ts"() {
+    universalPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        target: "ES2022",
+        types: ["node"]
+      }
+    };
+    universal_default = universalPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/angular.ts
+var angularPreset, angular_default;
+var init_angular = __esm({
+  "src/tools/typescript/presets/frameworks/angular.ts"() {
+    angularPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true
+      }
+    };
+    angular_default = angularPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/astro.ts
+var astroPreset, astro_default;
+var init_astro = __esm({
+  "src/tools/typescript/presets/frameworks/astro.ts"() {
+    astroPreset = {
+      compilerOptions: {
+        jsx: "react-jsx",
+        // Astro uses React-style JSX
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        types: ["astro/client"]
+      }
+    };
+    astro_default = astroPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/electron.ts
+function createElectronPreset(renderer = "vue") {
+  const rendererExtensions = renderer === "vue" ? ["src/renderer/**/*.vue"] : [];
+  const root = {
+    files: [],
+    references: [{ path: "./tsconfig.node.json" }, { path: "./tsconfig.web.json" }]
+  };
+  const node = {
+    $schema: "https://json.schemastore.org/tsconfig",
+    include: ["electron.vite.config.*", "package.json", "src/main/*", "src/preload/*"],
+    compilerOptions: {
+      composite: true,
+      target: "ES2024",
+      lib: ["ES2024", "ESNext"],
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      types: ["electron-vite/node"],
+      baseUrl: ".",
+      paths: {
+        "@/*": ["src/*"],
+        "@main/*": ["src/main/*"],
+        "@preload/*": ["src/preload/*"]
+      },
+      resolveJsonModule: true
+    }
+  };
+  const web = {
+    $schema: "https://json.schemastore.org/tsconfig",
+    include: [
+      "src/renderer/env.d.ts",
+      "src/renderer/**/*",
+      ...rendererExtensions,
+      "src/preload/*.d.ts",
+      "package.json"
+    ],
+    compilerOptions: {
+      composite: true,
+      target: "ES2024",
+      lib: ["ES2024", "ESNext", "DOM", "DOM.Iterable"],
+      baseUrl: ".",
+      paths: {
+        "@/*": ["src/*"],
+        "@renderer/*": ["src/renderer/*"],
+        "@main/*": ["src/main/*"],
+        "@preload/*": ["src/preload/*"]
+      },
+      strict: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      noUncheckedIndexedAccess: true
+    }
+  };
+  const tests = {
+    $schema: "https://json.schemastore.org/tsconfig",
+    include: ["tests/**/*", "src/renderer/**/*.vue", "src/renderer/env.d.ts"],
+    compilerOptions: {
+      composite: true,
+      baseUrl: ".",
+      paths: {
+        "@/*": ["src/*"],
+        "@renderer/*": ["src/renderer/*"],
+        "@main/*": ["src/main/*"],
+        "@preload/*": ["src/preload/*"],
+        "@tests/*": ["tests/*"],
+        "@unit/*": ["tests/unit/*"],
+        "@integration/*": ["tests/integration/*"],
+        "@fixtures/*": ["tests/fixtures/*"],
+        "@setup/*": ["tests/setup/*"]
+      },
+      types: ["vitest/globals", "@playwright/test"],
+      strict: false
+    }
+  };
+  return { root, node, web, tests };
+}
+var init_electron = __esm({
+  "src/tools/typescript/presets/frameworks/electron.ts"() {
+  }
+});
+
+// src/tools/typescript/presets/frameworks/node.ts
+var nodePreset2, node_default2;
+var init_node2 = __esm({
+  "src/tools/typescript/presets/frameworks/node.ts"() {
+    nodePreset2 = {
+      compilerOptions: {
+        lib: ["ES2022"],
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        types: ["node"]
+      }
+    };
+    node_default2 = nodePreset2;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/react.ts
+var reactPreset, react_default;
+var init_react = __esm({
+  "src/tools/typescript/presets/frameworks/react.ts"() {
+    reactPreset = {
+      compilerOptions: {
+        jsx: "react-jsx",
+        // Modern React 17+ automatic runtime
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      }
+    };
+    react_default = reactPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/solid.ts
+var solidPreset, solid_default;
+var init_solid = __esm({
+  "src/tools/typescript/presets/frameworks/solid.ts"() {
+    solidPreset = {
+      compilerOptions: {
+        jsx: "preserve",
+        // Solid uses its own JSX transform
+        jsxImportSource: "solid-js",
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      }
+    };
+    solid_default = solidPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/svelte.ts
+var sveltePreset, svelte_default;
+var init_svelte = __esm({
+  "src/tools/typescript/presets/frameworks/svelte.ts"() {
+    sveltePreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        types: ["svelte"]
+      }
+    };
+    svelte_default = sveltePreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/vanilla.ts
+var vanillaPreset, vanilla_default;
+var init_vanilla = __esm({
+  "src/tools/typescript/presets/frameworks/vanilla.ts"() {
+    vanillaPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      }
+    };
+    vanilla_default = vanillaPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/vue.ts
+var vuePreset, vue_default;
+var init_vue = __esm({
+  "src/tools/typescript/presets/frameworks/vue.ts"() {
+    vuePreset = {
+      compilerOptions: {
+        jsx: "preserve",
+        // Vue compiler handles JSX transformation
+        jsxImportSource: "vue",
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        types: ["vite/client"]
+        // Common for Vue + Vite projects
+      },
+      // Vue-specific options (for vue-tsc)
+      vueCompilerOptions: {
+        extensions: [".vue"],
+        vitePressExtensions: [".md"]
+      }
+    };
+    vue_default = vuePreset;
+  }
+});
+function readPackageJson(cwd) {
+  const packagePath = join(cwd, "package.json");
+  if (!existsSync(packagePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(packagePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: Failed to read package.json: ${message}`);
+    return null;
+  }
+}
+function getAllDependencies(pkg) {
+  if (!pkg) {
+    return {};
+  }
+  return {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+}
+var init_package_reader = __esm({
+  "src/core/package-reader.ts"() {
+  }
+});
+function detectReactMetaFramework(deps) {
+  return !!(deps.next || deps["@next/core"] || deps.remix || deps["@remix-run/react"] || deps["@remix-run/node"] || deps.gatsby || deps["gatsby-link"]);
+}
+function detectVueMetaFramework(deps) {
+  return !!(deps.nuxt || deps["nuxt3"]);
+}
+function detectSvelteMetaFramework(deps) {
+  return !!deps["@sveltejs/kit"];
+}
+function detectBaseFramework(deps) {
+  if (deps.react || deps["react-dom"]) return "react";
+  if (deps.vue || deps["@vue/runtime-core"] || deps["vue-router"] || deps.pinia) return "vue";
+  if (deps["@angular/core"]) return "angular";
+  if (deps.svelte) return "svelte";
+  if (deps["solid-js"]) return "solid";
+  if (deps.astro) return "astro";
+  return null;
+}
+function isNodeBackend(pkg, deps, cwd) {
+  if (pkg.type !== "module") return false;
+  const hasNodeFramework = !!(deps.express || deps.fastify || deps.koa || deps["@hapi/hapi"]);
+  const hasServerFiles = existsSync(join(cwd, "server.js")) || existsSync(join(cwd, "app.js")) || existsSync(join(cwd, "index.js")) && existsSync(join(cwd, "routes"));
+  return hasNodeFramework || hasServerFiles;
+}
+function detectFramework(cwd = process.cwd()) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) {
+    console.warn("Could not find package.json, defaulting to vanilla JavaScript");
+    return "vanilla";
+  }
+  const deps = getAllDependencies(pkg);
+  if (detectReactMetaFramework(deps)) return "react";
+  if (detectVueMetaFramework(deps)) return "vue";
+  if (detectSvelteMetaFramework(deps)) return "svelte";
+  const baseFramework = detectBaseFramework(deps);
+  if (baseFramework) return baseFramework;
+  if (isNodeBackend(pkg, deps, cwd)) return "node";
+  return "vanilla";
+}
+function detectEnvironment(framework, cwd = process.cwd()) {
+  if (framework === "node") {
+    return "node";
+  }
+  if (["react", "vue", "svelte", "solid", "angular"].includes(framework)) {
+    return "browser";
+  }
+  if (framework === "astro") {
+    return "universal";
+  }
+  const hasServerCode = existsSync(join(cwd, "server")) || existsSync(join(cwd, "api")) || existsSync(join(cwd, "backend"));
+  if (hasServerCode) {
+    return "universal";
+  }
+  return "browser";
+}
+function detectTypeScript(cwd = process.cwd()) {
+  if (existsSync(join(cwd, "tsconfig.json"))) {
+    return true;
+  }
+  const pkg = readPackageJson(cwd);
+  if (!pkg) return false;
+  return !!(pkg.dependencies?.typescript || pkg.devDependencies?.typescript);
+}
+function detectGitProvider(cwd = process.cwd()) {
+  const pkg = readPackageJson(cwd);
+  if (pkg?.repository) {
+    const repoUrl = typeof pkg.repository === "string" ? pkg.repository : pkg.repository.url || "";
+    if (repoUrl.includes("gitlab.com")) return "gitlab";
+    if (repoUrl.includes("github.com")) return "github";
+    if (repoUrl.includes("bitbucket.org")) return "bitbucket";
+    return null;
+  }
+  try {
+    const remoteUrl = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    if (remoteUrl.includes("gitlab.com")) return "gitlab";
+    if (remoteUrl.includes("github.com")) return "github";
+    if (remoteUrl.includes("bitbucket.org")) return "bitbucket";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: Could not detect git provider from remote: ${message}`);
+  }
+  return null;
+}
+function detectCssType(cwd = process.cwd()) {
+  const pkg = readPackageJson(cwd);
+  const results = {
+    preprocessor: null,
+    // 'scss', 'sass', 'less', null
+    tailwind: false,
+    modules: false,
+    postcss: false
+  };
+  const hasSass = pkg?.dependencies?.sass || pkg?.devDependencies?.sass || pkg?.dependencies?.["node-sass"] || pkg?.devDependencies?.["node-sass"] || pkg?.dependencies?.["sass-embedded"] || pkg?.devDependencies?.["sass-embedded"];
+  if (hasSass) {
+    results.preprocessor = "scss";
+  }
+  const hasLess = pkg?.dependencies?.less || pkg?.devDependencies?.less;
+  if (hasLess && !hasSass) {
+    results.preprocessor = "less";
+  }
+  const hasTailwind = pkg?.dependencies?.tailwindcss || pkg?.devDependencies?.tailwindcss;
+  if (hasTailwind) {
+    results.tailwind = existsSync(join(cwd, "tailwind.config.js")) || existsSync(join(cwd, "tailwind.config.ts")) || existsSync(join(cwd, "tailwind.config.mjs")) || existsSync(join(cwd, "tailwind.config.cjs"));
+  }
+  results.postcss = existsSync(join(cwd, "postcss.config.js")) || existsSync(join(cwd, "postcss.config.cjs")) || existsSync(join(cwd, "postcss.config.mjs")) || existsSync(join(cwd, ".postcssrc")) || existsSync(join(cwd, ".postcssrc.json"));
+  return results;
+}
+function detectElectron(cwd = process.cwd()) {
+  const pkg = readPackageJson(cwd);
+  if (!pkg) return false;
+  const deps = getAllDependencies(pkg);
+  return !!(deps.electron || deps["@electron-toolkit/utils"] || deps["@electron-toolkit/preload"]);
+}
+function autoDetect(cwd = process.cwd()) {
+  const framework = detectFramework(cwd);
+  const environment = detectEnvironment(framework, cwd);
+  const typescript = detectTypeScript(cwd);
+  const gitProvider = detectGitProvider(cwd);
+  const cssType = detectCssType(cwd);
+  const electron = detectElectron(cwd);
+  return {
+    framework,
+    environment,
+    typescript,
+    gitProvider,
+    cssType,
+    electron
+  };
+}
+var init_detectors = __esm({
+  "src/core/detectors.ts"() {
+    init_package_reader();
+  }
+});
+
+// src/tools/typescript/index.ts
+var typescript_exports = {};
+__export(typescript_exports, {
+  createTypescriptConfig: () => createTypescriptConfig,
+  default: () => typescript_default
+});
+async function createTypescriptConfig(options = {}) {
+  const {
+    framework: frameworkOption = "auto",
+    environment: environmentOption = "auto",
+    checker: checkerPreference = "auto",
+    strict = true,
+    electron: electronOption,
+    renderer: rendererOption,
+    compilerOptions: userCompilerOptions = {},
+    cwd = process.cwd()
+  } = options;
+  const detected = frameworkOption === "auto" || environmentOption === "auto" || electronOption === void 0 ? autoDetect(cwd) : { framework: frameworkOption, environment: environmentOption, electron: electronOption };
+  const framework = frameworkOption === "auto" ? detected.framework : frameworkOption;
+  const environment = environmentOption === "auto" ? detected.environment : environmentOption;
+  const isElectron = electronOption !== void 0 ? electronOption : detected.electron;
+  if (isElectron) {
+    const renderer = rendererOption || framework;
+    if (!VALID_RENDERERS.includes(renderer)) {
+      throw new ConfigError(
+        `Invalid renderer option for Electron: "${renderer}". Must be one of: ${VALID_RENDERERS.join(", ")}`,
+        {
+          received: renderer,
+          validRenderers: VALID_RENDERERS
+        }
+      );
+    }
+    const checker2 = detectTypeChecker(
+      framework,
+      checkerPreference,
+      cwd
+    );
+    console.log(
+      `\u26A1 Electron TypeScript Config: ${renderer} renderer | Checker: ${checker2}${checker2 === "tsgo" ? " (10x faster!)" : ""}`
+    );
+    const configs = createElectronPreset(renderer);
+    return {
+      ...configs,
+      _meta: {
+        framework: "electron",
+        renderer,
+        checker: checker2,
+        multiConfig: true,
+        experimental: checker2 === "tsgo",
+        generatedBy: "@dimensional-innovations/tool-config"
+      }
+    };
+  }
+  const checker = detectTypeChecker(
+    framework,
+    checkerPreference,
+    cwd
+  );
+  console.log(
+    `\u{1F50D} TypeScript Config: ${framework} | ${environment} | Checker: ${checker}${checker === "tsgo" ? " (10x faster!)" : ""}`
+  );
+  const config = loadPresets(framework, environment, strict);
+  if (userCompilerOptions && Object.keys(userCompilerOptions).length > 0) {
+    config.compilerOptions = {
+      ...config.compilerOptions,
+      ...userCompilerOptions
+    };
+  }
+  config._meta = {
+    framework,
+    environment,
+    checker,
+    experimental: checker === "tsgo",
+    generatedBy: "@dimensional-innovations/tool-config"
+  };
+  return config;
+}
+function loadPresets(framework, environment, strict) {
+  const config = structuredClone(base_default);
+  const envPreset = loadEnvironmentPreset(environment);
+  mergeConfig(config, envPreset);
+  const frameworkPreset = loadFrameworkPreset(framework);
+  mergeConfig(config, frameworkPreset);
+  if (!strict) {
+    config.compilerOptions = config.compilerOptions || {};
+    config.compilerOptions.strict = false;
+    config.compilerOptions.noImplicitAny = false;
+  }
+  return config;
+}
+function loadEnvironmentPreset(environment) {
+  switch (environment) {
+    case "browser":
+      return browser_default;
+    case "node":
+      return node_default;
+    case "universal":
+      return universal_default;
+    default:
+      return {};
+  }
+}
+function loadFrameworkPreset(framework) {
+  switch (framework) {
+    case "react":
+      return react_default;
+    case "vue":
+      return vue_default;
+    case "svelte":
+      return svelte_default;
+    case "solid":
+      return solid_default;
+    case "astro":
+      return astro_default;
+    case "angular":
+      return angular_default;
+    case "node":
+      return node_default2;
+    case "vanilla":
+    default:
+      return vanilla_default;
+  }
+}
+function mergeConfig(target, source) {
+  for (const key in source) {
+    const sourceKey = key;
+    if (key === "compilerOptions" && target.compilerOptions) {
+      Object.assign(target.compilerOptions, source.compilerOptions);
+    } else if (key === "include" && Array.isArray(source.include)) {
+      target.include = [.../* @__PURE__ */ new Set([...target.include || [], ...source.include])];
+    } else if (key === "exclude" && Array.isArray(source.exclude)) {
+      target.exclude = [.../* @__PURE__ */ new Set([...target.exclude || [], ...source.exclude])];
+    } else {
+      target[sourceKey] = source[sourceKey];
+    }
+  }
+}
+var VALID_RENDERERS, typescript_default;
+var init_typescript = __esm({
+  "src/tools/typescript/index.ts"() {
+    init_checker_detection();
+    init_base();
+    init_browser();
+    init_node();
+    init_universal();
+    init_angular();
+    init_astro();
+    init_electron();
+    init_node2();
+    init_react();
+    init_solid();
+    init_svelte();
+    init_vanilla();
+    init_vue();
+    init_detectors();
+    init_types();
+    VALID_RENDERERS = [
+      "react",
+      "vue",
+      "svelte",
+      "solid",
+      "astro",
+      "angular",
+      "vanilla"
+    ];
+    typescript_default = createTypescriptConfig;
+  }
+});
+
+// src/cli/formatting.ts
+var formatting_exports = {};
+__export(formatting_exports, {
+  BOX: () => BOX,
+  SYMBOLS: () => SYMBOLS,
+  colors: () => colors,
+  createBox: () => createBox,
+  createList: () => createList,
+  createProgress: () => createProgress,
+  createSeparator: () => createSeparator
+});
+function createBox(lines, title = "") {
+  const width = BOX.width;
+  const contentWidth = width - 4;
+  let top;
+  if (title) {
+    const titlePart = `\u2500 ${title} `;
+    const remaining = width - 2 - titlePart.length;
+    top = BOX.topLeft + titlePart + BOX.horizontal.repeat(remaining) + BOX.topRight;
+  } else {
+    top = BOX.topLeft + BOX.horizontal.repeat(width - 2) + BOX.topRight;
+  }
+  const content = lines.map((line) => {
+    const padded = line.slice(0, contentWidth).padEnd(contentWidth);
+    return `${BOX.vertical} ${padded} ${BOX.vertical}`;
+  });
+  const bottom = BOX.bottomLeft + BOX.horizontal.repeat(width - 2) + BOX.bottomRight;
+  return [top, ...content, bottom].join("\n");
+}
+function createSeparator() {
+  return BOX.separator.repeat(BOX.width);
+}
+function createList(items, bullet = "\u2022") {
+  return items.map((item) => `   ${bullet} ${item}`).join("\n");
+}
+function createProgress(current, total, label) {
+  return `  [${current}/${total}] ${label}`;
+}
+var BOX_WIDTH, BOX, SYMBOLS, colors;
+var init_formatting = __esm({
+  "src/cli/formatting.ts"() {
+    BOX_WIDTH = 70;
+    BOX = {
+      topLeft: "\u250C",
+      topRight: "\u2510",
+      bottomLeft: "\u2514",
+      bottomRight: "\u2518",
+      vertical: "\u2502",
+      horizontal: "\u2500",
+      separator: "\u2501",
+      width: BOX_WIDTH
+    };
+    SYMBOLS = {
+      success: pc.green("\u2713"),
+      warning: pc.yellow("\u26A0"),
+      error: pc.red("\u2717"),
+      info: pc.blue("\u2139")
+    };
+    colors = {
+      success: pc.green,
+      warning: pc.yellow,
+      error: pc.red,
+      info: pc.blue,
+      dim: pc.dim,
+      bold: pc.bold,
+      cyan: pc.cyan
+    };
+  }
+});
+
+// src/cli/handlers/eslint.ts
+var eslint_exports = {};
+__export(eslint_exports, {
+  generateConfigContent: () => generateConfigContent,
+  getConfigFilename: () => getConfigFilename,
+  getScripts: () => getScripts,
+  writeConfig: () => writeConfig
+});
+function getConfigFilename() {
+  return "eslint.config.js";
+}
+function generateConfigContent(detected) {
+  return `import { createConfig } from '@dimensional-innovations/tool-config'
+
+export default await createConfig('eslint', {
+  // \u2500\u2500 Detected Configuration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  framework: '${detected.framework}',
+  environment: '${detected.environment}',
+  typescript: ${detected.typescript},
+
+  // \u2500\u2500 Customization \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // ignorePaths: [],
+  // rules: {},
+})
+`;
+}
+function getScripts(_detected) {
+  return {
+    lint: "eslint .",
+    "lint:fix": "eslint --fix ."
+  };
+}
+function writeConfig(cwd, detected, dryRun = false) {
+  const filename = getConfigFilename();
+  const filepath = join(cwd, filename);
+  const content = generateConfigContent(detected);
+  if (existsSync(filepath)) {
+    console.log(`  \u26A0\uFE0F  ${filename} already exists - skipping`);
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F4C4} Would create: ${filename}`);
+    return true;
+  }
+  try {
+    writeFileSync(filepath, content, "utf8");
+    console.log(`  \u2705 Created: ${filename}`);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to create ${filename}:`, errorMessage);
+    return false;
+  }
+}
+
+// src/cli/handlers/prettier.ts
+var prettier_exports = {};
+__export(prettier_exports, {
+  generateConfigContent: () => generateConfigContent2,
+  getConfigFilename: () => getConfigFilename2,
+  getScripts: () => getScripts2,
+  writeConfig: () => writeConfig2
+});
+
+// src/core/ignore-patterns.ts
+var COMMON_IGNORE_DIRS = [
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "coverage",
+  ".nyc_output"
+];
+var FRAMEWORK_BUILD_DIRS = [
+  ".next",
+  // Next.js
+  ".nuxt",
+  // Nuxt
+  ".output",
+  // Nitro/Nuxt3
+  ".vercel",
+  // Vercel
+  ".netlify",
+  // Netlify
+  ".cache",
+  // Gatsby/Parcel
+  ".parcel-cache",
+  // Parcel
+  ".turbo",
+  // Turborepo
+  ".vite",
+  // Vite
+  ".vitepress",
+  // VitePress
+  ".svelte-kit"
+  // SvelteKit
+];
+var GENERATED_FILES = [
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb",
+  "CHANGELOG.md"
+];
+function getPrettierIgnoreContent() {
+  return `# Dependencies
+node_modules/
+.pnp/
+.pnp.js
+
+# Build outputs
+${COMMON_IGNORE_DIRS.filter((dir) => dir !== "node_modules" && dir !== "coverage").map((dir) => `${dir}/`).join("\n")}
+${FRAMEWORK_BUILD_DIRS.map((dir) => `${dir}/`).join("\n")}
+
+# Coverage
+coverage/
+.nyc_output/
+*.lcov
+
+# Lock files
+${GENERATED_FILES.filter((f) => f.includes("lock") || f.includes(".lock")).join("\n")}
+
+# Generated files
+CHANGELOG.md
+
+# Cache directories
+.cache/
+.parcel-cache/
+.turbo/
+.vite/
+
+# Environment files (may contain secrets)
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+
+# OS files
+.DS_Store
+Thumbs.db
+`;
+}
+
+// src/cli/handlers/prettier.ts
+function getConfigFilename2() {
+  return "prettier.config.js";
+}
+function generateConfigContent2(detected) {
+  return `import { createConfig } from '@dimensional-innovations/tool-config'
+
+export default createConfig('prettier', {
+  // \u2500\u2500 Detected Configuration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  framework: '${detected.framework}',
+
+  // \u2500\u2500 Customization \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // printWidth: 100,
+  // semi: false,
+  // singleQuote: true,
+  // overrides: [],
+})
+`;
+}
+function getScripts2(_detected) {
+  return {
+    "prettier:fix": "prettier --write .",
+    prettier: "prettier --check ."
+  };
+}
+function writeConfig2(cwd, detected, dryRun = false) {
+  const filename = getConfigFilename2();
+  const filepath = join(cwd, filename);
+  const content = generateConfigContent2(detected);
+  if (existsSync(filepath)) {
+    console.log(`  \u26A0\uFE0F  ${filename} already exists - skipping`);
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F4C4} Would create: ${filename}`);
+    const ignoreFile = ".prettierignore";
+    const ignoreExists = existsSync(join(cwd, ignoreFile));
+    if (!ignoreExists) {
+      console.log(`  \u{1F4C4} Would create: ${ignoreFile}`);
+    }
+    return true;
+  }
+  try {
+    writeFileSync(filepath, content, "utf8");
+    console.log(`  \u2705 Created: ${filename}`);
+    const ignoreFile = ".prettierignore";
+    const ignorePath = join(cwd, ignoreFile);
+    if (!existsSync(ignorePath)) {
+      writeFileSync(ignorePath, getPrettierIgnoreContent(), "utf8");
+      console.log(`  \u2705 Created: ${ignoreFile}`);
+    } else {
+      console.log(`  \u26A0\uFE0F  ${ignoreFile} already exists - skipping`);
+    }
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to create ${filename}:`, errorMessage);
+    return false;
+  }
+}
+
+// src/cli/handlers/semantic-release.ts
+var semantic_release_exports = {};
+__export(semantic_release_exports, {
+  generateConfigContent: () => generateConfigContent3,
+  getConfigFilename: () => getConfigFilename3,
+  getScripts: () => getScripts3,
+  writeConfig: () => writeConfig3
+});
+function getConfigFilename3() {
+  return "release.config.js";
+}
+function generateConfigContent3(detected) {
+  const gitProviderValue = detected.gitProvider === null ? "null" : `'${detected.gitProvider}'`;
+  return `import { createConfig } from '@dimensional-innovations/tool-config'
+
+export default createConfig('semantic-release', {
+  // \u2500\u2500 Detected Configuration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  preset: 'default',
+  gitProvider: ${gitProviderValue},
+
+  // \u2500\u2500 Customization \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // branches: [],
+  // plugins: [],
+})
+`;
+}
+function getScripts3(_detected) {
+  return {
+    release: "semantic-release"
+  };
+}
+function writeConfig3(cwd, detected, dryRun = false) {
+  const filename = getConfigFilename3();
+  const filepath = join(cwd, filename);
+  const content = generateConfigContent3(detected);
+  if (existsSync(filepath)) {
+    console.log(`  \u26A0\uFE0F  ${filename} already exists - skipping`);
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F4C4} Would create: ${filename}`);
+    return true;
+  }
+  try {
+    writeFileSync(filepath, content, "utf8");
+    console.log(`  \u2705 Created: ${filename}`);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to create ${filename}:`, errorMessage);
+    return false;
+  }
+}
+
+// src/cli/handlers/stylelint.ts
+var stylelint_exports = {};
+__export(stylelint_exports, {
+  generateConfigContent: () => generateConfigContent4,
+  getConfigFilename: () => getConfigFilename4,
+  getScripts: () => getScripts4,
+  writeConfig: () => writeConfig4
+});
+function getConfigFilename4() {
+  return "stylelint.config.js";
+}
+function generateConfigContent4(detected) {
+  return `import { createConfig } from '@dimensional-innovations/tool-config'
+
+export default createConfig('stylelint', {
+  // \u2500\u2500 Detected Configuration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  framework: '${detected.framework}',
+
+  // \u2500\u2500 Customization \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // extends: [],
+  // rules: {},
+  // overrides: [],
+})
+`;
+}
+function getStylelintExtensions(framework, cssType) {
+  const extensions = ["css"];
+  if (cssType.preprocessor === "scss") {
+    extensions.push("scss");
+  } else if (cssType.preprocessor === "less") {
+    extensions.push("less");
+  }
+  if (framework === "vue") extensions.push("vue");
+  if (framework === "svelte") extensions.push("svelte");
+  return extensions;
+}
+function getScripts4(detected) {
+  const extensions = getStylelintExtensions(detected.framework, detected.cssType);
+  const pattern = extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(",")}}`;
+  return {
+    style: `stylelint "${pattern}" --allow-empty-input`,
+    "style:fix": `stylelint "${pattern}" --fix --allow-empty-input`
+  };
+}
+function writeConfig4(cwd, detected, dryRun = false) {
+  const filename = getConfigFilename4();
+  const filepath = join(cwd, filename);
+  const content = generateConfigContent4(detected);
+  if (existsSync(filepath)) {
+    console.log(`  \u26A0\uFE0F  ${filename} already exists - skipping`);
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F4C4} Would create: ${filename}`);
+    return true;
+  }
+  try {
+    writeFileSync(filepath, content, "utf8");
+    console.log(`  \u2705 Created: ${filename}`);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to create ${filename}:`, errorMessage);
+    return false;
+  }
+}
+
+// src/cli/handlers/typescript.ts
+var typescript_exports2 = {};
+__export(typescript_exports2, {
+  generateConfigContent: () => generateConfigContent5,
+  getConfigFilename: () => getConfigFilename5,
+  getScripts: () => getScripts5,
+  writeConfig: () => writeConfig5
+});
+init_checker_detection();
+function getConfigFilename5() {
+  return "tsconfig.json";
+}
+function generateConfigContent5(_detected) {
+  return JSON.stringify(
+    {
+      $schema: "https://json.schemastore.org/tsconfig",
+      compilerOptions: {
+        target: "ES2022",
+        lib: ["ES2022"],
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist", "build", "out", "coverage"]
+    },
+    null,
+    2
+  );
+}
+function getScripts5(detected) {
+  if (detected.electron) {
+    return {
+      typecheck: "tsc --build",
+      "typecheck:watch": "tsc --build --watch"
+    };
+  }
+  const checker = detectTypeChecker(detected.framework, "auto");
+  const cmd = getTypeCheckCommand(checker);
+  const watchCmd = getTypeCheckCommand(checker, { watch: true });
+  return {
+    typecheck: cmd,
+    "typecheck:watch": watchCmd
+  };
+}
+async function writeElectronConfigs(detected, cwd, dryRun = false) {
+  const files = [
+    { name: "tsconfig.json", key: "root", desc: "root orchestrator" },
+    { name: "tsconfig.node.json", key: "node", desc: "main process" },
+    { name: "tsconfig.web.json", key: "web", desc: "renderer process" },
+    { name: "tsconfig.tests.json", key: "tests", desc: "test environment" }
+  ];
+  if (dryRun) {
+    for (const file of files) {
+      console.log(`  \u{1F4C4} Would create: ${file.name} (${file.desc})`);
+    }
+    return true;
+  }
+  try {
+    const { createTypescriptConfig: createTypescriptConfig2 } = await Promise.resolve().then(() => (init_typescript(), typescript_exports));
+    const configs = await createTypescriptConfig2({
+      electron: true,
+      renderer: detected.framework,
+      cwd
+    });
+    let created = 0;
+    for (const file of files) {
+      const filepath = join(cwd, file.name);
+      if (existsSync(filepath)) {
+        console.log(`  \u26A0\uFE0F  ${file.name} already exists - skipping`);
+        continue;
+      }
+      const content = JSON.stringify(configs[file.key], null, 2);
+      writeFileSync(filepath, `${content}
+`, "utf8");
+      console.log(`  \u2705 Created: ${file.name} (${file.desc})`);
+      created++;
+    }
+    return created > 0;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("  \u274C Failed to create Electron configs:", errorMessage);
+    return false;
+  }
+}
+function writeConfig5(cwd, detected, dryRun = false) {
+  if (!detected.typescript) {
+    console.log("  \u26A0\uFE0F  TypeScript not detected - skipping tsconfig generation");
+    return false;
+  }
+  if (detected.electron) {
+    return writeElectronConfigs(detected, cwd, dryRun);
+  }
+  const filename = getConfigFilename5();
+  const filepath = join(cwd, filename);
+  const content = generateConfigContent5();
+  if (existsSync(filepath)) {
+    console.log(`  \u26A0\uFE0F  ${filename} already exists - skipping`);
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F4C4} Would create: ${filename}`);
+    return true;
+  }
+  try {
+    writeFileSync(filepath, content, "utf8");
+    console.log(`  \u2705 Created: ${filename}`);
+    console.log("");
+    console.log("  To customize TypeScript options, add compilerOptions:");
+    console.log("");
+    console.log("  {");
+    console.log('    "compilerOptions": {');
+    console.log('      "baseUrl": "./src",');
+    console.log('      "paths": { "@/*": ["*"] }');
+    console.log("    }");
+    console.log("  }");
+    console.log("");
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to create ${filename}:`, errorMessage);
+    return false;
+  }
+}
+var CHECK_SCRIPT_MAP = {
+  prettier: "prettier",
+  stylelint: "style",
+  eslint: "lint",
+  typescript: "typecheck"
+};
+var CHECK_ORDER = ["prettier", "stylelint", "eslint", "typescript"];
+function generateCheckAllScript(installedTools) {
+  const commands = CHECK_ORDER.filter((tool) => installedTools.includes(tool)).map((tool) => `yarn ${CHECK_SCRIPT_MAP[tool]}`).join(" && ");
+  return commands || null;
+}
+function updatePackageJsonScripts(tools, getScriptsFn, context) {
+  const { detected, cwd, dryRun = false } = context;
+  const packageJsonPath = join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    console.log("  \u26A0\uFE0F  No package.json found - skipping script injection");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    const scriptsToAdd = {};
+    for (const tool of tools) {
+      const toolScripts = getScriptsFn(tool, detected);
+      for (const [name, command] of Object.entries(toolScripts)) {
+        if (!packageJson.scripts[name]) {
+          scriptsToAdd[name] = command;
+        }
+      }
+    }
+    const installedTools = [];
+    if (packageJson.scripts.lint || scriptsToAdd.lint) installedTools.push("eslint");
+    if (packageJson.scripts.prettier || scriptsToAdd.prettier) installedTools.push("prettier");
+    if (packageJson.scripts.style || scriptsToAdd.style) installedTools.push("stylelint");
+    if (packageJson.scripts.typecheck || scriptsToAdd.typecheck) installedTools.push("typescript");
+    if (installedTools.length >= 2) {
+      const checkAllCmd = generateCheckAllScript(installedTools);
+      if (checkAllCmd) {
+        const existingCheckAll = packageJson.scripts["check-all"];
+        const isAutoGenerated = existingCheckAll && existingCheckAll.startsWith("yarn ") && existingCheckAll.includes(" && yarn ");
+        if (!existingCheckAll || isAutoGenerated) {
+          scriptsToAdd["check-all"] = checkAllCmd;
+        }
+      }
+    }
+    if (Object.keys(scriptsToAdd).length === 0) {
+      console.log("  \u2139\uFE0F  All scripts already exist in package.json");
+      return;
+    }
+    if (dryRun) {
+      console.log("  \u{1F4DD} Would add scripts to package.json:");
+      for (const [name, command] of Object.entries(scriptsToAdd)) {
+        console.log(`     "${name}": "${command}"`);
+      }
+      return;
+    }
+    Object.assign(packageJson.scripts, scriptsToAdd);
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+    console.log("  \u2705 Updated package.json with scripts:");
+    for (const name of Object.keys(scriptsToAdd)) {
+      console.log(`     - ${name}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("  \u274C Failed to update package.json:", errorMessage);
+  }
+}
+function removePackageJsonScripts(tools, getScriptsFn, context) {
+  const { detected, cwd, dryRun = false } = context;
+  const packageJsonPath = join(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    console.log("  \u2139\uFE0F  No package.json found - skipping script removal");
+    return;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    if (!packageJson.scripts) {
+      console.log("  \u2139\uFE0F  No scripts section in package.json");
+      return;
+    }
+    const scriptsToRemove = [];
+    for (const tool of tools) {
+      const toolScripts = getScriptsFn(tool, detected);
+      for (const scriptName of Object.keys(toolScripts)) {
+        const expectedCommand = toolScripts[scriptName];
+        const actualCommand = packageJson.scripts[scriptName];
+        if (actualCommand === expectedCommand) {
+          scriptsToRemove.push(scriptName);
+        } else if (actualCommand) {
+          console.log(`  \u26A0\uFE0F  Script "${scriptName}" has been modified - skipping for safety`);
+        }
+      }
+    }
+    const checkAllScript = packageJson.scripts["check-all"];
+    if (checkAllScript) {
+      const isAutoGenerated = checkAllScript.startsWith("yarn ") && checkAllScript.includes(" && yarn ");
+      if (isAutoGenerated) {
+        scriptsToRemove.push("check-all");
+      }
+    }
+    if (scriptsToRemove.length === 0) {
+      console.log("  \u2139\uFE0F  No scripts to remove from package.json");
+      return;
+    }
+    if (dryRun) {
+      console.log("  \u{1F4DD} Would remove scripts from package.json:");
+      for (const name of scriptsToRemove) {
+        console.log(`     - ${name}`);
+      }
+      return;
+    }
+    for (const scriptName of scriptsToRemove) {
+      delete packageJson.scripts[scriptName];
+    }
+    if (Object.keys(packageJson.scripts).length === 0) {
+      delete packageJson.scripts;
+    }
+    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, "utf8");
+    console.log("  \u2705 Removed scripts from package.json:");
+    for (const name of scriptsToRemove) {
+      console.log(`     - ${name}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("  \u274C Failed to update package.json:", errorMessage);
+  }
+}
+
+// src/cli/ui.ts
+init_formatting();
+var VERSION = "0.0.0-development";
+function showHelp() {
+  console.log(`
+\u{1F4E6} @dimensional-innovations/tool-config Setup Tool
+
+Usage:
+  setup-tool-config [tool] [options]
+
+Tools:
+  eslint          Setup ESLint only
+  prettier        Setup Prettier only
+  stylelint       Setup Stylelint only
+  typescript      Setup TypeScript only
+  semantic-release Setup semantic-release only
+
+Options:
+  --all, -a       Setup all tools (non-interactive)
+  --uninstall     Remove tool configuration and scripts
+  --dry-run, -d   Preview changes without writing files
+  --help, -h      Show this help message
+  --version, -v   Show version number
+
+Examples (Install):
+  setup-tool-config                    # Interactive mode
+  setup-tool-config eslint             # Setup ESLint only
+  setup-tool-config --all              # Setup all tools
+  setup-tool-config --dry-run          # Preview without changes
+
+Examples (Uninstall):
+  setup-tool-config --uninstall        # Interactive uninstall
+  setup-tool-config --uninstall eslint # Remove ESLint only
+  setup-tool-config --uninstall --all  # Remove all detected tools
+  setup-tool-config --uninstall --dry-run # Preview uninstall
+
+For more information, visit:
+  https://gitlab.com/dimensional-innovations/tool-config
+`);
+}
+function showVersion() {
+  console.log(`@dimensional-innovations/tool-config v${VERSION}`);
+}
+function showBanner(detected) {
+  console.log("");
+  const welcome = [
+    "\u{1F680} Welcome to @dimensional-innovations/tool-config",
+    "",
+    "Zero-config setup for ESLint, Prettier, Stylelint,",
+    "TypeScript, and semantic-release.",
+    "",
+    "\u{1F4A1} Navigation: \u2191\u2193 to move, Space to select, Enter to continue"
+  ];
+  console.log(createBox(welcome));
+  console.log("");
+  const detectedParts = [];
+  if (detected.framework !== "vanilla") {
+    detectedParts.push(detected.framework.charAt(0).toUpperCase() + detected.framework.slice(1));
+  }
+  if (detected.typescript) {
+    detectedParts.push("TypeScript");
+  }
+  if (detected.environment) {
+    detectedParts.push(detected.environment.charAt(0).toUpperCase() + detected.environment.slice(1));
+  }
+  const detectedStr = detectedParts.length > 0 ? detectedParts.join(" \u2022 ") : "JavaScript project";
+  console.log(`\u{1F50D} Auto-detected: ${detectedStr}`);
+  console.log("");
+  console.log("\u{1F4A1} Recommended tools are pre-selected based on your project");
+  console.log("");
+}
+function showSection(title) {
+  console.log("");
+  console.log(`${title}`);
+  console.log("");
+}
+function showCompletion(dryRun, createdFiles = [], scripts = []) {
+  console.log("");
+  if (dryRun) {
+    console.log(createSeparator());
+    console.log("");
+    const dryRunMsg = [
+      `${SYMBOLS.info} DRY RUN MODE - Preview only, no files created`,
+      "",
+      "Run without --dry-run to create these files"
+    ];
+    console.log(createBox(dryRunMsg));
+  } else {
+    console.log(createSeparator());
+    console.log("");
+    const completion = [colors.bold(colors.cyan("\u{1F389} All done! Your project is ready."))];
+    if (createdFiles.length > 0) {
+      completion.push("");
+      completion.push(
+        `\u{1F4C1} Created ${createdFiles.length} config file${createdFiles.length > 1 ? "s" : ""}:`
+      );
+      createdFiles.forEach((file) => {
+        completion.push(`   \u2022 ${file}`);
+      });
+    }
+    if (scripts.length > 0) {
+      completion.push("");
+      completion.push(`\u{1F4E6} Added ${scripts.length} npm script${scripts.length > 1 ? "s" : ""}:`);
+      const checkAllIndex = scripts.indexOf("check-all");
+      if (checkAllIndex !== -1) {
+        completion.push(`   \u2022 check-all  \u2190 Run this to validate everything`);
+        scripts.filter((s) => s !== "check-all").forEach((script) => {
+          completion.push(`   \u2022 ${script}`);
+        });
+      } else {
+        scripts.forEach((script) => {
+          completion.push(`   \u2022 ${script}`);
+        });
+      }
+    }
+    completion.push("");
+    completion.push("\u{1F680} Quick start:");
+    if (scripts.includes("check-all")) {
+      completion.push("   npm run check-all");
+    } else if (scripts.length > 0) {
+      completion.push(`   npm run ${scripts[0]}`);
+    }
+    console.log(createBox(completion));
+  }
+  console.log("");
+}
+function showUninstallBanner(installedTools) {
+  console.log("");
+  console.log("\u{1F5D1}\uFE0F  @dimensional-innovations/tool-config Uninstall");
+  console.log("\u2501".repeat(50));
+  console.log("");
+  console.log("\u26A0\uFE0F  WARNING: This will remove configuration files and scripts");
+  console.log("   Make sure you have committed or backed up your changes first!");
+  console.log("");
+  if (installedTools.length > 0) {
+    console.log("\u{1F4E6} Detected tools:");
+    for (const tool of installedTools) {
+      console.log(`   - ${tool}`);
+    }
+    console.log("");
+  } else {
+    console.log("\u2139\uFE0F  No tools detected");
+    console.log("");
+  }
+}
+function showUninstallCompletion(dryRun, removedCount) {
+  console.log("");
+  if (dryRun) {
+    console.log(`${SYMBOLS.info} Dry run mode - no files were modified`);
+    console.log("   Run without --dry-run to apply changes");
+  } else if (removedCount > 0) {
+    console.log(`${SYMBOLS.success} Uninstall complete!`);
+    console.log(`   Removed ${removedCount} file(s) and their associated scripts`);
+  } else {
+    console.log(`${SYMBOLS.info} Nothing was removed`);
+  }
+  console.log("");
+}
+function detectInstalledTools(cwd) {
+  const toolFiles = {
+    eslint: "eslint.config.js",
+    prettier: "prettier.config.js",
+    stylelint: "stylelint.config.js",
+    typescript: "tsconfig.json",
+    "semantic-release": "release.config.js"
+  };
+  const installed = [];
+  for (const [tool, filename] of Object.entries(toolFiles)) {
+    if (existsSync(join(cwd, filename))) {
+      installed.push(tool);
+    }
+  }
+  return installed;
+}
+function contentMatches(filepath, expectedContent) {
+  if (!existsSync(filepath)) {
+    return false;
+  }
+  try {
+    const actualContent = readFileSync(filepath, "utf8");
+    return actualContent.trim() === expectedContent.trim();
+  } catch {
+    return false;
+  }
+}
+function uninstallTool(_tool, handler, detected, cwd, dryRun = false) {
+  const filename = handler.getConfigFilename();
+  const filepath = join(cwd, filename);
+  if (!existsSync(filepath)) {
+    console.log(`  \u2139\uFE0F  ${filename} not found - already uninstalled`);
+    return false;
+  }
+  const expectedContent = handler.generateConfigContent(detected);
+  const isUnmodified = contentMatches(filepath, expectedContent);
+  if (!isUnmodified) {
+    console.log(`  \u26A0\uFE0F  ${filename} has been modified - skipping for safety`);
+    console.log("     Remove manually if you want to delete it");
+    return false;
+  }
+  if (dryRun) {
+    console.log(`  \u{1F5D1}\uFE0F  Would remove: ${filename}`);
+    return true;
+  }
+  try {
+    rmSync(filepath);
+    console.log(`  \u2705 Removed: ${filename}`);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`  \u274C Failed to remove ${filename}:`, errorMessage);
+    return false;
+  }
+}
+
+// src/cli/validators.ts
+var VALID_TOOLS = [
+  "eslint",
+  "prettier",
+  "stylelint",
+  "typescript",
+  "semantic-release"
+];
+function validateTool(tool) {
+  if (!VALID_TOOLS.includes(tool)) {
+    throw new Error(`Unknown tool: ${tool}. Valid tools: ${VALID_TOOLS.join(", ")}`);
+  }
+}
+
+// src/cli/index.ts
+init_detectors();
+var TOOL_HANDLERS = {
+  eslint: eslint_exports,
+  prettier: prettier_exports,
+  stylelint: stylelint_exports,
+  typescript: typescript_exports2,
+  "semantic-release": semantic_release_exports
+};
+function getToolScripts(tool, detected) {
+  const handler = TOOL_HANDLERS[tool];
+  return handler.getScripts ? handler.getScripts(detected) : {};
+}
+async function setupTools(tools, detected, cwd, dryRun = false) {
+  const { createProgress: createProgress2, SYMBOLS: SYMBOLS2, colors: colors2 } = await Promise.resolve().then(() => (init_formatting(), formatting_exports));
+  console.log("");
+  console.log("Creating configuration files...");
+  console.log("");
+  const successfulTools = [];
+  const createdFiles = [];
+  let current = 0;
+  for (const tool of tools) {
+    current++;
+    const handler = TOOL_HANDLERS[tool];
+    const filename = handler.getConfigFilename();
+    const progressLine = colors2.dim(createProgress2(current, tools.length, filename));
+    process.stdout.write(progressLine);
+    const success = await handler.writeConfig(cwd, detected, dryRun);
+    if (success) {
+      successfulTools.push(tool);
+      createdFiles.push(filename);
+      console.log(` ${SYMBOLS2.success}`);
+    } else {
+      console.log(` ${SYMBOLS2.warning}`);
+    }
+  }
+  const addedScripts = [];
+  if (successfulTools.length > 0) {
+    console.log("");
+    console.log("Adding npm scripts...");
+    console.log("");
+    for (const tool of successfulTools) {
+      const scripts = getToolScripts(tool, detected);
+      addedScripts.push(...Object.keys(scripts));
+    }
+    updatePackageJsonScripts(successfulTools, getToolScripts, {
+      detected,
+      cwd,
+      dryRun
+    });
+  }
+  return {
+    files: createdFiles,
+    scripts: addedScripts
+  };
+}
+function uninstallTools(tools, detected, cwd, dryRun = false) {
+  showSection("\u{1F5D1}\uFE0F  Removing configuration files...");
+  let removedCount = 0;
+  for (const tool of tools) {
+    console.log(`${tool}:`);
+    const handler = TOOL_HANDLERS[tool];
+    const success = uninstallTool(tool, handler, detected, cwd, dryRun);
+    if (success) {
+      removedCount++;
+    }
+  }
+  if (tools.length > 0) {
+    showSection("\u{1F4E6} Removing package.json scripts...");
+    removePackageJsonScripts(tools, getToolScripts, { detected, cwd, dryRun });
+  }
+  return removedCount;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const flags = {
+    help: args.includes("--help") || args.includes("-h"),
+    version: args.includes("--version") || args.includes("-v"),
+    dryRun: args.includes("--dry-run") || args.includes("-d"),
+    all: args.includes("--all") || args.includes("-a"),
+    uninstall: args.includes("--uninstall")
+  };
+  const singleTool = args.find((arg) => !arg.startsWith("-"));
+  if (flags.help) {
+    showHelp();
+    process.exit(0);
+  }
+  if (flags.version) {
+    showVersion();
+    process.exit(0);
+  }
+  const cwd = process.cwd();
+  if (flags.uninstall) {
+    const detected2 = autoDetect(cwd);
+    const installedTools = detectInstalledTools(cwd);
+    showUninstallBanner(installedTools);
+    if (installedTools.length === 0) {
+      console.log("Nothing to uninstall.");
+      process.exit(0);
+    }
+    if (flags.all) {
+      const removedCount2 = uninstallTools(installedTools, detected2, cwd, flags.dryRun);
+      showUninstallCompletion(flags.dryRun, removedCount2);
+      process.exit(0);
+    }
+    if (singleTool) {
+      if (!installedTools.includes(singleTool)) {
+        console.log(`\u26A0\uFE0F  ${singleTool} is not installed`);
+        process.exit(0);
+      }
+      const removedCount2 = uninstallTools([singleTool], detected2, cwd, flags.dryRun);
+      showUninstallCompletion(flags.dryRun, removedCount2);
+      process.exit(0);
+    }
+    const response2 = await prompts({
+      type: "multiselect",
+      name: "tools",
+      message: "Which tools would you like to uninstall?",
+      choices: installedTools.map((tool) => ({
+        title: tool,
+        value: tool,
+        selected: false
+      })),
+      hint: "- Space to select. Return to submit"
+    });
+    if (!response2.tools || response2.tools.length === 0) {
+      console.log("");
+      console.log("\u274C No tools selected. Exiting.");
+      process.exit(0);
+    }
+    const removedCount = uninstallTools(response2.tools, detected2, cwd, flags.dryRun);
+    showUninstallCompletion(flags.dryRun, removedCount);
+    process.exit(0);
+  }
+  const detected = autoDetect(cwd);
+  showBanner(detected);
+  if (flags.all) {
+    const summary2 = await setupTools([...VALID_TOOLS], detected, cwd, flags.dryRun);
+    showCompletion(flags.dryRun, summary2.files, summary2.scripts);
+    process.exit(0);
+  }
+  if (singleTool) {
+    validateTool(singleTool);
+    const summary2 = await setupTools([singleTool], detected, cwd, flags.dryRun);
+    showCompletion(flags.dryRun, summary2.files, summary2.scripts);
+    process.exit(0);
+  }
+  const response = await prompts([
+    {
+      type: "multiselect",
+      name: "tools",
+      message: "Select development tools to configure:",
+      choices: [
+        {
+          title: "ESLint        Catch bugs and enforce standards",
+          value: "eslint",
+          selected: true
+        },
+        {
+          title: "Prettier      Auto-format code consistently",
+          value: "prettier",
+          selected: true
+        },
+        {
+          title: "Stylelint     Lint CSS, SCSS, and style files",
+          value: "stylelint",
+          selected: false
+        },
+        {
+          title: "TypeScript    Type safety and better tooling",
+          value: "typescript",
+          selected: detected.typescript
+        },
+        {
+          title: "semantic-release  Automated versioning & releases",
+          value: "semantic-release",
+          selected: false
+        }
+      ],
+      hint: "  (Recommended tools are pre-selected)"
+    }
+  ]);
+  if (!response.tools || response.tools.length === 0) {
+    console.log("");
+    console.log("\u274C No tools selected. Exiting.");
+    process.exit(0);
+  }
+  const summary = await setupTools(response.tools, detected, cwd, flags.dryRun);
+  showCompletion(flags.dryRun, summary.files, summary.scripts);
+}
+main().catch((error) => {
+  console.error("");
+  console.error("\u274C Error:", error.message);
+  console.error("");
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map