@dimensional-innovations/tool-config 5.0.0 → 5.0.1

package/dist/index.js

@@ -0,0 +1,2644 @@
+import globals3 from 'globals';
+import prettierConfig from 'eslint-config-prettier';
+import react from 'eslint-plugin-react';
+import reactHooks from 'eslint-plugin-react-hooks';
+import vuePlugin from 'eslint-plugin-vue';
+import tseslint from 'typescript-eslint';
+import vueParser from 'vue-eslint-parser';
+import { fixupPluginRules } from '@eslint/compat';
+import importPlugin from 'eslint-plugin-import';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import svelte from 'eslint-plugin-svelte';
+import svelteParser from 'svelte-eslint-parser';
+import solid from 'eslint-plugin-solid/configs/typescript';
+import { configs } from 'eslint-plugin-astro';
+import js from '@eslint/js';
+
+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);
+        }
+      }
+    };
+  }
+});
+
+// src/tools/eslint/presets/base.ts
+var basePreset, base_default;
+var init_base = __esm({
+  "src/tools/eslint/presets/base.ts"() {
+    basePreset = {
+      rules: {
+        // ============================================================
+        // MODERN JAVASCRIPT RULES
+        // Best practices for ES2015+ code
+        // Documentation: https://eslint.org/docs/rules/
+        // ============================================================
+        // Console and debugging
+        "no-console": ["warn", { allow: ["warn", "error"] }],
+        // Warn on console.log but allow console.warn/error for logging
+        "no-debugger": "warn",
+        // Warn on debugger statements (should be removed before commit)
+        "no-alert": "error",
+        // Disallow alert/confirm/prompt (use proper UI)
+        // Modern syntax preferences
+        "prefer-const": "error",
+        // Use const for variables that are never reassigned
+        "no-var": "error",
+        // Use let/const instead of var
+        "prefer-arrow-callback": "error",
+        // Use arrow functions for callbacks
+        "prefer-template": "error",
+        // Use template literals instead of string concatenation
+        "prefer-destructuring": [
+          "error",
+          {
+            array: true,
+            object: true
+          },
+          {
+            enforceForRenamedProperties: false
+          }
+        ],
+        // Use destructuring where possible
+        "prefer-rest-params": "error",
+        // Use rest parameters instead of arguments object
+        "prefer-spread": "error",
+        // Use spread operator instead of .apply()
+        "object-shorthand": "error",
+        // Use object shorthand syntax {x} instead of {x: x}
+        // Note: arrow-body-style is a formatting rule disabled by eslint-config-prettier
+        // Code quality
+        eqeqeq: ["error", "always"],
+        // Always use === and !== instead of == and !=
+        "no-duplicate-imports": "off",
+        // Handled by import/no-duplicates (better type + value import support)
+        "no-useless-computed-key": "error",
+        // Disallow unnecessary computed property keys
+        "no-useless-constructor": "error",
+        // Disallow unnecessary constructors
+        "no-useless-rename": "error",
+        // Disallow renaming import/export/destructured assignments to same name
+        "no-nested-ternary": "error",
+        // Disallow nested ternary expressions (hard to read)
+        "no-unneeded-ternary": "error",
+        // Disallow ternary operators when simpler alternatives exist
+        "prefer-object-spread": "error",
+        // Use object spread instead of Object.assign
+        // Async/Promise best practices
+        "no-return-await": "error",
+        // Disallow unnecessary return await
+        "require-await": "warn",
+        // Warn on async functions without await (allow for plugin patterns)
+        "no-promise-executor-return": "error",
+        // Disallow returning values from Promise executor functions
+        // ============================================================
+        // CODE QUALITY & COMPLEXITY
+        // Maintainability and readability rules
+        // Documentation: https://eslint.org/docs/rules/
+        // ============================================================
+        // Complexity (warnings to identify areas needing refactoring)
+        complexity: ["warn", 15],
+        // Warn on high cyclomatic complexity
+        "max-depth": ["warn", 4],
+        // Warn on deeply nested blocks
+        "max-lines": ["warn", 500],
+        // Warn on files exceeding 500 lines
+        "max-lines-per-function": [
+          "warn",
+          {
+            max: 100,
+            skipBlankLines: true,
+            skipComments: true
+          }
+        ],
+        // Warn on functions exceeding 100 lines
+        "max-params": ["warn", 4]
+        // Warn on functions with more than 4 parameters
+        // Note: spaced-comment is a formatting rule disabled by eslint-config-prettier
+      }
+    };
+    base_default = basePreset;
+  }
+});
+var browserEnv, browser_default;
+var init_browser = __esm({
+  "src/tools/eslint/presets/environments/browser.ts"() {
+    browserEnv = {
+      languageOptions: {
+        ecmaVersion: 2025,
+        sourceType: "module",
+        globals: {
+          ...globals3.browser
+        }
+      }
+    };
+    browser_default = browserEnv;
+  }
+});
+var nodeEnv, node_default;
+var init_node = __esm({
+  "src/tools/eslint/presets/environments/node.ts"() {
+    nodeEnv = {
+      languageOptions: {
+        ecmaVersion: 2025,
+        sourceType: "module",
+        globals: {
+          ...globals3.node
+        }
+      },
+      rules: {
+        // Node.js-specific rule adjustments
+        "no-console": "off",
+        // Console is normal in Node.js
+        "@typescript-eslint/no-var-requires": "off"
+        // Allow require() in .js files
+      }
+    };
+    node_default = nodeEnv;
+  }
+});
+var universalEnv, universal_default;
+var init_universal = __esm({
+  "src/tools/eslint/presets/environments/universal.ts"() {
+    universalEnv = {
+      languageOptions: {
+        ecmaVersion: 2025,
+        sourceType: "module",
+        globals: {
+          ...globals3.browser,
+          ...globals3.node
+        }
+      }
+    };
+    universal_default = universalEnv;
+  }
+});
+function createAngularPreset() {
+  return [
+    {
+      files: ["**/*.ts"],
+      rules: {
+        // ============================================================
+        // ANGULAR-FRIENDLY TYPESCRIPT RULES
+        // Basic rules that work well with Angular patterns
+        // ============================================================
+        // Angular uses decorators extensively
+        "@typescript-eslint/no-extraneous-class": "off",
+        // Angular components often have empty constructors for DI
+        "@typescript-eslint/no-empty-function": [
+          "error",
+          {
+            allow: ["constructors"]
+          }
+        ],
+        // Angular uses ! for definite assignment (properties set by Angular)
+        "@typescript-eslint/no-non-null-assertion": "warn",
+        // Angular services and components use 'any' in some cases
+        "@typescript-eslint/no-explicit-any": "warn",
+        // Parameter properties are common in Angular (constructor(private foo: Foo))
+        "@typescript-eslint/parameter-properties": "off",
+        "@typescript-eslint/explicit-member-accessibility": "off",
+        // Angular uses both interfaces and types
+        "@typescript-eslint/consistent-type-definitions": "off",
+        // Naming conventions for Angular
+        "@typescript-eslint/naming-convention": [
+          "error",
+          {
+            selector: "default",
+            format: ["camelCase"],
+            leadingUnderscore: "allow",
+            trailingUnderscore: "allow"
+          },
+          {
+            selector: "variable",
+            format: ["camelCase", "UPPER_CASE", "PascalCase"],
+            leadingUnderscore: "allow"
+          },
+          {
+            selector: "typeLike",
+            format: ["PascalCase"]
+          },
+          {
+            selector: "enumMember",
+            format: ["PascalCase", "UPPER_CASE"]
+          },
+          {
+            selector: "property",
+            format: null
+            // Allow any format for properties (Angular templates use various patterns)
+          }
+        ]
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_angular = __esm({
+  "src/tools/eslint/presets/frameworks/angular.ts"() {
+  }
+});
+function createNodePreset() {
+  return [
+    {
+      files: ["**/*.js", "**/*.ts", "**/*.mjs"],
+      rules: {
+        // ============================================================
+        // NODE.JS BACKEND RULES
+        // Best practices for server-side JavaScript/TypeScript
+        // ============================================================
+        // Console usage is normal in Node.js
+        "no-console": "off",
+        // Process and __dirname are standard in Node
+        "no-process-env": "off",
+        "no-process-exit": "warn",
+        // Async patterns
+        "no-async-promise-executor": "error",
+        "require-atomic-updates": "error",
+        // Error handling
+        "no-throw-literal": "error",
+        "prefer-promise-reject-errors": "error",
+        // Node.js specific
+        "callback-return": "off",
+        // Modern Node uses async/await
+        "handle-callback-err": "off",
+        // Modern Node uses async/await
+        "no-mixed-requires": "off",
+        // ES modules don't have this issue
+        "no-new-require": "error",
+        "no-path-concat": "error",
+        // Use path.join() instead
+        // Security
+        "no-eval": "error",
+        "no-implied-eval": "error",
+        "no-new-func": "error",
+        // Best practices for backend
+        "no-unused-vars": [
+          "error",
+          {
+            args: "after-used",
+            argsIgnorePattern: "^_",
+            varsIgnorePattern: "^_"
+          }
+        ],
+        // Allow both require and import
+        "@typescript-eslint/no-var-requires": "off"
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_node2 = __esm({
+  "src/tools/eslint/presets/frameworks/node.ts"() {
+  }
+});
+function createReactPreset() {
+  return [
+    // React recommended configuration
+    react.configs.flat.recommended,
+    react.configs.flat["jsx-runtime"],
+    // Disable React-in-scope for React 17+
+    // React Hooks rules
+    {
+      files: ["**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"],
+      plugins: {
+        "react-hooks": reactHooks
+      },
+      rules: reactHooks.configs.recommended.rules
+    },
+    // Custom opinionated React rules
+    {
+      files: ["**/*.js", "**/*.jsx", "**/*.ts", "**/*.tsx"],
+      settings: {
+        react: {
+          version: "detect"
+          // Automatically detect React version
+        }
+      },
+      rules: {
+        // ============================================================
+        // REACT RULES (Conservative - Essential Only)
+        // React best practices for modern React 17+
+        // Documentation: https://github.com/jsx-eslint/eslint-plugin-react
+        // ============================================================
+        // Modern React (17+) adjustments
+        "react/react-in-jsx-scope": "off",
+        // Not needed in React 17+ with new JSX transform
+        "react/jsx-uses-react": "off",
+        // Not needed in React 17+ with new JSX transform
+        // TypeScript integration
+        "react/prop-types": "off",
+        // TypeScript handles prop validation
+        // JSX best practices
+        "react/jsx-uses-vars": "error",
+        // Prevent variables used in JSX being marked as unused
+        "react/jsx-curly-brace-presence": ["error", { props: "never", children: "never" }],
+        // Use strings when possible: prop="value" not prop={"value"}
+        "react/self-closing-comp": "error",
+        // Use <Component /> instead of <Component></Component>
+        "react/jsx-boolean-value": ["error", "never"],
+        // Use prop instead of prop={true}
+        "react/jsx-fragments": ["error", "syntax"],
+        // Use <> instead of <Fragment>
+        "react/jsx-no-useless-fragment": "error",
+        // Disallow unnecessary fragments
+        // Component definition
+        "react/function-component-definition": [
+          "error",
+          {
+            namedComponents: "arrow-function",
+            // const Component = () => ...
+            unnamedComponents: "arrow-function"
+          }
+        ],
+        // Hooks (enforced by react-hooks plugin)
+        // - react-hooks/rules-of-hooks: error
+        // - react-hooks/exhaustive-deps: warn
+        // Best practices
+        "react/no-array-index-key": "warn",
+        // Warn when using array index as key (can cause issues)
+        "react/jsx-key": "error",
+        // Require key prop in iterators
+        "react/no-children-prop": "error",
+        // Prevent passing children as props
+        "react/no-danger": "warn",
+        // Warn on dangerouslySetInnerHTML (XSS risk)
+        "react/no-deprecated": "error",
+        // Prevent usage of deprecated methods
+        "react/no-unknown-property": "error"
+        // Prevent usage of unknown DOM properties
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_react = __esm({
+  "src/tools/eslint/presets/frameworks/react.ts"() {
+  }
+});
+function createVanillaPreset() {
+  return [
+    {
+      files: ["**/*.js", "**/*.ts", "**/*.tsx"],
+      rules: {
+        // No framework-specific rules
+        // All rules come from base.js and typescript.js presets
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_vanilla = __esm({
+  "src/tools/eslint/presets/frameworks/vanilla.ts"() {
+  }
+});
+function createVuePreset() {
+  return [
+    // Vue recommended configuration (flat config)
+    ...vuePlugin.configs["flat/recommended"],
+    // Vue-specific custom rules
+    {
+      files: ["**/*.vue", "**/*.js", "**/*.ts", "**/*.tsx"],
+      rules: vueCustomRules
+    },
+    // Vue-specific parser configuration for TypeScript in <script> tags
+    // We must explicitly set vue-eslint-parser as the main parser, then configure
+    // it to use TypeScript parser for <script> blocks via parserOptions.parser
+    {
+      files: ["**/*.vue"],
+      languageOptions: {
+        parser: vueParser,
+        parserOptions: {
+          parser: tseslint.parser,
+          extraFileExtensions: [".vue"],
+          ecmaVersion: "latest",
+          sourceType: "module"
+        }
+      }
+    },
+    // Disable TypeScript naming convention for Vue files (allows onUpdate:modelValue pattern)
+    // IMPORTANT: Must also set parser to maintain vue-eslint-parser
+    {
+      files: ["**/*.vue"],
+      languageOptions: {
+        parser: vueParser,
+        parserOptions: {
+          parser: tseslint.parser,
+          extraFileExtensions: [".vue"],
+          ecmaVersion: "latest",
+          sourceType: "module"
+        }
+      },
+      rules: {
+        "@typescript-eslint/naming-convention": "off"
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var vueCustomRules;
+var init_vue = __esm({
+  "src/tools/eslint/presets/frameworks/vue.ts"() {
+    vueCustomRules = {
+      // Component naming
+      "vue/component-name-in-template-casing": ["error", "PascalCase"],
+      "vue/multi-word-component-names": "off",
+      "vue/component-definition-name-casing": ["error", "PascalCase"],
+      // Template best practices
+      "vue/html-self-closing": [
+        "error",
+        {
+          html: {
+            void: "any",
+            normal: "always",
+            component: "always"
+          }
+        }
+      ],
+      "vue/max-attributes-per-line": [
+        "error",
+        {
+          singleline: 3,
+          multiline: 1
+        }
+      ],
+      "vue/first-attribute-linebreak": [
+        "error",
+        {
+          singleline: "ignore",
+          multiline: "below"
+        }
+      ],
+      "vue/html-closing-bracket-newline": [
+        "error",
+        {
+          singleline: "never",
+          multiline: "always"
+        }
+      ],
+      // Disable formatting rules that conflict with Prettier
+      "vue/multiline-html-element-content-newline": "off",
+      "vue/singleline-html-element-content-newline": "off",
+      // Vue 3 Composition API
+      "vue/no-deprecated-v-on-native-modifier": "error",
+      "vue/no-deprecated-slot-attribute": "error",
+      "vue/require-explicit-emits": "error",
+      "vue/no-setup-props-reactivity-loss": "error",
+      "vue/component-api-style": ["error", ["script-setup"]],
+      "vue/define-macros-order": [
+        "error",
+        {
+          order: ["defineProps", "defineEmits"]
+        }
+      ],
+      "vue/define-emits-declaration": ["error", "type-based"],
+      // Directives
+      "vue/no-v-html": "warn",
+      "vue/v-on-event-hyphenation": ["error", "always"],
+      "vue/v-bind-style": ["error", "shorthand"],
+      "vue/v-on-style": ["error", "shorthand"],
+      // Attributes
+      "vue/attribute-hyphenation": ["error", "always"],
+      "vue/prop-name-casing": ["error", "camelCase"],
+      // Order and organization
+      "vue/order-in-components": [
+        "error",
+        {
+          order: [
+            "el",
+            "name",
+            "parent",
+            "functional",
+            ["delimiters", "comments"],
+            ["components", "directives", "filters"],
+            "extends",
+            "mixins",
+            "inheritAttrs",
+            "model",
+            ["props", "propsData"],
+            "data",
+            "computed",
+            "watch",
+            "LIFECYCLE_HOOKS",
+            "methods",
+            ["template", "render"],
+            "renderError"
+          ]
+        }
+      ]
+    };
+  }
+});
+var importsPreset, imports_default;
+var init_imports = __esm({
+  "src/tools/eslint/presets/imports.ts"() {
+    importsPreset = {
+      plugins: {
+        import: fixupPluginRules(importPlugin)
+      },
+      rules: {
+        // ============================================================
+        // IMPORT/MODULE RULES
+        // Module import/export best practices
+        // Documentation: https://github.com/import-js/eslint-plugin-import
+        // ============================================================
+        "import/order": [
+          "error",
+          {
+            groups: ["builtin", "external", "internal", "parent", "sibling", "index"],
+            "newlines-between": "always",
+            alphabetize: {
+              order: "asc",
+              caseInsensitive: true
+            }
+          }
+        ],
+        // Enforce consistent import order with alphabetization
+        "import/no-duplicates": [
+          "error",
+          {
+            "prefer-inline": true,
+            considerQueryString: false
+          }
+        ],
+        // Prevent duplicate imports (allows type + value imports from same module)
+        "import/no-unresolved": "off",
+        // TypeScript handles this better
+        "import/named": "off",
+        // TypeScript handles this better
+        "import/namespace": "off",
+        // TypeScript handles this better
+        "import/default": "off",
+        // TypeScript handles this better
+        "import/no-named-as-default": "warn",
+        // Warn on potentially confusing imports
+        "import/no-named-as-default-member": "warn",
+        // Warn on confusing member access
+        "import/newline-after-import": "error",
+        // Require blank line after imports
+        "import/no-webpack-loader-syntax": "error",
+        // No webpack loader syntax in imports
+        "import/first": "error"
+        // Imports must be at the top of the file
+      }
+    };
+    imports_default = importsPreset;
+  }
+});
+
+// src/tools/eslint/presets/typescript.ts
+var typescriptPreset, typescript_default;
+var init_typescript = __esm({
+  "src/tools/eslint/presets/typescript.ts"() {
+    typescriptPreset = {
+      rules: {
+        // ============================================================
+        // TYPESCRIPT RULES
+        // TypeScript-specific linting and type safety
+        // Documentation: https://typescript-eslint.io/rules/
+        // ============================================================
+        // Type safety
+        "@typescript-eslint/no-explicit-any": "warn",
+        // Warn on any usage (allow when necessary)
+        // Note: Type-checked rules (no-unsafe-*) require TypeScript project configuration
+        // They are disabled here but available in recommended-type-checked preset
+        // Type annotations
+        "@typescript-eslint/explicit-function-return-type": "off",
+        // Too strict - TS can infer return types
+        "@typescript-eslint/explicit-module-boundary-types": "off",
+        // Too strict - TS can infer exports
+        "@typescript-eslint/typedef": [
+          "error",
+          {
+            arrayDestructuring: false,
+            arrowParameter: false,
+            memberVariableDeclaration: false,
+            objectDestructuring: false,
+            parameter: false,
+            propertyDeclaration: true,
+            // Require type annotations on class properties
+            variableDeclaration: false,
+            variableDeclarationIgnoreFunction: true
+          }
+        ],
+        // Require type annotations in specific places
+        // Best practices
+        "@typescript-eslint/no-unused-vars": [
+          "error",
+          {
+            argsIgnorePattern: "^_",
+            // Allow unused args prefixed with _
+            varsIgnorePattern: "^_"
+            // Allow unused vars prefixed with _
+          }
+        ],
+        "@typescript-eslint/prefer-for-of": "error",
+        // Prefer for-of over standard for loop with index
+        "@typescript-eslint/no-non-null-assertion": "warn",
+        // Warn on non-null assertions (! operator)
+        // Consistency
+        "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+        // Prefer interface over type alias
+        "@typescript-eslint/consistent-type-imports": [
+          "error",
+          {
+            prefer: "type-imports",
+            // Use import type for type-only imports
+            disallowTypeAnnotations: false
+          }
+        ],
+        // ============================================================
+        // NAMING CONVENTIONS
+        // Enforce consistent naming patterns across the codebase
+        // Documentation: https://typescript-eslint.io/rules/naming-convention/
+        //
+        // Patterns enforced:
+        // - camelCase: variables, functions, methods, parameters
+        // - PascalCase: classes, interfaces, types, enums
+        // - UPPER_CASE: constants and enum members
+        // - underscore prefix: private members, unused parameters
+        // ============================================================
+        "@typescript-eslint/naming-convention": [
+          "error",
+          // Default: camelCase for most identifiers
+          {
+            selector: "default",
+            format: ["camelCase"],
+            leadingUnderscore: "allow",
+            trailingUnderscore: "forbid"
+          },
+          // Variables: camelCase or UPPER_CASE for constants
+          {
+            selector: "variable",
+            format: ["camelCase", "UPPER_CASE", "PascalCase"],
+            // PascalCase for components
+            leadingUnderscore: "allow"
+          },
+          // Functions and methods: camelCase
+          {
+            selector: ["function", "method"],
+            format: ["camelCase"]
+          },
+          // Classes, interfaces, types, enums: PascalCase
+          {
+            selector: "typeLike",
+            format: ["PascalCase"]
+          },
+          // Type parameters: PascalCase with T prefix
+          {
+            selector: "typeParameter",
+            format: ["PascalCase"],
+            prefix: ["T"]
+          },
+          // Enum members: PascalCase or UPPER_CASE
+          {
+            selector: "enumMember",
+            format: ["PascalCase", "UPPER_CASE"]
+          },
+          // Object properties: allow camelCase, PascalCase, or UPPER_CASE (for API responses, component props, env vars)
+          {
+            selector: "property",
+            format: ["camelCase", "PascalCase", "UPPER_CASE"],
+            leadingUnderscore: "allow",
+            filter: {
+              // Allow properties with special characters (ESLint rule names, path aliases, env vars)
+              regex: "^(@|no-|prefer-|max-|vue/|import/|spaced-|react/|[A-Z_]+).*$",
+              match: false
+            }
+          },
+          // Object literal properties: allow any format (path aliases like @renderer, @main, @preload)
+          {
+            selector: "objectLiteralProperty",
+            format: null
+          },
+          // Imports: allow camelCase or PascalCase (Vue component imports)
+          {
+            selector: "import",
+            format: ["camelCase", "PascalCase"],
+            leadingUnderscore: "allow"
+          },
+          // Private class members: require underscore prefix
+          {
+            selector: "memberLike",
+            modifiers: ["private"],
+            format: ["camelCase"],
+            leadingUnderscore: "require"
+          },
+          // Unused parameters: require underscore prefix
+          {
+            selector: "parameter",
+            modifiers: ["unused"],
+            format: ["camelCase"],
+            leadingUnderscore: "require"
+          }
+        ]
+      }
+    };
+    typescript_default = typescriptPreset;
+  }
+});
+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/core/ignore-patterns.ts
+function getIgnorePatterns(customIgnores = []) {
+  return [
+    ...COMMON_IGNORE_DIRS.map((dir) => `**/${dir}/**`),
+    ...FRAMEWORK_BUILD_DIRS.map((dir) => `**/${dir}/**`),
+    ...MINIFIED_FILES.map((pattern) => `**/${pattern}`),
+    ...customIgnores
+  ];
+}
+var COMMON_IGNORE_DIRS, FRAMEWORK_BUILD_DIRS, MINIFIED_FILES, getEslintIgnores, getStylelintIgnores;
+var init_ignore_patterns = __esm({
+  "src/core/ignore-patterns.ts"() {
+    COMMON_IGNORE_DIRS = [
+      "node_modules",
+      "dist",
+      "build",
+      "out",
+      "coverage",
+      ".nyc_output"
+    ];
+    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
+    ];
+    MINIFIED_FILES = ["*.min.js", "*.min.css", "*.min.mjs"];
+    getEslintIgnores = getIgnorePatterns;
+    getStylelintIgnores = getIgnorePatterns;
+  }
+});
+
+// src/tools/eslint/presets/frameworks/svelte.ts
+var svelte_exports = {};
+__export(svelte_exports, {
+  default: () => createSveltePreset
+});
+function createSveltePreset() {
+  return [
+    ...svelte.configs["flat/recommended"],
+    {
+      files: ["**/*.svelte"],
+      languageOptions: {
+        parser: svelteParser,
+        parserOptions: {
+          parser: tseslint.parser,
+          extraFileExtensions: [".svelte"]
+        }
+      },
+      rules: {
+        // Core Svelte Best Practices (7 rules)
+        "svelte/no-at-html-tags": "error",
+        "svelte/no-target-blank": "error",
+        "svelte/no-reactive-reassign": "error",
+        "svelte/require-store-reactive-access": "error",
+        "svelte/valid-compile": "error",
+        "svelte/no-unused-svelte-ignore": "error",
+        "svelte/no-useless-mustaches": "error",
+        "svelte/require-optimized-style-attribute": "error",
+        // Svelte 5 (runes mode) - 4 rules
+        "svelte/block-lang": [
+          "error",
+          {
+            script: "ts",
+            style: null
+          }
+        ],
+        "svelte/no-dom-manipulating": "error",
+        "svelte/no-export-load-in-svelte-module-in-kit-pages": "error",
+        "svelte/no-store-async": "error",
+        // Code Style (3 rules - formatting rules removed, handled by Prettier)
+        "svelte/shorthand-attribute": "error",
+        "svelte/shorthand-directive": "error",
+        "svelte/no-spaces-around-equal-signs-in-attribute": "error"
+        // Note: svelte/html-quotes, svelte/indent, svelte/first-attribute-linebreak
+        // are formatting rules disabled by eslint-config-prettier
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_svelte = __esm({
+  "src/tools/eslint/presets/frameworks/svelte.ts"() {
+  }
+});
+
+// src/tools/eslint/presets/frameworks/solid.ts
+var solid_exports = {};
+__export(solid_exports, {
+  default: () => createSolidPreset
+});
+function createSolidPreset() {
+  return [
+    {
+      files: ["**/*.jsx", "**/*.tsx"],
+      ...solid,
+      rules: {
+        ...solid.rules,
+        // Reactive Primitives (7 rules)
+        "solid/reactivity": "error",
+        // Enforce reactive dependencies
+        "solid/no-destructure": "error",
+        // Don't destructure props (loses reactivity)
+        "solid/prefer-for": "error",
+        // Use <For> over .map()
+        "solid/no-innerhtml": ["error", { allowStatic: true }],
+        // Prevent XSS
+        "solid/event-handlers": [
+          "error",
+          {
+            // Consistent event handler naming
+            ignoreCase: false,
+            warnOnSpread: false
+          }
+        ],
+        "solid/jsx-no-undef": "error",
+        // Undefined components
+        "solid/jsx-uses-vars": "error",
+        // Mark JSX vars as used
+        // Component Best Practices (5 rules)
+        "solid/components-return-once": "error",
+        // Single return per component
+        "solid/no-unknown-namespaces": "error",
+        // Validate JSX namespaces
+        "solid/prefer-show": "error",
+        // Use <Show> over ternary
+        "solid/self-closing-comp": "error",
+        // Self-close components without children
+        "solid/style-prop": ["error", { styleProps: ["style", "css"] }]
+        // Validate style prop
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_solid = __esm({
+  "src/tools/eslint/presets/frameworks/solid.ts"() {
+  }
+});
+
+// src/tools/eslint/presets/frameworks/astro.ts
+var astro_exports = {};
+__export(astro_exports, {
+  default: () => createAstroPreset
+});
+function createAstroPreset() {
+  return [
+    ...configs.recommended,
+    ...configs["jsx-a11y-recommended"],
+    {
+      files: ["**/*.astro"],
+      rules: {
+        // Component Best Practices (5 rules)
+        "astro/no-conflict-set-directives": "error",
+        // Avoid conflicting set directives
+        "astro/no-unused-define-vars-in-style": "error",
+        // Remove unused CSS variables
+        "astro/no-deprecated-astro-canonicalurl": "error",
+        // Use new canonical URL API
+        "astro/no-deprecated-astro-fetchcontent": "error",
+        // Use new content collections
+        "astro/no-deprecated-astro-resolve": "error",
+        // Use new module resolution
+        // Template Syntax (3 rules - formatting rules removed, handled by Prettier)
+        "astro/valid-compile": "error",
+        // Ensure valid Astro syntax
+        "astro/no-set-html-directive": "warn",
+        // Warn about XSS risk
+        "astro/prefer-class-list-directive": "error"
+        // Use class:list over className
+        // Note: astro/semi is a formatting rule disabled by eslint-config-prettier
+        // Accessibility (included from jsx-a11y-recommended preset)
+        // - alt-text, click-events-have-key-events, etc.
+      }
+    },
+    // Disable all formatting rules that conflict with Prettier
+    // This must be last to override any formatting rules from above
+    prettierConfig
+  ];
+}
+var init_astro = __esm({
+  "src/tools/eslint/presets/frameworks/astro.ts"() {
+  }
+});
+
+// src/tools/eslint/index.ts
+var eslint_exports = {};
+__export(eslint_exports, {
+  createEslintConfig: () => createEslintConfig,
+  default: () => eslint_default
+});
+async function addFrameworkConfig(config, framework) {
+  switch (framework) {
+    case "react":
+      config.push(...createReactPreset());
+      break;
+    case "vue":
+      config.push(...createVuePreset());
+      break;
+    case "svelte": {
+      const { default: createSveltePreset2 } = await Promise.resolve().then(() => (init_svelte(), svelte_exports));
+      config.push(...createSveltePreset2());
+      break;
+    }
+    case "solid": {
+      const { default: createSolidPreset2 } = await Promise.resolve().then(() => (init_solid(), solid_exports));
+      config.push(...createSolidPreset2());
+      break;
+    }
+    case "astro": {
+      const { default: createAstroPreset2 } = await Promise.resolve().then(() => (init_astro(), astro_exports));
+      config.push(...createAstroPreset2());
+      break;
+    }
+    case "vanilla":
+      config.push(...createVanillaPreset());
+      break;
+    case "node":
+      config.push(...createNodePreset());
+      break;
+    case "angular":
+      config.push(...createAngularPreset());
+      break;
+    default:
+      console.warn(`\u26A0\uFE0F  Unknown framework "${framework}", defaulting to vanilla JavaScript`);
+      config.push(...createVanillaPreset());
+      break;
+  }
+}
+function getEnvironmentConfig(environment) {
+  switch (environment) {
+    case "node":
+      return node_default;
+    case "universal":
+      return universal_default;
+    case "browser":
+    default:
+      return browser_default;
+  }
+}
+function addTypeScriptConfig(config) {
+  config.push(...tseslint.configs.recommended);
+  config.push({
+    files: SOURCE_FILES,
+    ...typescript_default
+  });
+  config.push({
+    files: ["**/*.d.ts"],
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off"
+    }
+  });
+  config.push({
+    files: ["**/*.js"],
+    rules: {
+      "@typescript-eslint/no-var-requires": "off"
+    }
+  });
+}
+function addOverrides(config, options) {
+  config.push({
+    files: ["tests/**/*.{js,ts,jsx,tsx,vue,svelte,astro}"],
+    rules: {
+      "no-console": "off",
+      "max-lines-per-function": "off",
+      complexity: "off",
+      "max-statements": "off",
+      "max-nested-callbacks": "off",
+      "no-magic-numbers": "off",
+      "@typescript-eslint/no-explicit-any": "off"
+    }
+  });
+  config.push({
+    files: ["**/bin/**/*.js", "**/scripts/**/*.js"],
+    languageOptions: {
+      globals: {
+        ...node_default.languageOptions?.globals
+      }
+    },
+    rules: {
+      "no-console": "off",
+      "max-lines-per-function": "off"
+    }
+  });
+  if (options.rules && Object.keys(options.rules).length > 0) {
+    config.push({
+      files: SOURCE_FILES,
+      rules: options.rules
+    });
+  }
+}
+async function createEslintConfig(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const detected = autoDetect(cwd);
+  const framework = options.framework === "auto" || !options.framework ? detected.framework : options.framework;
+  const environment = options.environment === "auto" || !options.environment ? detected.environment : options.environment;
+  const typescript = options.typescript === "auto" || options.typescript === void 0 ? detected.typescript : options.typescript;
+  console.log(
+    `\u{1F4E6} ESLint Config: ${framework} | ${environment} | TypeScript: ${typescript ? "Yes" : "No"}`
+  );
+  if (framework === "angular") {
+    console.warn(
+      "\n\u26A0\uFE0F  Angular detected. This package provides basic TypeScript linting.\n   For Angular-specific rules, install: @angular-eslint/eslint-plugin\n   See: https://github.com/angular-eslint/angular-eslint\n"
+    );
+  }
+  const defaultIgnorePaths = getEslintIgnores();
+  const allIgnorePaths = [...defaultIgnorePaths, ...options.ignorePaths || []];
+  const config = [];
+  config.push({ ignores: allIgnorePaths });
+  config.push(js.configs.recommended);
+  if (typescript) {
+    addTypeScriptConfig(config);
+  }
+  const envConfig = getEnvironmentConfig(environment);
+  config.push({
+    files: SOURCE_FILES,
+    ...envConfig
+  });
+  config.push({
+    files: SOURCE_FILES,
+    ...base_default
+  });
+  config.push({
+    files: SOURCE_FILES,
+    ...imports_default
+  });
+  await addFrameworkConfig(config, framework);
+  addOverrides(config, options);
+  return config;
+}
+var SOURCE_FILES, eslint_default;
+var init_eslint = __esm({
+  "src/tools/eslint/index.ts"() {
+    init_base();
+    init_browser();
+    init_node();
+    init_universal();
+    init_angular();
+    init_node2();
+    init_react();
+    init_vanilla();
+    init_vue();
+    init_imports();
+    init_typescript();
+    init_detectors();
+    init_ignore_patterns();
+    SOURCE_FILES = [
+      "**/*.js",
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.vue",
+      "**/*.jsx",
+      "**/*.svelte",
+      "**/*.astro"
+    ];
+    eslint_default = createEslintConfig;
+  }
+});
+
+// src/tools/prettier/presets/base.ts
+var basePreset2, base_default2;
+var init_base2 = __esm({
+  "src/tools/prettier/presets/base.ts"() {
+    basePreset2 = {
+      // Code style
+      semi: false,
+      singleQuote: true,
+      trailingComma: "none",
+      // Line formatting
+      printWidth: 100,
+      tabWidth: 2,
+      useTabs: false,
+      proseWrap: "preserve",
+      // Syntax preferences
+      arrowParens: "avoid",
+      bracketSpacing: true,
+      bracketSameLine: false,
+      singleAttributePerLine: true,
+      // Line endings
+      endOfLine: "lf"
+    };
+    base_default2 = basePreset2;
+  }
+});
+
+// src/tools/prettier/presets/frameworks/astro.ts
+var astroPreset, astro_default;
+var init_astro2 = __esm({
+  "src/tools/prettier/presets/frameworks/astro.ts"() {
+    astroPreset = {
+      // Use Astro plugin for .astro files
+      plugins: ["prettier-plugin-astro"]
+      // Astro plugin handles all formatting automatically
+      // No additional options needed
+    };
+    astro_default = astroPreset;
+  }
+});
+
+// src/tools/prettier/presets/frameworks/react.ts
+var reactPreset, react_default;
+var init_react2 = __esm({
+  "src/tools/prettier/presets/frameworks/react.ts"() {
+    reactPreset = {
+      // JSX-specific options
+      // Use double quotes in JSX attributes (React convention)
+      jsxSingleQuote: false
+      // Note: bracketSameLine is now in base preset
+    };
+    react_default = reactPreset;
+  }
+});
+
+// src/tools/prettier/presets/frameworks/svelte.ts
+var sveltePreset, svelte_default;
+var init_svelte2 = __esm({
+  "src/tools/prettier/presets/frameworks/svelte.ts"() {
+    sveltePreset = {
+      // Use Svelte plugin for .svelte files
+      plugins: ["prettier-plugin-svelte"],
+      // Component block ordering: options, scripts, markup, styles
+      // This is the standard Svelte convention
+      svelteSortOrder: "options-scripts-markup-styles",
+      // Don't enforce strict mode (allow flexibility)
+      svelteStrictMode: false,
+      // Indent <script> and <style> tags for consistency
+      svelteIndentScriptAndStyle: true
+    };
+    svelte_default = sveltePreset;
+  }
+});
+
+// src/tools/prettier/presets/frameworks/vanilla.ts
+var vanillaPreset, vanilla_default;
+var init_vanilla2 = __esm({
+  "src/tools/prettier/presets/frameworks/vanilla.ts"() {
+    vanillaPreset = {
+      // No framework-specific options needed
+      // Base preset provides everything required
+    };
+    vanilla_default = vanillaPreset;
+  }
+});
+
+// src/tools/prettier/presets/frameworks/vue.ts
+var vuePreset, vue_default;
+var init_vue2 = __esm({
+  "src/tools/prettier/presets/frameworks/vue.ts"() {
+    vuePreset = {
+      // Don't indent <script> and <style> tags
+      // This keeps them aligned with <template> for consistency
+      vueIndentScriptAndStyle: false,
+      // Ignore whitespace sensitivity in HTML
+      // Prevents issues with Vue's template whitespace handling
+      htmlWhitespaceSensitivity: "ignore"
+    };
+    vue_default = vuePreset;
+  }
+});
+
+// src/tools/prettier/index.ts
+var prettier_exports = {};
+__export(prettier_exports, {
+  createPrettierConfig: () => createPrettierConfig,
+  default: () => prettier_default
+});
+async function createPrettierConfig(options = {}) {
+  const { framework: explicitFramework = "auto", cwd = process.cwd(), ...userOverrides } = options;
+  const framework = explicitFramework === "auto" ? autoDetect(cwd).framework : explicitFramework;
+  const config = { ...base_default2 };
+  switch (framework) {
+    case "vue": {
+      Object.assign(config, vue_default);
+      console.warn("\u{1F4DD} Prettier: Detected Vue.js - using Vue plugin");
+      break;
+    }
+    case "react": {
+      Object.assign(config, react_default);
+      console.warn("\u{1F4DD} Prettier: Detected React - using JSX conventions");
+      break;
+    }
+    case "solid": {
+      Object.assign(config, react_default);
+      console.warn("\u{1F4DD} Prettier: Detected Solid.js - using JSX conventions");
+      break;
+    }
+    case "svelte": {
+      Object.assign(config, svelte_default);
+      console.warn("\u{1F4DD} Prettier: Detected Svelte - using Svelte plugin");
+      break;
+    }
+    case "astro": {
+      Object.assign(config, astro_default);
+      console.warn("\u{1F4DD} Prettier: Detected Astro - using Astro plugin");
+      break;
+    }
+    case "angular":
+    case "node":
+    case "vanilla": {
+      Object.assign(config, vanilla_default);
+      console.warn(`\u{1F4DD} Prettier: Detected ${framework} - using base configuration`);
+      break;
+    }
+    default: {
+      console.warn(`\u26A0\uFE0F  Unknown framework "${framework}", using base configuration`);
+      Object.assign(config, vanilla_default);
+    }
+  }
+  const { framework: _f, cwd: _c, customIgnores: _ci, ...prettierOverrides } = userOverrides;
+  Object.assign(config, prettierOverrides);
+  return config;
+}
+var prettier_default;
+var init_prettier = __esm({
+  "src/tools/prettier/index.ts"() {
+    init_base2();
+    init_astro2();
+    init_react2();
+    init_svelte2();
+    init_vanilla2();
+    init_vue2();
+    init_detectors();
+    prettier_default = createPrettierConfig;
+  }
+});
+
+// src/tools/stylelint/presets/base.ts
+var basePreset3, base_default3;
+var init_base3 = __esm({
+  "src/tools/stylelint/presets/base.ts"() {
+    basePreset3 = {
+      extends: ["stylelint-config-standard"],
+      rules: {
+        // Color rules
+        "color-hex-length": "short",
+        "color-named": "never",
+        // Property rules
+        "declaration-block-no-redundant-longhand-properties": true,
+        "shorthand-property-no-redundant-values": true,
+        // Selector rules
+        "selector-max-id": 0,
+        "selector-no-qualifying-type": true,
+        "selector-class-pattern": [
+          "^[a-z]([a-z0-9-]+)?(__([a-z0-9]+-?)+)?(--([a-z0-9]+-?)+){0,2}$",
+          {
+            message: "Expected class selector to be kebab-case or BEM format"
+          }
+        ],
+        // Nesting
+        "max-nesting-depth": 3,
+        // Specificity
+        "no-descending-specificity": null,
+        // At-rules
+        "at-rule-no-unknown": [
+          true,
+          {
+            ignoreAtRules: ["tailwind", "apply", "variants", "responsive", "screen"]
+          }
+        ]
+      }
+    };
+    base_default3 = basePreset3;
+  }
+});
+
+// src/tools/stylelint/presets/css-modules.ts
+var cssModulesPreset, css_modules_default;
+var init_css_modules = __esm({
+  "src/tools/stylelint/presets/css-modules.ts"() {
+    cssModulesPreset = {
+      rules: {
+        // Allow CSS Modules pseudo-classes
+        "selector-pseudo-class-no-unknown": [
+          true,
+          {
+            ignorePseudoClasses: ["global", "local", "export", "import"]
+          }
+        ],
+        // Allow @value (CSS Modules constants)
+        "at-rule-no-unknown": [
+          true,
+          {
+            ignoreAtRules: ["value"]
+          }
+        ],
+        // Allow 'composes' property (CSS Modules composition)
+        "property-no-unknown": [
+          true,
+          {
+            ignoreProperties: ["composes", "compose-with"]
+          }
+        ],
+        // CSS Modules often use camelCase
+        "selector-class-pattern": null
+        // Disable pattern check for modules
+      }
+    };
+    css_modules_default = cssModulesPreset;
+  }
+});
+
+// src/tools/stylelint/presets/frameworks/react.ts
+var reactPreset2, react_default2;
+var init_react3 = __esm({
+  "src/tools/stylelint/presets/frameworks/react.ts"() {
+    reactPreset2 = {
+      // No special rules needed for React/Solid CSS files
+      // They use standard CSS, so base preset is sufficient
+      rules: {}
+    };
+    react_default2 = reactPreset2;
+  }
+});
+
+// src/tools/stylelint/presets/frameworks/svelte.ts
+var sveltePreset2, svelte_default2;
+var init_svelte3 = __esm({
+  "src/tools/stylelint/presets/frameworks/svelte.ts"() {
+    sveltePreset2 = {
+      extends: ["stylelint-config-standard"],
+      overrides: [
+        {
+          files: ["**/*.svelte"],
+          customSyntax: "postcss-html"
+        }
+      ],
+      rules: {
+        // Allow Svelte :global() pseudo-class
+        "selector-pseudo-class-no-unknown": [
+          true,
+          {
+            ignorePseudoClasses: ["global"]
+          }
+        ]
+      }
+    };
+    svelte_default2 = sveltePreset2;
+  }
+});
+
+// src/tools/stylelint/presets/frameworks/vue.ts
+var vuePreset2, vue_default2;
+var init_vue3 = __esm({
+  "src/tools/stylelint/presets/frameworks/vue.ts"() {
+    vuePreset2 = {
+      extends: ["stylelint-config-standard-vue"],
+      overrides: [
+        {
+          files: ["**/*.vue"],
+          customSyntax: "postcss-html"
+        }
+      ],
+      rules: {
+        // Allow Vue-specific pseudo-classes
+        "selector-pseudo-class-no-unknown": [
+          true,
+          {
+            ignorePseudoClasses: ["deep", "global", "slotted"]
+          }
+        ],
+        // Allow Vue-specific pseudo-elements
+        "selector-pseudo-element-no-unknown": [
+          true,
+          {
+            ignorePseudoElements: ["v-deep", "v-global", "v-slotted"]
+          }
+        ]
+      }
+    };
+    vue_default2 = vuePreset2;
+  }
+});
+
+// src/tools/stylelint/presets/scss.ts
+var scssPreset, scss_default;
+var init_scss = __esm({
+  "src/tools/stylelint/presets/scss.ts"() {
+    scssPreset = {
+      extends: ["stylelint-config-standard-scss"],
+      rules: {
+        // Color rules
+        "color-hex-length": "short",
+        // Variables
+        "scss/dollar-variable-colon-space-after": "always",
+        "scss/dollar-variable-colon-space-before": "never",
+        "scss/dollar-variable-pattern": [
+          "^[a-z][a-zA-Z0-9]*(-[a-z][a-zA-Z0-9]*)*$",
+          {
+            message: "Expected variable to be kebab-case"
+          }
+        ],
+        // Operators
+        "scss/operator-no-newline-after": true,
+        "scss/operator-no-unspaced": true,
+        // Nesting
+        "max-nesting-depth": 4,
+        // Allow one more level for SCSS
+        // At-rules (allow Tailwind if present)
+        "scss/at-rule-no-unknown": [
+          true,
+          {
+            ignoreAtRules: ["tailwind", "apply", "variants", "responsive", "screen", "layer"]
+          }
+        ],
+        // Mixins
+        "scss/at-mixin-pattern": [
+          "^[a-z][a-zA-Z0-9]*(-[a-z][a-zA-Z0-9]*)*$",
+          {
+            message: "Expected mixin name to be kebab-case"
+          }
+        ],
+        // Functions
+        "scss/at-function-pattern": [
+          "^[a-z][a-zA-Z0-9]*(-[a-z][a-zA-Z0-9]*)*$",
+          {
+            message: "Expected function name to be kebab-case"
+          }
+        ],
+        // Placeholder selectors
+        "scss/percent-placeholder-pattern": [
+          "^[a-z][a-zA-Z0-9]*(-[a-z][a-zA-Z0-9]*)*$",
+          {
+            message: "Expected placeholder to be kebab-case"
+          }
+        ],
+        // Selector rules (inherit from base)
+        "selector-max-id": 0,
+        "selector-no-qualifying-type": true,
+        "selector-class-pattern": [
+          "^[a-z]([a-z0-9-]+)?(__([a-z0-9]+-?)+)?(--([a-z0-9]+-?)+){0,2}$",
+          {
+            message: "Expected class selector to be kebab-case or BEM format"
+          }
+        ],
+        // Disable some rules that conflict with SCSS
+        "no-descending-specificity": null
+      }
+    };
+    scss_default = scssPreset;
+  }
+});
+
+// src/tools/stylelint/presets/tailwind.ts
+var tailwindPreset, tailwind_default;
+var init_tailwind = __esm({
+  "src/tools/stylelint/presets/tailwind.ts"() {
+    tailwindPreset = {
+      // Note: We don't extend stylelint-config-tailwindcss because it's too opinionated
+      // Instead, we selectively disable conflicting rules
+      rules: {
+        // Allow Tailwind at-rules
+        "at-rule-no-unknown": [
+          true,
+          {
+            ignoreAtRules: ["tailwind", "apply", "layer", "variants", "responsive", "screen", "config"]
+          }
+        ],
+        // Allow Tailwind functions
+        "function-no-unknown": [
+          true,
+          {
+            ignoreFunctions: ["theme", "screen"]
+          }
+        ],
+        // Disable rules that conflict with Tailwind's utility classes
+        "selector-class-pattern": null,
+        // Tailwind uses various patterns
+        "selector-max-id": null,
+        // Allow IDs (though not recommended)
+        "no-descending-specificity": null,
+        // Utility classes have complex specificity
+        "declaration-block-no-redundant-longhand-properties": null,
+        // Utilities may look redundant
+        // Allow unknown properties (Tailwind CSS variables)
+        "property-no-unknown": [
+          true,
+          {
+            ignoreProperties: ["/^--/"]
+            // Allow CSS custom properties
+          }
+        ]
+      }
+    };
+    tailwind_default = tailwindPreset;
+  }
+});
+
+// src/tools/stylelint/index.ts
+var stylelint_exports = {};
+__export(stylelint_exports, {
+  createStylelintConfig: () => createStylelintConfig,
+  default: () => stylelint_default
+});
+function normalizeExtends(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function mergeArrays(target, source) {
+  let targetArray;
+  if (Array.isArray(target)) {
+    targetArray = target;
+  } else if (target) {
+    targetArray = [target];
+  } else {
+    targetArray = [];
+  }
+  let sourceArray;
+  if (Array.isArray(source)) {
+    sourceArray = source;
+  } else if (source) {
+    sourceArray = [source];
+  } else {
+    sourceArray = [];
+  }
+  return [...targetArray, ...sourceArray];
+}
+function mergePreset(config, preset) {
+  if (preset.extends) {
+    const presetExtends = normalizeExtends(preset.extends);
+    const configExtends = normalizeExtends(config.extends);
+    config.extends = [...configExtends, ...presetExtends];
+  }
+  if (preset.overrides) {
+    config.overrides = [...config.overrides || [], ...preset.overrides];
+  }
+  if (preset.rules) {
+    config.rules = { ...config.rules, ...preset.rules };
+  }
+}
+function applyUserOverrides(config, userOverrides) {
+  if (userOverrides.extends) {
+    config.extends = mergeArrays(config.extends, userOverrides.extends);
+    delete userOverrides.extends;
+  }
+  if (userOverrides.plugins) {
+    config.plugins = mergeArrays(config.plugins, userOverrides.plugins);
+    delete userOverrides.plugins;
+  }
+  if (userOverrides.overrides) {
+    config.overrides = mergeArrays(
+      config.overrides,
+      userOverrides.overrides
+    );
+    delete userOverrides.overrides;
+  }
+  if (userOverrides.rules) {
+    config.rules = { ...config.rules, ...userOverrides.rules };
+    delete userOverrides.rules;
+  }
+  Object.assign(config, userOverrides);
+}
+async function createStylelintConfig(options = {}) {
+  const {
+    framework: explicitFramework = "auto",
+    cssType: explicitCssType = "auto",
+    cwd = process.cwd(),
+    ...userOverrides
+  } = options;
+  const framework = explicitFramework === "auto" ? autoDetect(cwd).framework : explicitFramework;
+  const cssType = explicitCssType === "auto" ? detectCssType(cwd) : explicitCssType;
+  let cssTypeResult;
+  if (typeof cssType === "string") {
+    cssTypeResult = cssType === "scss" ? { preprocessor: "scss", tailwind: false, modules: false, postcss: false } : null;
+  } else {
+    cssTypeResult = cssType;
+  }
+  const config = cssTypeResult?.preprocessor === "scss" ? { ...scss_default, customSyntax: "postcss-scss" } : { ...base_default3 };
+  config.ignoreFiles = getStylelintIgnores();
+  if (cssTypeResult?.tailwind) {
+    mergePreset(config, tailwind_default);
+  }
+  if ((framework === "react" || framework === "solid") && !cssTypeResult?.tailwind) {
+    mergePreset(config, css_modules_default);
+  }
+  let cssTypeDesc = cssTypeResult?.preprocessor === "scss" ? "SCSS" : "CSS";
+  if (cssTypeResult?.tailwind) cssTypeDesc += " + Tailwind";
+  if ((framework === "react" || framework === "solid") && !cssTypeResult?.tailwind) {
+    cssTypeDesc += " Modules";
+  }
+  switch (framework) {
+    case "vue": {
+      mergePreset(config, vue_default2);
+      console.warn(`\u{1F3A8} Stylelint: Detected Vue.js - linting .vue component styles (${cssTypeDesc})`);
+      break;
+    }
+    case "svelte": {
+      mergePreset(config, svelte_default2);
+      console.warn(
+        `\u{1F3A8} Stylelint: Detected Svelte - linting .svelte component styles (${cssTypeDesc})`
+      );
+      break;
+    }
+    case "react":
+    case "solid": {
+      mergePreset(config, react_default2);
+      console.warn(
+        `\u{1F3A8} Stylelint: Detected ${framework} - linting ${cssTypeDesc} (CSS-in-JS uses ESLint)`
+      );
+      break;
+    }
+    case "angular":
+    case "node":
+    case "vanilla":
+    case "astro": {
+      console.warn(`\u{1F3A8} Stylelint: Detected ${framework} - linting ${cssTypeDesc} files`);
+      break;
+    }
+    default: {
+      console.warn(`\u26A0\uFE0F  Unknown framework "${framework}", using base ${cssTypeDesc} linting`);
+    }
+  }
+  const {
+    framework: _f,
+    cssType: _ct,
+    cwd: _c,
+    customIgnores: _ci,
+    ...restOverrides
+  } = userOverrides;
+  applyUserOverrides(config, restOverrides);
+  return config;
+}
+var stylelint_default;
+var init_stylelint = __esm({
+  "src/tools/stylelint/index.ts"() {
+    init_base3();
+    init_css_modules();
+    init_react3();
+    init_svelte3();
+    init_vue3();
+    init_scss();
+    init_tailwind();
+    init_detectors();
+    init_ignore_patterns();
+    stylelint_default = createStylelintConfig;
+  }
+});
+
+// src/tools/semantic-release/presets/default.ts
+function createDefaultPreset(gitProvider = null) {
+  const plugins = [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm"
+  ];
+  if (gitProvider === "gitlab") {
+    plugins.push("@semantic-release/gitlab");
+  } else if (gitProvider === "github") {
+    plugins.push("@semantic-release/github");
+  }
+  plugins.push("@semantic-release/git");
+  return {
+    branches: ["main"],
+    plugins
+  };
+}
+var init_default = __esm({
+  "src/tools/semantic-release/presets/default.ts"() {
+  }
+});
+
+// src/tools/semantic-release/presets/library.ts
+function createLibraryPreset(gitProvider = null) {
+  const plugins = [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    [
+      "@semantic-release/npm",
+      {
+        pkgRoot: "."
+      }
+    ]
+  ];
+  if (gitProvider === "gitlab") {
+    plugins.push([
+      "@semantic-release/gitlab",
+      {
+        successComment: false,
+        releasedLabels: false
+      }
+    ]);
+  } else if (gitProvider === "github") {
+    plugins.push([
+      "@semantic-release/github",
+      {
+        successComment: false,
+        releasedLabels: false
+      }
+    ]);
+  }
+  plugins.push("@semantic-release/git");
+  return {
+    branches: ["main"],
+    plugins
+  };
+}
+var init_library = __esm({
+  "src/tools/semantic-release/presets/library.ts"() {
+  }
+});
+
+// src/tools/semantic-release/presets/monorepo.ts
+function createMonorepoPreset(gitProvider = null) {
+  const plugins = [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    [
+      "@semantic-release/npm",
+      {
+        pkgRoot: "packages/*"
+      }
+    ]
+  ];
+  if (gitProvider === "gitlab") {
+    plugins.push("@semantic-release/gitlab");
+  } else if (gitProvider === "github") {
+    plugins.push("@semantic-release/github");
+  }
+  plugins.push("@semantic-release/git");
+  return {
+    branches: ["main"],
+    plugins
+  };
+}
+var init_monorepo = __esm({
+  "src/tools/semantic-release/presets/monorepo.ts"() {
+  }
+});
+
+// src/tools/semantic-release/index.ts
+var semantic_release_exports = {};
+__export(semantic_release_exports, {
+  createReleaseConfig: () => createReleaseConfig,
+  default: () => semantic_release_default
+});
+async function createReleaseConfig(options = {}) {
+  const {
+    preset = "default",
+    gitProvider: explicitGitProvider = "auto",
+    cwd = process.cwd(),
+    ...userOverrides
+  } = options;
+  const gitProvider = explicitGitProvider === "auto" ? detectGitProvider(cwd) : explicitGitProvider;
+  if (gitProvider) {
+    console.warn(`\u{1F4E6} semantic-release: Detected ${gitProvider} - using ${gitProvider} plugin`);
+  } else {
+    console.warn("\u{1F4E6} semantic-release: No Git provider detected - skipping provider plugin");
+  }
+  let config;
+  switch (preset) {
+    case "library": {
+      config = createLibraryPreset(gitProvider);
+      console.warn("\u{1F4E6} semantic-release: Using library preset");
+      break;
+    }
+    case "monorepo": {
+      config = createMonorepoPreset(gitProvider);
+      console.warn("\u{1F4E6} semantic-release: Using monorepo preset");
+      break;
+    }
+    case "default": {
+      config = createDefaultPreset(gitProvider);
+      console.warn("\u{1F4E6} semantic-release: Using default preset");
+      break;
+    }
+    default: {
+      console.warn(`\u26A0\uFE0F  Unknown preset "${preset}", using default preset`);
+      config = createDefaultPreset(gitProvider);
+    }
+  }
+  const overrides = userOverrides;
+  if (overrides.branches) {
+    config.branches = overrides.branches;
+    delete overrides.branches;
+  }
+  if (overrides.plugins) {
+    config.plugins = overrides.plugins;
+    delete overrides.plugins;
+  }
+  Object.assign(config, overrides);
+  config._meta = {
+    preset,
+    gitProvider
+  };
+  return config;
+}
+var semantic_release_default;
+var init_semantic_release = __esm({
+  "src/tools/semantic-release/index.ts"() {
+    init_default();
+    init_library();
+    init_monorepo();
+    init_detectors();
+    semantic_release_default = createReleaseConfig;
+  }
+});
+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;
+  }
+}
+var init_checker_detection = __esm({
+  "src/tools/typescript/checker-detection.ts"() {
+    init_types();
+  }
+});
+
+// src/tools/typescript/presets/base.ts
+var basePreset4, base_default4;
+var init_base4 = __esm({
+  "src/tools/typescript/presets/base.ts"() {
+    basePreset4 = {
+      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_default4 = basePreset4;
+  }
+});
+
+// src/tools/typescript/presets/environments/browser.ts
+var browserPreset, browser_default2;
+var init_browser2 = __esm({
+  "src/tools/typescript/presets/environments/browser.ts"() {
+    browserPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        target: "ES2020"
+        // Good browser support
+      }
+    };
+    browser_default2 = browserPreset;
+  }
+});
+
+// src/tools/typescript/presets/environments/node.ts
+var nodePreset, node_default2;
+var init_node3 = __esm({
+  "src/tools/typescript/presets/environments/node.ts"() {
+    nodePreset = {
+      compilerOptions: {
+        lib: ["ES2024"],
+        target: "ES2024",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        types: ["node"]
+      }
+    };
+    node_default2 = nodePreset;
+  }
+});
+
+// src/tools/typescript/presets/environments/universal.ts
+var universalPreset, universal_default2;
+var init_universal2 = __esm({
+  "src/tools/typescript/presets/environments/universal.ts"() {
+    universalPreset = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        target: "ES2022",
+        types: ["node"]
+      }
+    };
+    universal_default2 = universalPreset;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/angular.ts
+var angularPreset, angular_default;
+var init_angular2 = __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 astroPreset2, astro_default2;
+var init_astro3 = __esm({
+  "src/tools/typescript/presets/frameworks/astro.ts"() {
+    astroPreset2 = {
+      compilerOptions: {
+        jsx: "react-jsx",
+        // Astro uses React-style JSX
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        types: ["astro/client"]
+      }
+    };
+    astro_default2 = astroPreset2;
+  }
+});
+
+// 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_default3;
+var init_node4 = __esm({
+  "src/tools/typescript/presets/frameworks/node.ts"() {
+    nodePreset2 = {
+      compilerOptions: {
+        lib: ["ES2022"],
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        types: ["node"]
+      }
+    };
+    node_default3 = nodePreset2;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/react.ts
+var reactPreset3, react_default3;
+var init_react4 = __esm({
+  "src/tools/typescript/presets/frameworks/react.ts"() {
+    reactPreset3 = {
+      compilerOptions: {
+        jsx: "react-jsx",
+        // Modern React 17+ automatic runtime
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      }
+    };
+    react_default3 = reactPreset3;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/solid.ts
+var solidPreset, solid_default;
+var init_solid2 = __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 sveltePreset3, svelte_default3;
+var init_svelte4 = __esm({
+  "src/tools/typescript/presets/frameworks/svelte.ts"() {
+    sveltePreset3 = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        types: ["svelte"]
+      }
+    };
+    svelte_default3 = sveltePreset3;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/vanilla.ts
+var vanillaPreset2, vanilla_default2;
+var init_vanilla3 = __esm({
+  "src/tools/typescript/presets/frameworks/vanilla.ts"() {
+    vanillaPreset2 = {
+      compilerOptions: {
+        lib: ["ES2022", "DOM", "DOM.Iterable"]
+      }
+    };
+    vanilla_default2 = vanillaPreset2;
+  }
+});
+
+// src/tools/typescript/presets/frameworks/vue.ts
+var vuePreset3, vue_default3;
+var init_vue4 = __esm({
+  "src/tools/typescript/presets/frameworks/vue.ts"() {
+    vuePreset3 = {
+      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_default3 = vuePreset3;
+  }
+});
+
+// src/tools/typescript/index.ts
+var typescript_exports = {};
+__export(typescript_exports, {
+  createTypescriptConfig: () => createTypescriptConfig,
+  default: () => typescript_default2
+});
+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 configs2 = createElectronPreset(renderer);
+    return {
+      ...configs2,
+      _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_default4);
+  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_default2;
+    case "node":
+      return node_default2;
+    case "universal":
+      return universal_default2;
+    default:
+      return {};
+  }
+}
+function loadFrameworkPreset(framework) {
+  switch (framework) {
+    case "react":
+      return react_default3;
+    case "vue":
+      return vue_default3;
+    case "svelte":
+      return svelte_default3;
+    case "solid":
+      return solid_default;
+    case "astro":
+      return astro_default2;
+    case "angular":
+      return angular_default;
+    case "node":
+      return node_default3;
+    case "vanilla":
+    default:
+      return vanilla_default2;
+  }
+}
+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_default2;
+var init_typescript2 = __esm({
+  "src/tools/typescript/index.ts"() {
+    init_checker_detection();
+    init_base4();
+    init_browser2();
+    init_node3();
+    init_universal2();
+    init_angular2();
+    init_astro3();
+    init_electron();
+    init_node4();
+    init_react4();
+    init_solid2();
+    init_svelte4();
+    init_vanilla3();
+    init_vue4();
+    init_detectors();
+    init_types();
+    VALID_RENDERERS = [
+      "react",
+      "vue",
+      "svelte",
+      "solid",
+      "astro",
+      "angular",
+      "vanilla"
+    ];
+    typescript_default2 = createTypescriptConfig;
+  }
+});
+
+// src/index.ts
+init_types();
+init_eslint();
+init_prettier();
+init_stylelint();
+init_semantic_release();
+init_typescript2();
+init_detectors();
+init_types();
+var VALID_TOOLS = [
+  "eslint",
+  "prettier",
+  "stylelint",
+  "typescript",
+  "semantic-release"
+];
+function validateToolName(tool) {
+  if (typeof tool !== "string") {
+    throw new ConfigError("Tool name must be a string", {
+      received: typeof tool,
+      validTools: VALID_TOOLS
+    });
+  }
+  if (!VALID_TOOLS.includes(tool)) {
+    throw new ConfigError(`Unknown tool: "${tool}". Supported tools: ${VALID_TOOLS.join(", ")}`, {
+      received: tool,
+      validTools: VALID_TOOLS
+    });
+  }
+}
+function validateOptions(options) {
+  if (options !== void 0 && options !== null && typeof options !== "object") {
+    throw new ConfigError("Options must be an object", {
+      received: typeof options
+    });
+  }
+}
+async function createConfig(tool, options) {
+  validateToolName(tool);
+  validateOptions(options);
+  const opts = options ?? {};
+  switch (tool) {
+    case "eslint": {
+      const { createEslintConfig: createEslintConfig2 } = await Promise.resolve().then(() => (init_eslint(), eslint_exports));
+      return createEslintConfig2(opts);
+    }
+    case "prettier": {
+      const { createPrettierConfig: createPrettierConfig2 } = await Promise.resolve().then(() => (init_prettier(), prettier_exports));
+      return createPrettierConfig2(opts);
+    }
+    case "stylelint": {
+      const { createStylelintConfig: createStylelintConfig2 } = await Promise.resolve().then(() => (init_stylelint(), stylelint_exports));
+      return createStylelintConfig2(opts);
+    }
+    case "semantic-release": {
+      const { createReleaseConfig: createReleaseConfig2 } = await Promise.resolve().then(() => (init_semantic_release(), semantic_release_exports));
+      return createReleaseConfig2(opts);
+    }
+    case "typescript": {
+      const { createTypescriptConfig: createTypescriptConfig2 } = await Promise.resolve().then(() => (init_typescript2(), typescript_exports));
+      return createTypescriptConfig2(opts);
+    }
+  }
+}
+
+export { ConfigError, autoDetect, createConfig, createEslintConfig, createPrettierConfig, createReleaseConfig, createStylelintConfig, createTypescriptConfig, detectCssType, detectElectron, detectEnvironment, detectFramework, detectGitProvider, detectTypeScript };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map