@hyperfrontend/project-scope 0.2.0 → 0.2.2

package/heuristics/framework/index.cjs.js

@@ -1,567 +1,27 @@
 'use strict';
 
-var node_path = require('node:path');
-var node_fs = require('node:fs');
-
-/**
- * Safe copies of Map built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/map
- */
-// Capture references at module initialization time
-const _Map = globalThis.Map;
-const _Reflect$2 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Map using the captured Map constructor.
- * Use this instead of `new Map()`.
- *
- * @param iterable - Optional iterable of key-value pairs.
- * @returns A new Map instance.
- */
-const createMap = (iterable) => _Reflect$2.construct(_Map, iterable ? [iterable] : []);
-
-/**
- * Safe copies of Object built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/object
- */
-// Capture references at module initialization time
-const _Object = globalThis.Object;
-/**
- * (Safe copy) Prevents modification of existing property attributes and values,
- * and prevents the addition of new properties.
- */
-const freeze = _Object.freeze;
-/**
- * (Safe copy) Returns the names of the enumerable string properties and methods of an object.
- */
-const keys = _Object.keys;
-/**
- * (Safe copy) Returns an array of key/values of the enumerable own properties of an object.
- */
-const entries = _Object.entries;
-/**
- * (Safe copy) Returns an array of values of the enumerable own properties of an object.
- */
-const values = _Object.values;
-/**
- * (Safe copy) Adds one or more properties to an object, and/or modifies attributes of existing properties.
- */
-const defineProperties = _Object.defineProperties;
-
-/**
- * Safe copies of Set built-in via factory function.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides a factory function that uses Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/set
- */
-// Capture references at module initialization time
-const _Set = globalThis.Set;
-const _Reflect$1 = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Set using the captured Set constructor.
- * Use this instead of `new Set()`.
- *
- * @param iterable - Optional iterable of values.
- * @returns A new Set instance.
- */
-const createSet = (iterable) => _Reflect$1.construct(_Set, iterable ? [iterable] : []);
-
-/**
- * Global registry of all caches for bulk operations.
- */
-const cacheRegistry = createSet();
-/**
- * Create a cache with optional TTL and size limits.
- *
- * The cache provides a simple key-value store with:
- * - Optional TTL (time-to-live) for automatic expiration
- * - Optional maxSize for limiting cache size with FIFO eviction
- * - Lazy expiration (entries are checked on access)
- *
- * @param options - Cache configuration options
- * @returns Cache instance
- *
- * @example
- * ```typescript
- * // Basic cache
- * const cache = createCache<string, number>()
- * cache.set('answer', 42)
- * cache.get('answer') // 42
- *
- * // Cache with TTL (expires after 60 seconds)
- * const ttlCache = createCache<string, object>({ ttl: 60000 })
- *
- * // Cache with max size (evicts oldest when full)
- * const lruCache = createCache<string, object>({ maxSize: 100 })
- *
- * // Combined options
- * const configCache = createCache<string, object>({
- *   ttl: 30000,
- *   maxSize: 50
- * })
- * ```
- */
-function createCache(options) {
-    const { ttl, maxSize } = options ?? {};
-    const store = createMap();
-    // Track insertion order for FIFO eviction
-    const insertionOrder = [];
-    /**
-     * Check if an entry is expired.
-     *
-     * @param entry - Cache entry to check
-     * @returns True if entry is expired
-     */
-    function isExpired(entry) {
-        if (ttl === undefined)
-            return false;
-        // eslint-disable-next-line workspace/no-unsafe-builtin-methods -- Date.now() is needed for Jest fake timers compatibility
-        return Date.now() - entry.timestamp > ttl;
-    }
-    /**
-     * Evict oldest entries to make room for new ones.
-     */
-    function evictIfNeeded() {
-        if (maxSize === undefined)
-            return;
-        while (store.size >= maxSize && insertionOrder.length > 0) {
-            const oldestKey = insertionOrder.shift();
-            if (oldestKey !== undefined) {
-                store.delete(oldestKey);
-            }
-        }
-    }
-    /**
-     * Remove key from insertion order tracking.
-     *
-     * @param key - Key to remove from order tracking
-     */
-    function removeFromOrder(key) {
-        const index = insertionOrder.indexOf(key);
-        if (index !== -1) {
-            insertionOrder.splice(index, 1);
-        }
-    }
-    const cache = {
-        get(key) {
-            const entry = store.get(key);
-            if (!entry)
-                return undefined;
-            if (isExpired(entry)) {
-                store.delete(key);
-                removeFromOrder(key);
-                return undefined;
-            }
-            return entry.value;
-        },
-        set(key, value) {
-            // If key exists, remove from order first
-            if (store.has(key)) {
-                removeFromOrder(key);
-            }
-            else {
-                // Evict if needed before adding new entry
-                evictIfNeeded();
-            }
-            // eslint-disable-next-line workspace/no-unsafe-builtin-methods -- Date.now() is needed for Jest fake timers compatibility
-            store.set(key, { value, timestamp: Date.now() });
-            insertionOrder.push(key);
-        },
-        has(key) {
-            const entry = store.get(key);
-            if (!entry)
-                return false;
-            if (isExpired(entry)) {
-                store.delete(key);
-                removeFromOrder(key);
-                return false;
-            }
-            return true;
-        },
-        delete(key) {
-            removeFromOrder(key);
-            return store.delete(key);
-        },
-        clear() {
-            store.clear();
-            insertionOrder.length = 0;
-        },
-        size() {
-            return store.size;
-        },
-        keys() {
-            return [...insertionOrder];
-        },
-    };
-    // Register cache for global operations
-    cacheRegistry.add(cache);
-    return freeze(cache);
-}
-
-/**
- * Safe copies of Array built-in static methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/array
- */
-// Capture references at module initialization time
-const _Array = globalThis.Array;
-/**
- * (Safe copy) Determines whether the passed value is an Array.
- */
-const isArray = _Array.isArray;
-
-/**
- * Safe copies of Console built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/console
- */
-// Capture references at module initialization time
-const _console = globalThis.console;
-/**
- * (Safe copy) Outputs a message to the console.
- */
-const log = _console.log.bind(_console);
-/**
- * (Safe copy) Outputs a warning message to the console.
- */
-const warn = _console.warn.bind(_console);
-/**
- * (Safe copy) Outputs an error message to the console.
- */
-const error = _console.error.bind(_console);
-/**
- * (Safe copy) Outputs an informational message to the console.
- */
-const info = _console.info.bind(_console);
-/**
- * (Safe copy) Outputs a debug message to the console.
- */
-const debug = _console.debug.bind(_console);
-/**
- * (Safe copy) Outputs a stack trace to the console.
- */
-_console.trace.bind(_console);
-/**
- * (Safe copy) Displays an interactive listing of the properties of a specified object.
- */
-_console.dir.bind(_console);
-/**
- * (Safe copy) Displays tabular data as a table.
- */
-_console.table.bind(_console);
-/**
- * (Safe copy) Writes an error message to the console if the assertion is false.
- */
-_console.assert.bind(_console);
-/**
- * (Safe copy) Clears the console.
- */
-_console.clear.bind(_console);
-/**
- * (Safe copy) Logs the number of times that this particular call to count() has been called.
- */
-_console.count.bind(_console);
-/**
- * (Safe copy) Resets the counter used with console.count().
- */
-_console.countReset.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console.
- */
-_console.group.bind(_console);
-/**
- * (Safe copy) Creates a new inline group in the console that is initially collapsed.
- */
-_console.groupCollapsed.bind(_console);
-/**
- * (Safe copy) Exits the current inline group.
- */
-_console.groupEnd.bind(_console);
-/**
- * (Safe copy) Starts a timer with a name specified as an input parameter.
- */
-_console.time.bind(_console);
-/**
- * (Safe copy) Stops a timer that was previously started.
- */
-_console.timeEnd.bind(_console);
-/**
- * (Safe copy) Logs the current value of a timer that was previously started.
- */
-_console.timeLog.bind(_console);
-
-/**
- * Safe copies of JSON built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/json
- */
-// Capture references at module initialization time
-const _JSON = globalThis.JSON;
-/**
- * (Safe copy) Converts a JavaScript Object Notation (JSON) string into an object.
- */
-const parse = _JSON.parse;
-/**
- * (Safe copy) Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
- */
-const stringify = _JSON.stringify;
-
-const registeredClasses = [];
-
-/**
- * Returns the data type of the target.
- * Uses native `typeof` operator, however, makes distinction between `null`, `array`, and `object`.
- * Also, when classes are registered via `registerClass`, it checks if objects are instance of any known registered class.
- *
- * @param target - The target to get the data type of.
- * @returns The data type of the target.
- */
-const getType = (target) => {
-    if (target === null)
-        return 'null';
-    const nativeDataType = typeof target;
-    if (nativeDataType === 'object') {
-        if (isArray(target))
-            return 'array';
-        for (const registeredClass of registeredClasses) {
-            if (target instanceof registeredClass)
-                return registeredClass.name;
-        }
-    }
-    return nativeDataType;
-};
-
-/**
- * Safe copies of Error built-ins via factory functions.
- *
- * Since constructors cannot be safely captured via Object.assign, this module
- * provides factory functions that use Reflect.construct internally.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/error
- */
-// Capture references at module initialization time
-const _Error = globalThis.Error;
-const _Reflect = globalThis.Reflect;
-/**
- * (Safe copy) Creates a new Error using the captured Error constructor.
- * Use this instead of `new Error()`.
- *
- * @param message - Optional error message.
- * @param options - Optional error options.
- * @returns A new Error instance.
- */
-const createError = (message, options) => _Reflect.construct(_Error, [message, options]);
-
-/**
- * Safe copies of Math built-in methods.
- *
- * These references are captured at module initialization time to protect against
- * prototype pollution attacks. Import only what you need for tree-shaking.
- *
- * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
- */
-// Capture references at module initialization time
-const _Math = globalThis.Math;
-/**
- * (Safe copy) Returns the smaller of zero or more numbers.
- */
-const min = _Math.min;
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that only executes the wrapped function if the condition function returns true.
- *
- * @param func - The function to be conditionally executed.
- * @param conditionFunc - A function that returns a boolean, determining if `func` should be executed.
- * @returns A wrapped version of `func` that executes conditionally.
- */
-function createConditionalExecutionFunction(func, conditionFunc) {
-    return function (...args) {
-        if (conditionFunc()) {
-            return func(...args);
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * Creates a wrapper function that silently ignores any errors thrown by the wrapped void function.
- * This function is specifically for wrapping functions that do not return a value (void functions).
- * Exceptions are swallowed without any logging or handling.
- *
- * @param func - The void function to be wrapped.
- * @returns A wrapped version of the input function that ignores errors.
- */
-function createErrorIgnoringFunction(func) {
-    return function (...args) {
-        try {
-            func(...args);
-        }
-        catch {
-            // Deliberately swallowing/ignoring the exception
-        }
-    };
-}
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/**
- * A no-operation function (noop) that does nothing regardless of the arguments passed.
- * It is designed to be as permissive as possible in its typing without using the `Function` keyword.
- *
- * @param args - Any arguments passed to the function (ignored)
- */
-const noop = (...args) => {
-    // Intentionally does nothing
-};
-
-const logLevels = ['none', 'error', 'warn', 'log', 'info', 'debug'];
-const priority = {
-    error: 4,
-    warn: 3,
-    log: 2,
-    info: 1,
-    debug: 0,
-};
-/**
- * Validates whether a given string is a valid log level.
- *
- * @param level - The log level to validate
- * @returns True if the level is valid, false otherwise
- */
-function isValidLogLevel(level) {
-    return logLevels.includes(level);
-}
-/**
- * Creates a log level configuration manager for controlling logging behavior.
- * Provides methods to get, set, and evaluate log levels based on priority.
- *
- * @param level - The initial log level (defaults to 'error')
- * @returns A configuration object with log level management methods
- * @throws {Error} When the provided level is not a valid log level
- */
-function createLogLevelConfig(level = 'error') {
-    if (!isValidLogLevel(level)) {
-        throw createError('Cannot create log level configuration with a valid default log level');
-    }
-    const state = { level };
-    const getLogLevel = () => state.level;
-    const setLogLevel = (level) => {
-        if (!isValidLogLevel(level)) {
-            throw createError(`Cannot set value '${level}' level. Expected levels are ${logLevels}.`);
-        }
-        state.level = level;
-    };
-    const shouldLog = (level) => {
-        if (state.level === 'none' || level === 'none' || !isValidLogLevel(level)) {
-            return false;
-        }
-        return priority[level] >= priority[state.level];
-    };
-    return freeze({
-        getLogLevel,
-        setLogLevel,
-        shouldLog,
-    });
-}
-
-/**
- * Creates a logger instance with configurable log level filtering.
- * Each log function is wrapped to respect the current log level setting.
- *
- * @param error - Function to handle error-level logs (required)
- * @param warn - Function to handle warning-level logs (optional, defaults to noop)
- * @param log - Function to handle standard logs (optional, defaults to noop)
- * @param info - Function to handle info-level logs (optional, defaults to noop)
- * @param debug - Function to handle debug-level logs (optional, defaults to noop)
- * @returns A frozen logger object with log methods and level control
- * @throws {ErrorLevelFn} When any provided log function is invalid
- */
-function createLogger(error, warn = noop, log = noop, info = noop, debug = noop) {
-    if (notValidLogFn(error)) {
-        throw createError(notFnMsg('error'));
-    }
-    if (notValidLogFn(warn)) {
-        throw createError(notFnMsg('warn'));
-    }
-    if (notValidLogFn(log)) {
-        throw createError(notFnMsg('log'));
-    }
-    if (notValidLogFn(info)) {
-        throw createError(notFnMsg('info'));
-    }
-    if (notValidLogFn(debug)) {
-        throw createError(notFnMsg('debug'));
-    }
-    const { setLogLevel, getLogLevel, shouldLog } = createLogLevelConfig();
-    const wrapLogFn = (fn, level) => {
-        if (fn === noop)
-            return fn;
-        const condition = () => shouldLog(level);
-        return createConditionalExecutionFunction(createErrorIgnoringFunction(fn), condition);
-    };
-    return freeze({
-        error: wrapLogFn(error, 'error'),
-        warn: wrapLogFn(warn, 'warn'),
-        log: wrapLogFn(log, 'log'),
-        info: wrapLogFn(info, 'info'),
-        debug: wrapLogFn(debug, 'debug'),
-        setLogLevel,
-        getLogLevel,
-    });
-}
-/**
- * Validates whether a given value is a valid log function.
- *
- * @param fn - The value to validate
- * @returns True if the value is not a function (invalid), false if it is valid
- */
-function notValidLogFn(fn) {
-    return getType(fn) !== 'function' && fn !== noop;
-}
-/**
- * Generates an error message for invalid log function parameters.
- *
- * @param label - The name of the log function that failed validation
- * @returns A formatted error message string
- */
-function notFnMsg(label) {
-    return `Cannot create a logger when ${label} is not a function`;
-}
-
-createLogger(error, warn, log, info, debug);
+const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.cjs.js');
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$5 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$4 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/console/index.cjs.js');
+const index_cjs_js$6 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/logging/index.cjs.js');
+const node_path = require('node:path');
+const index_cjs_js$7 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+const node_fs = require('node:fs');
+const index_cjs_js$8 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.cjs.js');
+const { isDirectory, exists } = require('../../_shared/core/fs/stat/index.cjs.js');
+const { join } = require('../../_shared/core/path/join/index.cjs.js');
+const { createCache } = require('../../_shared/core/cache/index.cjs.js');
+const { collectAllDependencies, parseVersionString, locateConfigFile, filterScriptsByCommand } = require('../../_shared/tech/shared-utils/detector-helpers/index.cjs.js');
+const { pnpmWorkspacesDetector } = require('../../_shared/tech/monorepo/pnpm-workspaces/index.cjs.js');
 
 /**
  * Global log level registry.
  * Tracks all created scoped loggers to allow global log level changes.
  */
-const loggerRegistry = createSet();
+const loggerRegistry = index_cjs_js.createSet();
 /** Redacted placeholder for sensitive values */
 const REDACTED = '[REDACTED]';
 /**
@@ -595,17 +55,24 @@ function isSensitiveKey(key) {
  *
  * @param obj - Object to sanitize
  * @returns New object with sensitive values redacted
+ *
+ * @example Sanitizing sensitive data
+ * ```typescript
+ * const config = { apiKey: 'secret123', endpoint: 'https://api.example.com' }
+ * const safe = sanitize(config)
+ * // => { apiKey: '[REDACTED]', endpoint: 'https://api.example.com' }
+ * ```
  */
 function sanitize(obj) {
     if (obj === null || obj === undefined) {
         return obj;
     }
-    if (isArray(obj)) {
+    if (index_cjs_js$5.isArray(obj)) {
         return obj.map((item) => sanitize(item));
     }
     if (typeof obj === 'object') {
         const result = {};
-        for (const [key, value] of entries(obj)) {
+        for (const [key, value] of index_cjs_js$2.entries(obj)) {
             if (isSensitiveKey(key)) {
                 result[key] = REDACTED;
             }
@@ -630,9 +97,9 @@ function sanitize(obj) {
  */
 function formatMessage(namespace, message, meta) {
     const prefix = `[${namespace}]`;
-    if (meta && keys(meta).length > 0) {
+    if (meta && index_cjs_js$2.keys(meta).length > 0) {
         const sanitizedMeta = sanitize(meta);
-        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+        return `${prefix} ${message} ${index_cjs_js$6.stringify(sanitizedMeta)}`;
     }
     return `${prefix} ${message}`;
 }
@@ -645,7 +112,7 @@ function formatMessage(namespace, message, meta) {
  * @param options - Logger configuration options
  * @returns A configured scoped logger instance
  *
- * @example
+ * @example Creating a scoped logger
  * ```typescript
  * const logger = createScopedLogger('project-scope')
  * logger.setLogLevel('debug')
@@ -660,16 +127,13 @@ function formatMessage(namespace, message, meta) {
  */
 function createScopedLogger(namespace, options = {}) {
     const { level = 'error', sanitizeSecrets = true } = options;
-    // Create wrapper functions that add namespace prefix and sanitization
     const createLogFn = (baseFn) => (message, meta) => {
         const processedMeta = sanitizeSecrets && meta ? sanitize(meta) : meta;
         baseFn(formatMessage(namespace, message, processedMeta));
     };
-    // Create base logger with wrapped functions
-    const baseLogger = createLogger(createLogFn(error), createLogFn(warn), createLogFn(log), createLogFn(info), createLogFn(debug));
-    // Set initial log level (use global override if set)
+    const baseLogger = index_cjs_js$3.createLogger(createLogFn(index_cjs_js$4.error), createLogFn(index_cjs_js$4.warn), createLogFn(index_cjs_js$4.log), createLogFn(index_cjs_js$4.info), createLogFn(index_cjs_js$4.debug));
     baseLogger.setLogLevel(level);
-    const scopedLogger = freeze({
+    const scopedLogger = index_cjs_js$2.freeze({
         error: (message, meta) => baseLogger.error(message, meta),
         warn: (message, meta) => baseLogger.warn(message, meta),
         log: (message, meta) => baseLogger.log(message, meta),
@@ -678,7 +142,6 @@ function createScopedLogger(namespace, options = {}) {
         setLogLevel: baseLogger.setLogLevel,
         getLogLevel: baseLogger.getLogLevel,
     });
-    // Register logger for global level management
     loggerRegistry.add(scopedLogger);
     return scopedLogger;
 }
@@ -686,7 +149,7 @@ function createScopedLogger(namespace, options = {}) {
  * Default logger instance for the project-scope library.
  * Use this for general logging within the library.
  *
- * @example
+ * @example Using the default logger
  * ```typescript
  * import { logger } from '@hyperfrontend/project-scope/core'
  *
@@ -704,10 +167,19 @@ createScopedLogger('project-scope:fs');
  * @param code - The category code for this type of filesystem failure
  * @param context - Additional context including path, operation, and cause
  * @returns A configured Error object with code and context properties
+ *
+ * @example Creating a file system error
+ * ```typescript
+ * throw createFileSystemError(
+ *   'Cannot read file',
+ *   'FS_READ_ERROR',
+ *   { path: './missing.txt', operation: 'read' }
+ * )
+ * ```
  */
 function createFileSystemError(message, code, context) {
-    const error = createError(message);
-    defineProperties(error, {
+    const error = index_cjs_js$7.createError(message);
+    index_cjs_js$2.defineProperties(error, {
         code: { value: code, enumerable: true },
         context: { value: context, enumerable: true },
     });
@@ -719,6 +191,14 @@ function createFileSystemError(message, code, context) {
  * @param filePath - Path to file
  * @param encoding - File encoding (default: utf-8)
  * @returns File contents or null if file doesn't exist
+ *
+ * @example Reading file if it exists
+ * ```typescript
+ * const content = readFileIfExists('./optional-config.json')
+ * if (content) {
+ *   // File existed, use content
+ * }
+ * ```
  */
 function readFileIfExists(filePath, encoding = 'utf-8') {
     if (!node_fs.existsSync(filePath)) {
@@ -732,56 +212,6 @@ function readFileIfExists(filePath, encoding = 'utf-8') {
     }
 }
 
-createScopedLogger('project-scope:fs:write');
-
-/**
- * Get file stats with error handling.
- *
- * @param filePath - Path to file
- * @param followSymlinks - Whether to follow symlinks (default: true)
- * @returns File stats or null if path doesn't exist
- */
-function getFileStat(filePath, followSymlinks = true) {
-    if (!node_fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const stat = followSymlinks ? node_fs.statSync(filePath) : node_fs.lstatSync(filePath);
-        return {
-            isFile: stat.isFile(),
-            isDirectory: stat.isDirectory(),
-            isSymlink: stat.isSymbolicLink(),
-            size: stat.size,
-            created: stat.birthtime,
-            modified: stat.mtime,
-            accessed: stat.atime,
-            mode: stat.mode,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Check if path is a directory.
- *
- * @param dirPath - Path to check
- * @returns True if path is a directory
- */
-function isDirectory(dirPath) {
-    const stats = getFileStat(dirPath);
-    return stats?.isDirectory ?? false;
-}
-/**
- * Check if path exists.
- *
- * @param filePath - Path to check
- * @returns True if path exists
- */
-function exists(filePath) {
-    return node_fs.existsSync(filePath);
-}
-
 const fsDirLogger = createScopedLogger('project-scope:fs:dir');
 /**
  * List immediate contents of a directory.
@@ -790,7 +220,7 @@ const fsDirLogger = createScopedLogger('project-scope:fs:dir');
  * @returns Array of entries with metadata for each file/directory
  * @throws {Error} If directory doesn't exist or isn't a directory
  *
- * @example
+ * @example Listing directory contents
  * ```typescript
  * import { readDirectory } from '@hyperfrontend/project-scope'
  *
@@ -831,19 +261,10 @@ function readDirectory(dirPath) {
     }
 }
 
-/**
- * Join path segments.
- * Uses platform-specific separators (e.g., / or \).
- *
- * @param paths - Path segments to join
- * @returns Joined path
- */
-function join(...paths) {
-    return node_path.join(...paths);
-}
-
 createScopedLogger('project-scope:fs:traversal');
 
+createScopedLogger('project-scope:fs:write');
+
 const packageLogger = createScopedLogger('project-scope:project:package');
 /**
  * Verifies that a value is an object with only string values,
@@ -855,7 +276,7 @@ const packageLogger = createScopedLogger('project-scope:project:package');
 function isStringRecord(value) {
     if (typeof value !== 'object' || value === null)
         return false;
-    return values(value).every((v) => typeof v === 'string');
+    return index_cjs_js$2.values(value).every((v) => typeof v === 'string');
 }
 /**
  * Extracts and normalizes the workspaces field from package.json,
@@ -865,12 +286,12 @@ function isStringRecord(value) {
  * @returns Normalized workspace patterns or undefined if invalid
  */
 function parseWorkspaces(value) {
-    if (isArray(value) && value.every((v) => typeof v === 'string')) {
+    if (index_cjs_js$5.isArray(value) && value.every((v) => typeof v === 'string')) {
         return value;
     }
     if (typeof value === 'object' && value !== null) {
         const obj = value;
-        if (isArray(obj['packages'])) {
+        if (index_cjs_js$5.isArray(obj['packages'])) {
             return { packages: obj['packages'] };
         }
     }
@@ -884,7 +305,7 @@ function parseWorkspaces(value) {
  */
 function validatePackageJson(data) {
     if (typeof data !== 'object' || data === null) {
-        throw createError('package.json must be an object');
+        throw index_cjs_js$7.createError('package.json must be an object');
     }
     const pkg = data;
     return {
@@ -913,6 +334,16 @@ function validatePackageJson(data) {
  *
  * @param projectPath - Project directory path or path to package.json
  * @returns Parsed package.json or null if not found
+ *
+ * @example Reading package.json if it exists
+ * ```typescript
+ * import { readPackageJsonIfExists } from '@hyperfrontend/project-scope'
+ *
+ * const pkg = readPackageJsonIfExists('/path/to/project')
+ * if (pkg) {
+ *   console.log('Found:', pkg.name)
+ * }
+ * ```
  */
 function readPackageJsonIfExists(projectPath) {
     const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : node_path.join(projectPath, 'package.json');
@@ -922,7 +353,7 @@ function readPackageJsonIfExists(projectPath) {
         return null;
     }
     try {
-        const validated = validatePackageJson(parse(content));
+        const validated = validatePackageJson(index_cjs_js$6.parse(content));
         packageLogger.debug('Package.json loaded', { path: packageJsonPath, name: validated.name });
         return validated;
     }
@@ -933,80 +364,31 @@ function readPackageJsonIfExists(projectPath) {
 }
 
 /**
- * Get combined dependencies from package.json.
- * Merges dependencies, devDependencies, peerDependencies, and optionalDependencies.
+ * Detect Express in project.
  *
- * @param packageJson - The package.json object to extract dependencies from
- * @returns Combined dependencies as a single record
- */
-function collectAllDependencies(packageJson) {
-    return {
-        ...packageJson?.dependencies,
-        ...packageJson?.devDependencies,
-        ...packageJson?.peerDependencies,
-        ...packageJson?.optionalDependencies,
-    };
-}
-/**
- * Extract clean version from dependency version string.
- * Removes semver prefixes like ^, ~, >=, etc.
- * Uses character-by-character parsing to avoid ReDoS vulnerabilities.
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ * @example Detecting Express framework
+ * ```typescript
+ * const pkg = {
+ *   dependencies: { express: '^4.18.2', cors: '^2.8.5' },
+ *   devDependencies: { '@types/express': '^4.17.17' },
+ * }
  *
- * @param versionString - The version string with optional prefix characters
- * @returns The cleaned version string without prefix characters
- */
-function parseVersionString(versionString) {
-    if (versionString === undefined || versionString === null)
-        return undefined;
-    // Manual parsing instead of regex to avoid ReDoS
-    let start = 0;
-    while (start < versionString.length) {
-        const char = versionString[start];
-        if (char !== '^' && char !== '~' && char !== '>' && char !== '=' && char !== '<') {
-            break;
-        }
-        start++;
-    }
-    return versionString.slice(start);
-}
-/**
- * Find first matching config file in project.
- * Note: Name avoids similarity to fs.readFile/fs.readFileSync.
- *
- * @param projectPath - The project directory path
- * @param patterns - Array of config file patterns to search for
- * @returns The first matching config file path or undefined
- */
-function locateConfigFile(projectPath, patterns) {
-    for (const pattern of patterns) {
-        const fullPath = join(projectPath, pattern);
-        if (exists(fullPath)) {
-            return pattern;
-        }
-    }
-    return undefined;
-}
-/**
- * Find scripts containing a specific command.
- *
- * @param scripts - The scripts object from package.json
- * @param command - The command string to search for
- * @returns Array of script names that contain the command
- */
-function filterScriptsByCommand(scripts, command) {
-    if (!scripts)
-        return [];
-    return entries(scripts)
-        .filter(([, script]) => script.includes(command))
-        .map(([name]) => name);
-}
-
-/**
- * Detect Express in project.
- *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
+ * const result = expressDetector('/path/to/project', pkg)
+ * // => {
+ * //   id: 'express',
+ * //   name: 'Express',
+ * //   version: '4.18.2',
+ * //   confidence: 100,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.express' },
+ * //     { type: 'package.json', field: 'dependencies.@types/express' },
+ * //     { type: 'package.json', field: 'dependencies (express middleware)' },
+ * //   ],
+ * // }
+ * ```
  */
 function expressDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1019,12 +401,11 @@ function expressDetector(projectPath, packageJson) {
         version = parseVersionString(deps['express']);
         sources.push({ type: 'package.json', field: 'dependencies.express' });
     }
-    // @types/express (indicates usage)
     if (deps['@types/express']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.@types/express' });
     }
-    const expressMiddleware = keys(deps).filter((d) => d.includes('express-') || d === 'body-parser' || d === 'cors' || d === 'helmet' || d === 'morgan');
+    const expressMiddleware = index_cjs_js$2.keys(deps).filter((d) => d.includes('express-') || d === 'body-parser' || d === 'cors' || d === 'helmet' || d === 'morgan');
     if (expressMiddleware.length > 0) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies (express middleware)' });
@@ -1036,95 +417,117 @@ function expressDetector(projectPath, packageJson) {
         id: 'express',
         name: 'Express',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect NestJS in project.
+ * Detect Fastify in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ * @example Detecting Fastify framework
+ * ```typescript
+ * const pkg = {
+ *   dependencies: { fastify: '^4.24.0', '@fastify/cors': '^8.4.0' },
+ * }
+ *
+ * const result = fastifyDetector('/path/to/project', pkg)
+ * // => {
+ * //   id: 'fastify',
+ * //   name: 'Fastify',
+ * //   version: '4.24.0',
+ * //   confidence: 95,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.fastify' },
+ * //     { type: 'package.json', field: 'dependencies (fastify plugins)' },
+ * //   ],
+ * // }
+ * ```
  */
-function nestDetector(projectPath, packageJson) {
+function fastifyDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
-    let configPath;
     const deps = collectAllDependencies(pkg);
-    // @nestjs/core package
-    if (deps['@nestjs/core']) {
-        confidence += 70;
-        version = parseVersionString(deps['@nestjs/core']);
-        sources.push({ type: 'package.json', field: 'dependencies.@nestjs/core' });
-    }
-    // @nestjs/common
-    if (deps['@nestjs/common']) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies.@nestjs/common' });
+    if (deps['fastify']) {
+        confidence += 80;
+        version = parseVersionString(deps['fastify']);
+        sources.push({ type: 'package.json', field: 'dependencies.fastify' });
     }
-    if (exists(node_path.join(projectPath, 'nest-cli.json'))) {
+    const fastifyPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@fastify/') || d.startsWith('fastify-'));
+    if (fastifyPlugins.length > 0) {
         confidence += 15;
-        configPath = 'nest-cli.json';
-        sources.push({ type: 'config-file', path: 'nest-cli.json' });
+        sources.push({ type: 'package.json', field: 'dependencies (fastify plugins)' });
     }
-    const nestPackages = keys(deps).filter((d) => d.startsWith('@nestjs/'));
-    if (nestPackages.length > 2) {
+    if (deps['@types/fastify']) {
         confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies (@nestjs packages)' });
+        sources.push({ type: 'package.json', field: 'dependencies.@types/fastify' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'nestjs',
-        name: 'NestJS',
+        id: 'fastify',
+        name: 'Fastify',
         version,
-        configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Fastify in project.
+ * Detect Hono in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ * @example Detecting Hono framework
+ * ```typescript
+ * const pkg = {
+ *   dependencies: { hono: '^3.11.0', '@hono/node-server': '^1.3.0' },
+ * }
+ *
+ * const result = honoDetector('/path/to/project', pkg)
+ * // => {
+ * //   id: 'hono',
+ * //   name: 'Hono',
+ * //   version: '3.11.0',
+ * //   confidence: 100,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.hono' },
+ * //     { type: 'package.json', field: 'dependencies (@hono adapters)' },
+ * //   ],
+ * // }
+ * ```
  */
-function fastifyDetector(projectPath, packageJson) {
+function honoDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['fastify']) {
-        confidence += 80;
-        version = parseVersionString(deps['fastify']);
-        sources.push({ type: 'package.json', field: 'dependencies.fastify' });
+    if (deps['hono']) {
+        confidence += 85;
+        version = parseVersionString(deps['hono']);
+        sources.push({ type: 'package.json', field: 'dependencies.hono' });
     }
-    const fastifyPlugins = keys(deps).filter((d) => d.startsWith('@fastify/') || d.startsWith('fastify-'));
-    if (fastifyPlugins.length > 0) {
+    const honoAdapters = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@hono/'));
+    if (honoAdapters.length > 0) {
         confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies (fastify plugins)' });
-    }
-    // @types/fastify (older versions)
-    if (deps['@types/fastify']) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies.@types/fastify' });
+        sources.push({ type: 'package.json', field: 'dependencies (@hono adapters)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'fastify',
-        name: 'Fastify',
+        id: 'hono',
+        name: 'Hono',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -1135,6 +538,26 @@ function fastifyDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ * @example Detecting Koa framework
+ * ```typescript
+ * const pkg = {
+ *   dependencies: { koa: '^2.14.2', 'koa-router': '^12.0.0' },
+ *   devDependencies: { '@types/koa': '^2.13.9' },
+ * }
+ *
+ * const result = koaDetector('/path/to/project', pkg)
+ * // => {
+ * //   id: 'koa',
+ * //   name: 'Koa',
+ * //   version: '2.14.2',
+ * //   confidence: 100,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.koa' },
+ * //     { type: 'package.json', field: 'dependencies.@types/koa' },
+ * //     { type: 'package.json', field: 'dependencies (koa middleware)' },
+ * //   ],
+ * // }
+ * ```
  */
 function koaDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1147,12 +570,11 @@ function koaDetector(projectPath, packageJson) {
         version = parseVersionString(deps['koa']);
         sources.push({ type: 'package.json', field: 'dependencies.koa' });
     }
-    // @types/koa
     if (deps['@types/koa']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.@types/koa' });
     }
-    const koaMiddleware = keys(deps).filter((d) => d.startsWith('koa-') || d.startsWith('@koa/'));
+    const koaMiddleware = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('koa-') || d.startsWith('@koa/'));
     if (koaMiddleware.length > 0) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies (koa middleware)' });
@@ -1164,42 +586,79 @@ function koaDetector(projectPath, packageJson) {
         id: 'koa',
         name: 'Koa',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Hono in project.
+ * Detect NestJS in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ * @example Detecting NestJS framework
+ * ```typescript
+ * // Project with nest-cli.json and NestJS packages
+ * const pkg = {
+ *   dependencies: {
+ *     '@nestjs/core': '^10.2.0',
+ *     '@nestjs/common': '^10.2.0',
+ *     '@nestjs/platform-express': '^10.2.0',
+ *   },
+ * }
+ *
+ * const result = nestDetector('/path/to/nest-project', pkg)
+ * // => {
+ * //   id: 'nestjs',
+ * //   name: 'NestJS',
+ * //   version: '10.2.0',
+ * //   configPath: 'nest-cli.json',  // if present
+ * //   confidence: 100,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@nestjs/core' },
+ * //     { type: 'package.json', field: 'dependencies.@nestjs/common' },
+ * //     { type: 'config-file', path: 'nest-cli.json' },
+ * //     { type: 'package.json', field: 'dependencies (@nestjs packages)' },
+ * //   ],
+ * // }
+ * ```
  */
-function honoDetector(projectPath, packageJson) {
+function nestDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
+    let configPath;
     const deps = collectAllDependencies(pkg);
-    if (deps['hono']) {
-        confidence += 85;
-        version = parseVersionString(deps['hono']);
-        sources.push({ type: 'package.json', field: 'dependencies.hono' });
+    if (deps['@nestjs/core']) {
+        confidence += 70;
+        version = parseVersionString(deps['@nestjs/core']);
+        sources.push({ type: 'package.json', field: 'dependencies.@nestjs/core' });
     }
-    const honoAdapters = keys(deps).filter((d) => d.startsWith('@hono/'));
-    if (honoAdapters.length > 0) {
+    if (deps['@nestjs/common']) {
         confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies (@hono adapters)' });
+        sources.push({ type: 'package.json', field: 'dependencies.@nestjs/common' });
+    }
+    if (exists(node_path.join(projectPath, 'nest-cli.json'))) {
+        confidence += 15;
+        configPath = 'nest-cli.json';
+        sources.push({ type: 'config-file', path: 'nest-cli.json' });
+    }
+    const nestPackages = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@nestjs/'));
+    if (nestPackages.length > 2) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies (@nestjs packages)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'hono',
-        name: 'Hono',
+        id: 'nestjs',
+        name: 'NestJS',
         version,
-        confidence: min(confidence, 100),
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -1213,102 +672,194 @@ const backendDetectors = [
     { id: 'hono', name: 'Hono', detect: honoDetector },
 ];
 
-/** Config patterns for Webpack */
-const WEBPACK_CONFIG_PATTERNS = [
-    'webpack.config.js',
-    'webpack.config.ts',
-    'webpack.config.cjs',
-    'webpack.config.mjs',
-    'webpack.config.babel.js',
-];
+/** Config patterns for Babel */
+const BABEL_CONFIG_PATTERNS = ['babel.config.js', 'babel.config.cjs', 'babel.config.mjs', 'babel.config.json', '.babelrc', '.babelrc.json', '.babelrc.js'];
 /**
- * Detect Webpack in project.
+ * Detect Babel in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Babel compiler
+ * ```typescript
+ * const result = babelDetector('/path/to/project', {
+ *   name: 'my-app',
+ *   devDependencies: { '@babel/core': '^7.23.0', '@babel/preset-env': '^7.23.0' }
+ * })
+ * // => {
+ * //   id: 'babel',
+ * //   name: 'Babel',
+ * //   version: '7.23.0',
+ * //   confidence: 60,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@babel/core' },
+ * //     { type: 'package.json', field: 'dependencies (@babel packages)' }
+ * //   ]
+ * // }
+ * ```
  */
-function webpackDetector(projectPath, packageJson) {
+function babelDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['webpack']) {
+    if (deps['@babel/core']) {
         confidence += 50;
-        version = parseVersionString(deps['webpack']);
-        sources.push({ type: 'package.json', field: 'dependencies.webpack' });
+        version = parseVersionString(deps['@babel/core']);
+        sources.push({ type: 'package.json', field: 'dependencies.@babel/core' });
     }
-    const configPath = locateConfigFile(projectPath, WEBPACK_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, BABEL_CONFIG_PATTERNS);
     if (configPath) {
         confidence += 40;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (deps['webpack-cli']) {
+    if (pkg && 'babel' in pkg) {
+        confidence += 30;
+        sources.push({ type: 'package.json', field: 'babel' });
+    }
+    const babelPackages = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@babel/'));
+    if (babelPackages.length > 1) {
         confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.webpack-cli' });
+        sources.push({ type: 'package.json', field: 'dependencies (@babel packages)' });
     }
-    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'webpack');
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'babel',
+        name: 'Babel',
+        version,
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect esbuild in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ *
+ * @example Detecting esbuild bundler
+ * ```typescript
+ * const result = esbuildDetector('/path/to/project', {
+ *   name: 'my-lib',
+ *   devDependencies: { 'esbuild': '^0.19.0' },
+ *   scripts: { 'build': 'esbuild src/index.ts --bundle --outfile=dist/index.js' }
+ * })
+ * // => {
+ * //   id: 'esbuild',
+ * //   name: 'esbuild',
+ * //   version: '0.19.0',
+ * //   confidence: 80,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.esbuild' },
+ * //     { type: 'package.json', field: 'scripts.build' }
+ * //   ]
+ * // }
+ * ```
+ */
+function esbuildDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['esbuild']) {
+        confidence += 70;
+        version = parseVersionString(deps['esbuild']);
+        sources.push({ type: 'package.json', field: 'dependencies.esbuild' });
+    }
+    const esbuildPlugins = index_cjs_js$2.keys(deps).filter((d) => d.includes('esbuild-plugin') || d.includes('esbuild-'));
+    if (esbuildPlugins.length > 0) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies (esbuild plugins)' });
+    }
+    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'esbuild');
     for (const name of scriptMatches) {
-        confidence = min(confidence + 5, 100);
+        confidence = index_cjs_js$8.min(confidence + 10, 100);
         sources.push({ type: 'package.json', field: `scripts.${name}` });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'webpack',
-        name: 'Webpack',
+        id: 'esbuild',
+        name: 'esbuild',
         version,
-        configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Vite */
-const VITE_CONFIG_PATTERNS = ['vite.config.js', 'vite.config.ts', 'vite.config.mjs', 'vite.config.cjs'];
+/** Config patterns for Parcel */
+const PARCEL_CONFIG_PATTERNS = ['.parcelrc'];
 /**
- * Detect Vite in project.
+ * Detect Parcel in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Parcel bundler
+ * ```typescript
+ * const result = parcelDetector('/path/to/project', {
+ *   name: 'my-app',
+ *   devDependencies: { 'parcel': '^2.10.0' },
+ *   scripts: { 'dev': 'parcel src/index.html', 'build': 'parcel build src/index.html' }
+ * })
+ * // => {
+ * //   id: 'parcel',
+ * //   name: 'Parcel',
+ * //   version: '2.10.0',
+ * //   confidence: 80,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.parcel' },
+ * //     { type: 'package.json', field: 'scripts.dev' },
+ * //     { type: 'package.json', field: 'scripts.build' }
+ * //   ]
+ * // }
+ * ```
  */
-function viteDetector(projectPath, packageJson) {
+function parcelDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['vite']) {
+    if (deps['parcel']) {
         confidence += 60;
-        version = parseVersionString(deps['vite']);
-        sources.push({ type: 'package.json', field: 'dependencies.vite' });
+        version = parseVersionString(deps['parcel']);
+        sources.push({ type: 'package.json', field: 'dependencies.parcel' });
     }
-    const configPath = locateConfigFile(projectPath, VITE_CONFIG_PATTERNS);
+    if (deps['parcel-bundler']) {
+        confidence += 60;
+        version = parseVersionString(deps['parcel-bundler']);
+        sources.push({ type: 'package.json', field: 'dependencies.parcel-bundler' });
+    }
+    const configPath = locateConfigFile(projectPath, PARCEL_CONFIG_PATTERNS);
     if (configPath) {
-        confidence += 35;
+        confidence += 30;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (deps['vitest']) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.vitest' });
-    }
-    const vitePlugins = keys(deps).filter((d) => d.startsWith('vite-plugin-') || d.startsWith('@vitejs/'));
-    if (vitePlugins.length > 0) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies (vite plugins)' });
+    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'parcel');
+    for (const name of scriptMatches) {
+        confidence = index_cjs_js$8.min(confidence + 10, 100);
+        sources.push({ type: 'package.json', field: `scripts.${name}` });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'vite',
-        name: 'Vite',
+        id: 'parcel',
+        name: 'Parcel',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -1321,6 +872,28 @@ const ROLLUP_CONFIG_PATTERNS = ['rollup.config.js', 'rollup.config.ts', 'rollup.
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Rollup bundler
+ * ```typescript
+ * const result = rollupDetector('/path/to/project', {
+ *   name: 'my-lib',
+ *   devDependencies: {
+ *     'rollup': '^4.0.0',
+ *     '@rollup/plugin-node-resolve': '^15.0.0',
+ *     '@rollup/plugin-commonjs': '^25.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'rollup',
+ * //   name: 'Rollup',
+ * //   version: '4.0.0',
+ * //   confidence: 65,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.rollup' },
+ * //     { type: 'package.json', field: 'dependencies (rollup plugins)' }
+ * //   ]
+ * // }
+ * ```
  */
 function rollupDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1338,14 +911,14 @@ function rollupDetector(projectPath, packageJson) {
         confidence += 40;
         sources.push({ type: 'config-file', path: configPath });
     }
-    const rollupPlugins = keys(deps).filter((d) => d.startsWith('@rollup/') || d.startsWith('rollup-plugin-'));
+    const rollupPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@rollup/') || d.startsWith('rollup-plugin-'));
     if (rollupPlugins.length > 0) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies (rollup plugins)' });
     }
     const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'rollup');
     for (const name of scriptMatches) {
-        confidence = min(confidence + 5, 100);
+        confidence = index_cjs_js$8.min(confidence + 5, 100);
         sources.push({ type: 'package.json', field: `scripts.${name}` });
     }
     if (confidence === 0) {
@@ -1356,280 +929,412 @@ function rollupDetector(projectPath, packageJson) {
         name: 'Rollup',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
+/** Config patterns for SWC */
+const SWC_CONFIG_PATTERNS = ['.swcrc', 'swc.config.js'];
 /**
- * Detect esbuild in project.
+ * Detect SWC in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting SWC compiler
+ * ```typescript
+ * const result = swcDetector('/path/to/project', {
+ *   name: 'my-app',
+ *   devDependencies: { '@swc/core': '^1.3.0', '@swc/cli': '^0.1.0' }
+ * })
+ * // => {
+ * //   id: 'swc',
+ * //   name: 'SWC',
+ * //   version: '1.3.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@swc/core' },
+ * //     { type: 'package.json', field: 'dependencies.@swc/cli' }
+ * //   ]
+ * // }
+ * ```
  */
-function esbuildDetector(projectPath, packageJson) {
+function swcDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['esbuild']) {
-        confidence += 70;
-        version = parseVersionString(deps['esbuild']);
-        sources.push({ type: 'package.json', field: 'dependencies.esbuild' });
+    if (deps['@swc/core']) {
+        confidence += 60;
+        version = parseVersionString(deps['@swc/core']);
+        sources.push({ type: 'package.json', field: 'dependencies.@swc/core' });
     }
-    const esbuildPlugins = keys(deps).filter((d) => d.includes('esbuild-plugin') || d.includes('esbuild-'));
-    if (esbuildPlugins.length > 0) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies (esbuild plugins)' });
+    const configPath = locateConfigFile(projectPath, SWC_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 35;
+        sources.push({ type: 'config-file', path: configPath });
     }
-    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'esbuild');
-    for (const name of scriptMatches) {
-        confidence = min(confidence + 10, 100);
-        sources.push({ type: 'package.json', field: `scripts.${name}` });
+    if (deps['@swc/cli']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.@swc/cli' });
+    }
+    const swcPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@swc/') || d.includes('swc-plugin'));
+    if (swcPlugins.length > 1) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies (@swc packages)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'esbuild',
-        name: 'esbuild',
+        id: 'swc',
+        name: 'SWC',
         version,
-        confidence: min(confidence, 100),
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Babel */
-const BABEL_CONFIG_PATTERNS = ['babel.config.js', 'babel.config.cjs', 'babel.config.mjs', 'babel.config.json', '.babelrc', '.babelrc.json', '.babelrc.js'];
+/** Config patterns for Vite */
+const VITE_CONFIG_PATTERNS = ['vite.config.js', 'vite.config.ts', 'vite.config.mjs', 'vite.config.cjs'];
 /**
- * Detect Babel in project.
+ * Detect Vite in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Vite build tool
+ * ```typescript
+ * const result = viteDetector('/path/to/project', {
+ *   name: 'my-app',
+ *   devDependencies: {
+ *     'vite': '^5.0.0',
+ *     '@vitejs/plugin-react': '^4.0.0',
+ *     'vitest': '^1.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'vite',
+ * //   name: 'Vite',
+ * //   version: '5.0.0',
+ * //   confidence: 80,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.vite' },
+ * //     { type: 'package.json', field: 'dependencies.vitest' },
+ * //     { type: 'package.json', field: 'dependencies (vite plugins)' }
+ * //   ]
+ * // }
+ * ```
  */
-function babelDetector(projectPath, packageJson) {
+function viteDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@babel/core']) {
-        confidence += 50;
-        version = parseVersionString(deps['@babel/core']);
-        sources.push({ type: 'package.json', field: 'dependencies.@babel/core' });
+    if (deps['vite']) {
+        confidence += 60;
+        version = parseVersionString(deps['vite']);
+        sources.push({ type: 'package.json', field: 'dependencies.vite' });
     }
-    const configPath = locateConfigFile(projectPath, BABEL_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, VITE_CONFIG_PATTERNS);
     if (configPath) {
-        confidence += 40;
+        confidence += 35;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (pkg && 'babel' in pkg) {
-        confidence += 30;
-        sources.push({ type: 'package.json', field: 'babel' });
+    if (deps['vitest']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.vitest' });
     }
-    const babelPackages = keys(deps).filter((d) => d.startsWith('@babel/'));
-    if (babelPackages.length > 1) {
+    const vitePlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('vite-plugin-') || d.startsWith('@vitejs/'));
+    if (vitePlugins.length > 0) {
         confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies (@babel packages)' });
+        sources.push({ type: 'package.json', field: 'dependencies (vite plugins)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'babel',
-        name: 'Babel',
+        id: 'vite',
+        name: 'Vite',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for SWC */
-const SWC_CONFIG_PATTERNS = ['.swcrc', 'swc.config.js'];
+/** Config patterns for Webpack */
+const WEBPACK_CONFIG_PATTERNS = [
+    'webpack.config.js',
+    'webpack.config.ts',
+    'webpack.config.cjs',
+    'webpack.config.mjs',
+    'webpack.config.babel.js',
+];
 /**
- * Detect SWC in project.
+ * Detect Webpack in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Webpack bundler
+ * ```typescript
+ * const result = webpackDetector('/path/to/project', {
+ *   name: 'my-app',
+ *   devDependencies: { 'webpack': '^5.89.0', 'webpack-cli': '^5.1.0' },
+ *   scripts: { 'build': 'webpack --mode production' }
+ * })
+ * // => {
+ * //   id: 'webpack',
+ * //   name: 'Webpack',
+ * //   version: '5.89.0',
+ * //   confidence: 65,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.webpack' },
+ * //     { type: 'package.json', field: 'dependencies.webpack-cli' },
+ * //     { type: 'package.json', field: 'scripts.build' }
+ * //   ]
+ * // }
+ * ```
  */
-function swcDetector(projectPath, packageJson) {
+function webpackDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@swc/core']) {
-        confidence += 60;
-        version = parseVersionString(deps['@swc/core']);
-        sources.push({ type: 'package.json', field: 'dependencies.@swc/core' });
+    if (deps['webpack']) {
+        confidence += 50;
+        version = parseVersionString(deps['webpack']);
+        sources.push({ type: 'package.json', field: 'dependencies.webpack' });
     }
-    const configPath = locateConfigFile(projectPath, SWC_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, WEBPACK_CONFIG_PATTERNS);
     if (configPath) {
-        confidence += 35;
+        confidence += 40;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (deps['@swc/cli']) {
+    if (deps['webpack-cli']) {
         confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.@swc/cli' });
+        sources.push({ type: 'package.json', field: 'dependencies.webpack-cli' });
     }
-    const swcPlugins = keys(deps).filter((d) => d.startsWith('@swc/') || d.includes('swc-plugin'));
-    if (swcPlugins.length > 1) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies (@swc packages)' });
+    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'webpack');
+    for (const name of scriptMatches) {
+        confidence = index_cjs_js$8.min(confidence + 5, 100);
+        sources.push({ type: 'package.json', field: `scripts.${name}` });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'swc',
-        name: 'SWC',
+        id: 'webpack',
+        name: 'Webpack',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Parcel */
-const PARCEL_CONFIG_PATTERNS = ['.parcelrc'];
+/** All build tool detectors */
+const buildToolDetectors = [
+    { id: 'webpack', name: 'Webpack', detect: webpackDetector },
+    { id: 'vite', name: 'Vite', detect: viteDetector },
+    { id: 'rollup', name: 'Rollup', detect: rollupDetector },
+    { id: 'esbuild', name: 'esbuild', detect: esbuildDetector },
+    { id: 'babel', name: 'Babel', detect: babelDetector },
+    { id: 'swc', name: 'SWC', detect: swcDetector },
+    { id: 'parcel', name: 'Parcel', detect: parcelDetector },
+];
+
 /**
- * Detect Parcel in project.
+ * Detect Angular in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Angular framework
+ * ```typescript
+ * const result = angularDetector('/path/to/angular-app', {
+ *   dependencies: { '@angular/core': '^17.0.0', '@angular/cli': '^17.0.0' }
+ * })
+ * // => {
+ * //   id: 'angular',
+ * //   name: 'Angular',
+ * //   category: 'frontend',
+ * //   version: '17.0.0',
+ * //   confidence: 85,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@angular/core' },
+ * //     { type: 'package.json', field: 'dependencies.@angular/cli' }
+ * //   ]
+ * // }
+ * ```
  */
-function parcelDetector(projectPath, packageJson) {
+function angularDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['parcel']) {
-        confidence += 60;
-        version = parseVersionString(deps['parcel']);
-        sources.push({ type: 'package.json', field: 'dependencies.parcel' });
+    if (deps['@angular/core']) {
+        confidence += 70;
+        version = parseVersionString(deps['@angular/core']);
+        sources.push({ type: 'package.json', field: 'dependencies.@angular/core' });
     }
-    if (deps['parcel-bundler']) {
-        confidence += 60;
-        version = parseVersionString(deps['parcel-bundler']);
-        sources.push({ type: 'package.json', field: 'dependencies.parcel-bundler' });
+    if (deps['@angular/cli']) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies.@angular/cli' });
     }
-    const configPath = locateConfigFile(projectPath, PARCEL_CONFIG_PATTERNS);
-    if (configPath) {
-        confidence += 30;
-        sources.push({ type: 'config-file', path: configPath });
+    if (exists(node_path.join(projectPath, 'angular.json'))) {
+        confidence += 15;
+        sources.push({ type: 'config-file', path: 'angular.json' });
     }
-    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'parcel');
-    for (const name of scriptMatches) {
-        confidence = min(confidence + 10, 100);
-        sources.push({ type: 'package.json', field: `scripts.${name}` });
+    if (deps['angular'] && !deps['@angular/core']) {
+        return {
+            id: 'angularjs',
+            name: 'AngularJS (Legacy)',
+            category: 'frontend',
+            version: parseVersionString(deps['angular']),
+            confidence: 80,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.angular' }],
+        };
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'parcel',
-        name: 'Parcel',
+        id: 'angular',
+        name: 'Angular',
+        category: 'frontend',
         version,
-        configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** All build tool detectors */
-const buildToolDetectors = [
-    { id: 'webpack', name: 'Webpack', detect: webpackDetector },
-    { id: 'vite', name: 'Vite', detect: viteDetector },
-    { id: 'rollup', name: 'Rollup', detect: rollupDetector },
-    { id: 'esbuild', name: 'esbuild', detect: esbuildDetector },
-    { id: 'babel', name: 'Babel', detect: babelDetector },
-    { id: 'swc', name: 'SWC', detect: swcDetector },
-    { id: 'parcel', name: 'Parcel', detect: parcelDetector },
-];
-
 /**
- * Detect React in project.
+ * Detect Astro in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Astro framework
+ * ```typescript
+ * const result = astroDetector('/path/to/astro-project', {
+ *   dependencies: { 'astro': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'astro',
+ * //   name: 'Astro',
+ * //   category: 'meta-framework',
+ * //   version: '4.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.astro' }]
+ * // }
+ * ```
  */
-function reactDetector(projectPath, packageJson) {
+function astroDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
-    const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    if (deps['react']) {
-        confidence += 60;
-        version = parseVersionString(deps['react']);
-        sources.push({ type: 'package.json', field: 'dependencies.react' });
-    }
-    if (deps['react-dom']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.react-dom' });
+    if (deps['astro']) {
+        confidence += 70;
+        version = parseVersionString(deps['astro']);
+        sources.push({ type: 'package.json', field: 'dependencies.astro' });
     }
-    if (deps['react-native']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.react-native' });
+    if (exists(node_path.join(projectPath, 'astro.config.mjs')) ||
+        exists(node_path.join(projectPath, 'astro.config.ts')) ||
+        exists(node_path.join(projectPath, 'astro.config.js'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'astro.config.*' });
     }
-    const hasJsxFiles = exists(node_path.join(projectPath, 'src', 'App.tsx')) ||
-        exists(node_path.join(projectPath, 'src', 'App.jsx')) ||
-        exists(node_path.join(projectPath, 'src', 'index.tsx')) ||
-        exists(node_path.join(projectPath, 'src', 'index.jsx'));
-    if (hasJsxFiles) {
-        confidence += 10;
-        sources.push({ type: 'directory', path: 'src/*.tsx or src/*.jsx' });
+    if (exists(node_path.join(projectPath, 'src', 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'src/pages/' });
     }
-    if (deps['next']) {
-        metaFrameworks.push({
-            id: 'nextjs',
-            name: 'Next.js',
-            category: 'meta-framework',
-            version: parseVersionString(deps['next']),
-            confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }],
-        });
+    if (confidence === 0) {
+        return null;
     }
+    return {
+        id: 'astro',
+        name: 'Astro',
+        category: 'meta-framework',
+        version,
+        confidence: index_cjs_js$8.min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Gatsby in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ *
+ * @example Detecting Gatsby framework
+ * ```typescript
+ * const result = gatsbyDetector('/path/to/gatsby-blog', {
+ *   dependencies: {
+ *     'gatsby': '^5.0.0',
+ *     'gatsby-plugin-image': '^3.0.0',
+ *     'gatsby-source-filesystem': '^5.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'gatsby',
+ * //   name: 'Gatsby',
+ * //   category: 'meta-framework',
+ * //   version: '5.0.0',
+ * //   confidence: 75,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.gatsby' },
+ * //     { type: 'package.json', field: 'dependencies (gatsby plugins)' }
+ * //   ]
+ * // }
+ * ```
+ */
+function gatsbyDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
     if (deps['gatsby']) {
-        metaFrameworks.push({
-            id: 'gatsby',
-            name: 'Gatsby',
-            category: 'meta-framework',
-            version: parseVersionString(deps['gatsby']),
-            confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.gatsby' }],
-        });
+        confidence += 70;
+        version = parseVersionString(deps['gatsby']);
+        sources.push({ type: 'package.json', field: 'dependencies.gatsby' });
     }
-    if (deps['@remix-run/react'] || deps['remix']) {
-        metaFrameworks.push({
-            id: 'remix',
-            name: 'Remix',
-            category: 'meta-framework',
-            version: parseVersionString(deps['@remix-run/react'] ?? deps['remix']),
-            confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.@remix-run/react' }],
-        });
+    if (exists(node_path.join(projectPath, 'gatsby-config.js')) || exists(node_path.join(projectPath, 'gatsby-config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'gatsby-config.*' });
+    }
+    const gatsbyPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('gatsby-plugin-') || d.startsWith('gatsby-source-'));
+    if (gatsbyPlugins.length > 0) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies (gatsby plugins)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'react',
-        name: 'React',
-        category: 'frontend',
+        id: 'gatsby',
+        name: 'Gatsby',
+        category: 'meta-framework',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
-        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
 }
 
@@ -1639,6 +1344,21 @@ function reactDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Next.js framework
+ * ```typescript
+ * const result = nextjsDetector('/path/to/nextjs-app', {
+ *   dependencies: { 'next': '^14.0.0', 'react': '^18.0.0' }
+ * })
+ * // => {
+ * //   id: 'nextjs',
+ * //   name: 'Next.js',
+ * //   category: 'meta-framework',
+ * //   version: '14.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }]
+ * // }
+ * ```
  */
 function nextjsDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1672,231 +1392,335 @@ function nextjsDetector(projectPath, packageJson) {
         name: 'Next.js',
         category: 'meta-framework',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Remix in project.
+ * Detect Nuxt in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Nuxt framework
+ * ```typescript
+ * const result = nuxtDetector('/path/to/nuxt-app', {
+ *   dependencies: { 'nuxt': '^3.0.0', 'vue': '^3.0.0' }
+ * })
+ * // => {
+ * //   id: 'nuxt',
+ * //   name: 'Nuxt',
+ * //   category: 'meta-framework',
+ * //   version: '3.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }]
+ * // }
+ * ```
  */
-function remixDetector(projectPath, packageJson) {
+function nuxtDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    // @remix-run packages
-    if (deps['@remix-run/react']) {
+    if (deps['nuxt'] || deps['nuxt3']) {
         confidence += 70;
-        version = parseVersionString(deps['@remix-run/react']);
-        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/react' });
+        version = parseVersionString(deps['nuxt'] ?? deps['nuxt3']);
+        sources.push({ type: 'package.json', field: 'dependencies.nuxt' });
     }
-    if (deps['@remix-run/node'] || deps['@remix-run/cloudflare'] || deps['@remix-run/deno']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/*' });
+    if (exists(node_path.join(projectPath, 'nuxt.config.js')) || exists(node_path.join(projectPath, 'nuxt.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
     }
-    if (exists(node_path.join(projectPath, 'remix.config.js')) || exists(node_path.join(projectPath, 'remix.config.ts'))) {
-        confidence += 10;
-        sources.push({ type: 'config-file', path: 'remix.config.*' });
+    if (exists(node_path.join(projectPath, 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'pages/' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'remix',
-        name: 'Remix',
+        id: 'nuxt',
+        name: 'Nuxt',
         category: 'meta-framework',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Gatsby in project.
+ * Detect Qwik in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Qwik framework
+ * ```typescript
+ * const result = qwikDetector('/path/to/qwik-app', {
+ *   dependencies: {
+ *     '@builder.io/qwik': '^1.0.0',
+ *     '@builder.io/qwik-city': '^1.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'qwik',
+ * //   name: 'Qwik',
+ * //   category: 'frontend',
+ * //   version: '1.0.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@builder.io/qwik' },
+ * //     { type: 'package.json', field: 'dependencies.@builder.io/qwik-city' }
+ * //   ]
+ * // }
+ * ```
  */
-function gatsbyDetector(projectPath, packageJson) {
+function qwikDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['gatsby']) {
+    if (deps['@builder.io/qwik']) {
         confidence += 70;
-        version = parseVersionString(deps['gatsby']);
-        sources.push({ type: 'package.json', field: 'dependencies.gatsby' });
+        version = parseVersionString(deps['@builder.io/qwik']);
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik' });
     }
-    if (exists(node_path.join(projectPath, 'gatsby-config.js')) || exists(node_path.join(projectPath, 'gatsby-config.ts'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'gatsby-config.*' });
+    if (deps['@builder.io/qwik-city']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik-city' });
     }
-    const gatsbyPlugins = keys(deps).filter((d) => d.startsWith('gatsby-plugin-') || d.startsWith('gatsby-source-'));
-    if (gatsbyPlugins.length > 0) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies (gatsby plugins)' });
+    if (exists(node_path.join(projectPath, 'qwik.config.ts')) || exists(node_path.join(projectPath, 'qwik.config.js'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'qwik.config.*' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'gatsby',
-        name: 'Gatsby',
-        category: 'meta-framework',
+        id: 'qwik',
+        name: 'Qwik',
+        category: 'frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Vue in project.
+ * Detect React in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting React library
+ * ```typescript
+ * const result = reactDetector('/path/to/react-app', {
+ *   dependencies: { 'react': '^18.0.0', 'react-dom': '^18.0.0' }
+ * })
+ * // => {
+ * //   id: 'react',
+ * //   name: 'React',
+ * //   category: 'frontend',
+ * //   version: '18.0.0',
+ * //   confidence: 80,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.react' },
+ * //     { type: 'package.json', field: 'dependencies.react-dom' }
+ * //   ]
+ * // }
+ * ```
  */
-function vueDetector(projectPath, packageJson) {
+function reactDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    if (deps['vue']) {
-        confidence += 70;
-        version = parseVersionString(deps['vue']);
-        sources.push({ type: 'package.json', field: 'dependencies.vue' });
+    if (deps['react']) {
+        confidence += 60;
+        version = parseVersionString(deps['react']);
+        sources.push({ type: 'package.json', field: 'dependencies.react' });
     }
-    if (deps['@vue/cli-service']) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies.@vue/cli-service' });
+    if (deps['react-dom']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.react-dom' });
     }
-    const hasVueFiles = exists(node_path.join(projectPath, 'src', 'App.vue')) || exists(node_path.join(projectPath, 'src', 'main.vue'));
-    if (hasVueFiles) {
+    if (deps['react-native']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.react-native' });
+    }
+    const hasJsxFiles = exists(node_path.join(projectPath, 'src', 'App.tsx')) ||
+        exists(node_path.join(projectPath, 'src', 'App.jsx')) ||
+        exists(node_path.join(projectPath, 'src', 'index.tsx')) ||
+        exists(node_path.join(projectPath, 'src', 'index.jsx'));
+    if (hasJsxFiles) {
         confidence += 10;
-        sources.push({ type: 'directory', path: 'src/*.vue' });
+        sources.push({ type: 'directory', path: 'src/*.tsx or src/*.jsx' });
     }
-    if (exists(node_path.join(projectPath, 'vue.config.js'))) {
-        confidence += 5;
-        sources.push({ type: 'config-file', path: 'vue.config.js' });
+    if (deps['next']) {
+        metaFrameworks.push({
+            id: 'nextjs',
+            name: 'Next.js',
+            category: 'meta-framework',
+            version: parseVersionString(deps['next']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }],
+        });
     }
-    if (deps['nuxt'] || deps['nuxt3']) {
+    if (deps['gatsby']) {
         metaFrameworks.push({
-            id: 'nuxt',
-            name: 'Nuxt',
+            id: 'gatsby',
+            name: 'Gatsby',
             category: 'meta-framework',
-            version: parseVersionString(deps['nuxt'] ?? deps['nuxt3']),
+            version: parseVersionString(deps['gatsby']),
             confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }],
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.gatsby' }],
+        });
+    }
+    if (deps['@remix-run/react'] || deps['remix']) {
+        metaFrameworks.push({
+            id: 'remix',
+            name: 'Remix',
+            category: 'meta-framework',
+            version: parseVersionString(deps['@remix-run/react'] ?? deps['remix']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.@remix-run/react' }],
         });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'vue',
-        name: 'Vue',
+        id: 'react',
+        name: 'React',
         category: 'frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
         metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
 }
 
 /**
- * Detect Nuxt in project.
+ * Detect Remix in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Remix framework
+ * ```typescript
+ * const result = remixDetector('/path/to/remix-app', {
+ *   dependencies: {
+ *     '@remix-run/react': '^2.0.0',
+ *     '@remix-run/node': '^2.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'remix',
+ * //   name: 'Remix',
+ * //   category: 'meta-framework',
+ * //   version: '2.0.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@remix-run/react' },
+ * //     { type: 'package.json', field: 'dependencies.@remix-run/*' }
+ * //   ]
+ * // }
+ * ```
  */
-function nuxtDetector(projectPath, packageJson) {
+function remixDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['nuxt'] || deps['nuxt3']) {
+    if (deps['@remix-run/react']) {
         confidence += 70;
-        version = parseVersionString(deps['nuxt'] ?? deps['nuxt3']);
-        sources.push({ type: 'package.json', field: 'dependencies.nuxt' });
+        version = parseVersionString(deps['@remix-run/react']);
+        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/react' });
     }
-    if (exists(node_path.join(projectPath, 'nuxt.config.js')) || exists(node_path.join(projectPath, 'nuxt.config.ts'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
+    if (deps['@remix-run/node'] || deps['@remix-run/cloudflare'] || deps['@remix-run/deno']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/*' });
     }
-    if (exists(node_path.join(projectPath, 'pages'))) {
-        confidence += 5;
-        sources.push({ type: 'directory', path: 'pages/' });
+    if (exists(node_path.join(projectPath, 'remix.config.js')) || exists(node_path.join(projectPath, 'remix.config.ts'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'remix.config.*' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'nuxt',
-        name: 'Nuxt',
+        id: 'remix',
+        name: 'Remix',
         category: 'meta-framework',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Angular in project.
+ * Detect Solid in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Solid.js framework
+ * ```typescript
+ * const result = solidDetector('/path/to/solid-app', {
+ *   dependencies: { 'solid-js': '^1.8.0', 'vite-plugin-solid': '^2.0.0' }
+ * })
+ * // => {
+ * //   id: 'solid',
+ * //   name: 'Solid',
+ * //   category: 'frontend',
+ * //   version: '1.8.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.solid-js' },
+ * //     { type: 'package.json', field: 'dependencies.vite-plugin-solid' }
+ * //   ]
+ * // }
+ * ```
  */
-function angularDetector(projectPath, packageJson) {
+function solidDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@angular/core']) {
+    if (deps['solid-js']) {
         confidence += 70;
-        version = parseVersionString(deps['@angular/core']);
-        sources.push({ type: 'package.json', field: 'dependencies.@angular/core' });
-    }
-    if (deps['@angular/cli']) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies.@angular/cli' });
+        version = parseVersionString(deps['solid-js']);
+        sources.push({ type: 'package.json', field: 'dependencies.solid-js' });
     }
-    if (exists(node_path.join(projectPath, 'angular.json'))) {
-        confidence += 15;
-        sources.push({ type: 'config-file', path: 'angular.json' });
+    if (deps['vite-plugin-solid']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.vite-plugin-solid' });
     }
-    if (deps['angular'] && !deps['@angular/core']) {
-        return {
-            id: 'angularjs',
-            name: 'AngularJS (Legacy)',
-            category: 'frontend',
-            version: parseVersionString(deps['angular']),
-            confidence: 80,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.angular' }],
-        };
+    if (deps['solid-start'] || deps['@solidjs/start']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.solid-start' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'angular',
-        name: 'Angular',
+        id: 'solid',
+        name: 'Solid',
         category: 'frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -1907,6 +1731,21 @@ function angularDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Svelte framework
+ * ```typescript
+ * const result = svelteDetector('/path/to/svelte-app', {
+ *   devDependencies: { 'svelte': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'svelte',
+ * //   name: 'Svelte',
+ * //   category: 'frontend',
+ * //   version: '4.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.svelte' }]
+ * // }
+ * ```
  */
 function svelteDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1947,7 +1786,7 @@ function svelteDetector(projectPath, packageJson) {
         name: 'Svelte',
         category: 'frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
         metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
@@ -1959,6 +1798,21 @@ function svelteDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting SvelteKit framework
+ * ```typescript
+ * const result = sveltekitDetector('/path/to/sveltekit-app', {
+ *   devDependencies: { '@sveltejs/kit': '^2.0.0', 'svelte': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'sveltekit',
+ * //   name: 'SvelteKit',
+ * //   category: 'meta-framework',
+ * //   version: '2.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.@sveltejs/kit' }]
+ * // }
+ * ```
  */
 function sveltekitDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1966,7 +1820,6 @@ function sveltekitDetector(projectPath, packageJson) {
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    // @sveltejs/kit package
     if (deps['@sveltejs/kit']) {
         confidence += 70;
         version = parseVersionString(deps['@sveltejs/kit']);
@@ -1988,129 +1841,82 @@ function sveltekitDetector(projectPath, packageJson) {
         name: 'SvelteKit',
         category: 'meta-framework',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Solid in project.
+ * Detect Vue in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
- */
-function solidDetector(projectPath, packageJson) {
-    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
-    const sources = [];
-    let confidence = 0;
-    let version;
-    const deps = collectAllDependencies(pkg);
-    if (deps['solid-js']) {
-        confidence += 70;
-        version = parseVersionString(deps['solid-js']);
-        sources.push({ type: 'package.json', field: 'dependencies.solid-js' });
-    }
-    if (deps['vite-plugin-solid']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.vite-plugin-solid' });
-    }
-    if (deps['solid-start'] || deps['@solidjs/start']) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.solid-start' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'solid',
-        name: 'Solid',
-        category: 'frontend',
-        version,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect Qwik in project.
  *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
+ * @example Detecting Vue.js framework
+ * ```typescript
+ * const result = vueDetector('/path/to/vue-app', {
+ *   dependencies: { 'vue': '^3.0.0', '@vue/cli-service': '^5.0.0' }
+ * })
+ * // => {
+ * //   id: 'vue',
+ * //   name: 'Vue',
+ * //   category: 'frontend',
+ * //   version: '3.0.0',
+ * //   confidence: 85,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.vue' },
+ * //     { type: 'package.json', field: 'dependencies.@vue/cli-service' }
+ * //   ]
+ * // }
+ * ```
  */
-function qwikDetector(projectPath, packageJson) {
+function vueDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
+    const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    // @builder.io/qwik package
-    if (deps['@builder.io/qwik']) {
+    if (deps['vue']) {
         confidence += 70;
-        version = parseVersionString(deps['@builder.io/qwik']);
-        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik' });
+        version = parseVersionString(deps['vue']);
+        sources.push({ type: 'package.json', field: 'dependencies.vue' });
     }
-    // @builder.io/qwik-city
-    if (deps['@builder.io/qwik-city']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik-city' });
+    if (deps['@vue/cli-service']) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies.@vue/cli-service' });
     }
-    if (exists(node_path.join(projectPath, 'qwik.config.ts')) || exists(node_path.join(projectPath, 'qwik.config.js'))) {
+    const hasVueFiles = exists(node_path.join(projectPath, 'src', 'App.vue')) || exists(node_path.join(projectPath, 'src', 'main.vue'));
+    if (hasVueFiles) {
         confidence += 10;
-        sources.push({ type: 'config-file', path: 'qwik.config.*' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'qwik',
-        name: 'Qwik',
-        category: 'frontend',
-        version,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect Astro in project.
- *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
- */
-function astroDetector(projectPath, packageJson) {
-    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
-    const sources = [];
-    let confidence = 0;
-    let version;
-    const deps = collectAllDependencies(pkg);
-    if (deps['astro']) {
-        confidence += 70;
-        version = parseVersionString(deps['astro']);
-        sources.push({ type: 'package.json', field: 'dependencies.astro' });
-    }
-    if (exists(node_path.join(projectPath, 'astro.config.mjs')) ||
-        exists(node_path.join(projectPath, 'astro.config.ts')) ||
-        exists(node_path.join(projectPath, 'astro.config.js'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'astro.config.*' });
+        sources.push({ type: 'directory', path: 'src/*.vue' });
     }
-    if (exists(node_path.join(projectPath, 'src', 'pages'))) {
+    if (exists(node_path.join(projectPath, 'vue.config.js'))) {
         confidence += 5;
-        sources.push({ type: 'directory', path: 'src/pages/' });
+        sources.push({ type: 'config-file', path: 'vue.config.js' });
+    }
+    if (deps['nuxt'] || deps['nuxt3']) {
+        metaFrameworks.push({
+            id: 'nuxt',
+            name: 'Nuxt',
+            category: 'meta-framework',
+            version: parseVersionString(deps['nuxt'] ?? deps['nuxt3']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }],
+        });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'astro',
-        name: 'Astro',
-        category: 'meta-framework',
+        id: 'vue',
+        name: 'Vue',
+        category: 'frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
+        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
 }
 
@@ -2137,6 +1943,14 @@ const frameworkDetectors = [
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting AngularJS framework
+ * ```typescript
+ * const result = angularJSDetector('/path/to/project', {
+ *   dependencies: { angular: '^1.8.0', 'angular-route': '^1.8.0' },
+ * })
+ * // => { id: 'angularjs', name: 'AngularJS', confidence: 85, version: '1.8.0', ... }
+ * ```
  */
 function angularJSDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2144,23 +1958,19 @@ function angularJSDetector(projectPath, packageJson) {
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    // AngularJS package (angular, not @angular/core)
     if (deps['angular']) {
         confidence += 70;
         version = parseVersionString(deps['angular']);
         sources.push({ type: 'package.json', field: 'dependencies.angular' });
     }
-    // AngularJS router
     if (deps['angular-route']) {
         confidence += 15;
         sources.push({ type: 'package.json', field: 'dependencies.angular-route' });
     }
-    // AngularJS resource
     if (deps['angular-resource']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.angular-resource' });
     }
-    // AngularJS animate
     if (deps['angular-animate']) {
         confidence += 5;
         sources.push({ type: 'package.json', field: 'dependencies.angular-animate' });
@@ -2173,7 +1983,7 @@ function angularJSDetector(projectPath, packageJson) {
         name: 'AngularJS',
         category: 'legacy-frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2184,6 +1994,14 @@ function angularJSDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Backbone.js framework
+ * ```typescript
+ * const result = backboneDetector('/path/to/project', {
+ *   dependencies: { backbone: '^1.4.0', underscore: '^1.13.0' },
+ * })
+ * // => { id: 'backbone', name: 'Backbone.js', confidence: 85, version: '1.4.0', ... }
+ * ```
  */
 function backboneDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2191,23 +2009,19 @@ function backboneDetector(projectPath, packageJson) {
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    // Backbone package
     if (deps['backbone']) {
         confidence += 70;
         version = parseVersionString(deps['backbone']);
         sources.push({ type: 'package.json', field: 'dependencies.backbone' });
-        // Underscore (commonly used with Backbone)
         if (deps['underscore']) {
             confidence += 15;
             sources.push({ type: 'package.json', field: 'dependencies.underscore' });
         }
-        // Lodash can be used as underscore replacement
         if (deps['lodash']) {
             confidence += 5;
             sources.push({ type: 'package.json', field: 'dependencies.lodash' });
         }
     }
-    // Marionette (Backbone framework)
     if (deps['backbone.marionette'] || deps['marionette']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.backbone.marionette' });
@@ -2220,7 +2034,7 @@ function backboneDetector(projectPath, packageJson) {
         name: 'Backbone.js',
         category: 'legacy-frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2231,6 +2045,15 @@ function backboneDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Ember.js framework
+ * ```typescript
+ * const result = emberDetector('/path/to/project', {
+ *   dependencies: { 'ember-source': '^4.0.0' },
+ *   devDependencies: { 'ember-cli': '^4.0.0' },
+ * })
+ * // => { id: 'ember', name: 'Ember.js', confidence: 90, version: '4.0.0', ... }
+ * ```
  */
 function emberDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2238,18 +2061,15 @@ function emberDetector(projectPath, packageJson) {
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    // Ember source package
     if (deps['ember-source']) {
         confidence += 70;
         version = parseVersionString(deps['ember-source']);
         sources.push({ type: 'package.json', field: 'dependencies.ember-source' });
     }
-    // Ember CLI
     if (deps['ember-cli']) {
         confidence += 20;
         sources.push({ type: 'package.json', field: 'devDependencies.ember-cli' });
     }
-    // Ember Data
     if (deps['ember-data']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.ember-data' });
@@ -2262,7 +2082,7 @@ function emberDetector(projectPath, packageJson) {
         name: 'Ember.js',
         category: 'legacy-frontend',
         version,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2273,50 +2093,105 @@ function emberDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting jQuery library
+ * ```typescript
+ * const result = jqueryDetector('/path/to/project', {
+ *   dependencies: { jquery: '^3.6.0', 'jquery-ui': '^1.13.0' },
+ * })
+ * // => { id: 'jquery', name: 'jQuery', confidence: 90, version: '3.6.0', ... }
+ * ```
+ */
+function jqueryDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['jquery']) {
+        confidence += 80;
+        version = parseVersionString(deps['jquery']);
+        sources.push({ type: 'package.json', field: 'dependencies.jquery' });
+    }
+    if (deps['jquery-ui']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.jquery-ui' });
+    }
+    if (deps['jquery-validation']) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies.jquery-validation' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'jquery',
+        name: 'jQuery',
+        category: 'legacy-frontend',
+        version,
+        confidence: index_cjs_js$8.min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** All legacy framework detectors */
+const legacyDetectors = [
+    { id: 'angularjs', name: 'AngularJS', category: 'legacy-frontend', detect: angularJSDetector },
+    { id: 'backbone', name: 'Backbone.js', category: 'legacy-frontend', detect: backboneDetector },
+    { id: 'ember', name: 'Ember.js', category: 'legacy-frontend', detect: emberDetector },
+    { id: 'jquery', name: 'jQuery', category: 'legacy-frontend', detect: jqueryDetector },
+];
+
+/**
+ * Detect Biome in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ *
+ * @example Detecting Biome linter
+ * ```typescript
+ * const result = biomeDetector('/path/to/project', {
+ *   devDependencies: { '@biomejs/biome': '^1.5.0' },
+ * })
+ * // => { id: 'biome', name: 'Biome', confidence: 70, version: '1.5.0', ... }
+ * ```
  */
-function jqueryDetector(projectPath, packageJson) {
+function biomeDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
+    let configPath;
     let version;
     const deps = collectAllDependencies(pkg);
-    // jQuery package
-    if (deps['jquery']) {
-        confidence += 80;
-        version = parseVersionString(deps['jquery']);
-        sources.push({ type: 'package.json', field: 'dependencies.jquery' });
+    if (deps['@biomejs/biome']) {
+        confidence += 70;
+        version = parseVersionString(deps['@biomejs/biome']);
+        sources.push({ type: 'package.json', field: 'dependencies.@biomejs/biome' });
     }
-    // jQuery UI
-    if (deps['jquery-ui']) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.jquery-ui' });
+    if (exists(node_path.join(projectPath, 'biome.json'))) {
+        confidence += 30;
+        configPath = 'biome.json';
+        sources.push({ type: 'config-file', path: 'biome.json' });
     }
-    // jQuery plugins
-    if (deps['jquery-validation']) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies.jquery-validation' });
+    if (!configPath && exists(node_path.join(projectPath, 'biome.jsonc'))) {
+        confidence += 30;
+        configPath = 'biome.jsonc';
+        sources.push({ type: 'config-file', path: 'biome.jsonc' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'jquery',
-        name: 'jQuery',
-        category: 'legacy-frontend',
+        id: 'biome',
+        name: 'Biome',
         version,
-        confidence: min(confidence, 100),
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** All legacy framework detectors */
-const legacyDetectors = [
-    { id: 'angularjs', name: 'AngularJS', category: 'legacy-frontend', detect: angularJSDetector },
-    { id: 'backbone', name: 'Backbone.js', category: 'legacy-frontend', detect: backboneDetector },
-    { id: 'ember', name: 'Ember.js', category: 'legacy-frontend', detect: emberDetector },
-    { id: 'jquery', name: 'jQuery', category: 'legacy-frontend', detect: jqueryDetector },
-];
-
 /** Config patterns for ESLint */
 const ESLINT_CONFIG_PATTERNS = [
     'eslint.config.js',
@@ -2336,6 +2211,15 @@ const ESLINT_CONFIG_PATTERNS = [
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting ESLint linter
+ * ```typescript
+ * const result = eslintDetector('/path/to/project', {
+ *   devDependencies: { eslint: '^8.50.0', '@typescript-eslint/parser': '^6.0.0' },
+ *   scripts: { lint: 'eslint src/' },
+ * })
+ * // => { id: 'eslint', name: 'ESLint', confidence: 65, version: '8.50.0', ... }
+ * ```
  */
 function eslintDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2357,7 +2241,7 @@ function eslintDetector(projectPath, packageJson) {
         confidence += 30;
         sources.push({ type: 'package.json', field: 'eslintConfig' });
     }
-    const eslintPlugins = keys(deps).filter((d) => d.startsWith('eslint-plugin-') || d.startsWith('@typescript-eslint/') || d.startsWith('eslint-config-'));
+    const eslintPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('eslint-plugin-') || d.startsWith('@typescript-eslint/') || d.startsWith('eslint-config-'));
     if (eslintPlugins.length > 0) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies (eslint plugins)' });
@@ -2375,7 +2259,7 @@ function eslintDetector(projectPath, packageJson) {
         name: 'ESLint',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2399,6 +2283,15 @@ const PRETTIER_CONFIG_PATTERNS = [
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Prettier formatter
+ * ```typescript
+ * const result = prettierDetector('/path/to/project', {
+ *   devDependencies: { prettier: '^3.0.0' },
+ *   scripts: { format: 'prettier --write .' },
+ * })
+ * // => { id: 'prettier', name: 'Prettier', confidence: 55, version: '3.0.0', ... }
+ * ```
  */
 function prettierDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2420,12 +2313,11 @@ function prettierDetector(projectPath, packageJson) {
         confidence += 30;
         sources.push({ type: 'package.json', field: 'prettier' });
     }
-    // .prettierignore file
     if (exists(node_path.join(projectPath, '.prettierignore'))) {
         confidence += 10;
         sources.push({ type: 'config-file', path: '.prettierignore' });
     }
-    const prettierPlugins = keys(deps).filter((d) => d.startsWith('prettier-plugin-'));
+    const prettierPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('prettier-plugin-'));
     if (prettierPlugins.length > 0) {
         confidence += 5;
         sources.push({ type: 'package.json', field: 'dependencies (prettier plugins)' });
@@ -2443,7 +2335,7 @@ function prettierDetector(projectPath, packageJson) {
         name: 'Prettier',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2462,6 +2354,14 @@ const STYLELINT_CONFIG_PATTERNS = [
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Stylelint linter
+ * ```typescript
+ * const result = stylelintDetector('/path/to/project', {
+ *   devDependencies: { stylelint: '^15.0.0', 'stylelint-config-standard': '^30.0.0' },
+ * })
+ * // => { id: 'stylelint', name: 'Stylelint', confidence: 65, version: '15.0.0', ... }
+ * ```
  */
 function stylelintDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -2483,7 +2383,7 @@ function stylelintDetector(projectPath, packageJson) {
             break;
         }
     }
-    const stylelintPlugins = keys(deps).filter((d) => d.startsWith('stylelint-'));
+    const stylelintPlugins = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('stylelint-'));
     if (stylelintPlugins.length > 0) {
         confidence += 5;
         sources.push({ type: 'package.json', field: 'dependencies (stylelint plugins)' });
@@ -2496,50 +2396,7 @@ function stylelintDetector(projectPath, packageJson) {
         name: 'Stylelint',
         version,
         configPath,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect Biome in project.
- *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
- */
-function biomeDetector(projectPath, packageJson) {
-    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
-    const sources = [];
-    let confidence = 0;
-    let configPath;
-    let version;
-    const deps = collectAllDependencies(pkg);
-    // @biomejs/biome package
-    if (deps['@biomejs/biome']) {
-        confidence += 70;
-        version = parseVersionString(deps['@biomejs/biome']);
-        sources.push({ type: 'package.json', field: 'dependencies.@biomejs/biome' });
-    }
-    if (exists(node_path.join(projectPath, 'biome.json'))) {
-        confidence += 30;
-        configPath = 'biome.json';
-        sources.push({ type: 'config-file', path: 'biome.json' });
-    }
-    if (!configPath && exists(node_path.join(projectPath, 'biome.jsonc'))) {
-        confidence += 30;
-        configPath = 'biome.jsonc';
-        sources.push({ type: 'config-file', path: 'biome.jsonc' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'biome',
-        name: 'Biome',
-        version,
-        configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2553,140 +2410,179 @@ const lintingDetectors = [
 ];
 
 /**
- * Detect NX in project.
+ * Detect Lerna in project.
  *
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Lerna monorepo
+ * ```typescript
+ * // Project with lerna.json config file
+ * const result = lernaDetector('/path/to/lerna-project')
+ * // => {
+ * //   id: 'lerna',
+ * //   name: 'Lerna',
+ * //   confidence: 80,
+ * //   configPath: 'lerna.json',
+ * //   detectedFrom: [{ type: 'config-file', path: 'lerna.json' }]
+ * // }
+ * ```
  */
-function nxDetector(workspacePath, packageJson) {
+function lernaDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
     const sources = [];
     let confidence = 0;
     let version;
-    let workspaceLayout;
-    const nxJsonPath = node_path.join(workspacePath, 'nx.json');
-    if (exists(nxJsonPath)) {
-        confidence += 70;
-        sources.push({ type: 'config-file', path: 'nx.json' });
+    let configPath;
+    const lernaJsonPath = node_path.join(workspacePath, 'lerna.json');
+    if (exists(lernaJsonPath)) {
+        confidence += 80;
+        configPath = 'lerna.json';
+        sources.push({ type: 'config-file', path: 'lerna.json' });
     }
     const deps = collectAllDependencies(pkg);
-    if (deps['nx']) {
-        confidence += 20;
-        version = parseVersionString(deps['nx']);
-        sources.push({ type: 'package.json', field: 'dependencies.nx' });
-    }
-    const hasApps = exists(node_path.join(workspacePath, 'apps'));
-    const hasLibs = exists(node_path.join(workspacePath, 'libs'));
-    if (hasApps || hasLibs) {
-        confidence += 10;
-        sources.push({ type: 'directory', path: 'apps/ or libs/' });
-        workspaceLayout = {
-            appsDir: hasApps ? 'apps' : '',
-            libsDir: hasLibs ? 'libs' : '',
-        };
+    if (deps['lerna']) {
+        confidence += 15;
+        version = parseVersionString(deps['lerna']);
+        sources.push({ type: 'package.json', field: 'dependencies.lerna' });
     }
-    const nxPackages = keys(deps).filter((d) => d.startsWith('@nx/') || d.startsWith('@nrwl/'));
-    if (nxPackages.length > 0) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: '@nx/* packages' });
+    if (exists(node_path.join(workspacePath, 'packages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'packages/' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'nx',
-        name: 'NX',
+        id: 'lerna',
+        name: 'Lerna',
         version,
-        configPath: exists(nxJsonPath) ? 'nx.json' : undefined,
-        confidence: min(confidence, 100),
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
-        workspaceLayout,
     };
 }
 
 /**
- * Detect Turborepo in project.
+ * Detect npm workspaces in project.
  *
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting npm workspaces
+ * ```typescript
+ * // Project with workspaces in package.json and package-lock.json
+ * const result = npmWorkspacesDetector('/path/to/npm-project')
+ * // => {
+ * //   id: 'npm-workspaces',
+ * //   name: 'npm Workspaces',
+ * //   confidence: 90,
+ * //   configPath: 'package.json',
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'workspaces' },
+ * //     { type: 'lockfile', path: 'package-lock.json' }
+ * //   ]
+ * // }
+ * ```
  */
-function turborepoDetector(workspacePath, packageJson) {
+function npmWorkspacesDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
     const sources = [];
     let confidence = 0;
-    let version;
-    let configPath;
-    const turboJsonPath = node_path.join(workspacePath, 'turbo.json');
-    if (exists(turboJsonPath)) {
+    if (pkg?.workspaces) {
         confidence += 80;
-        configPath = 'turbo.json';
-        sources.push({ type: 'config-file', path: 'turbo.json' });
+        sources.push({ type: 'package.json', field: 'workspaces' });
     }
-    const deps = collectAllDependencies(pkg);
-    if (deps['turbo']) {
-        confidence += 15;
-        version = parseVersionString(deps['turbo']);
-        sources.push({ type: 'package.json', field: 'dependencies.turbo' });
+    if (exists(node_path.join(workspacePath, 'package-lock.json'))) {
+        confidence += 10;
+        sources.push({ type: 'lockfile', path: 'package-lock.json' });
     }
-    const scripts = pkg?.scripts ?? {};
-    if (values(scripts).some((s) => s?.includes('turbo'))) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'scripts (turbo commands)' });
+    if (exists(node_path.join(workspacePath, 'yarn.lock'))) {
+        return null;
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'turborepo',
-        name: 'Turborepo',
-        version,
-        configPath,
-        confidence: min(confidence, 100),
+        id: 'npm-workspaces',
+        name: 'npm Workspaces',
+        configPath: 'package.json',
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect Lerna in project.
+ * Detect NX in project.
  *
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting NX workspace
+ * ```typescript
+ * // Project with nx.json and apps/libs directories
+ * const result = nxDetector('/path/to/nx-workspace')
+ * // => {
+ * //   id: 'nx',
+ * //   name: 'NX',
+ * //   confidence: 100,
+ * //   configPath: 'nx.json',
+ * //   version: '17.0.0',
+ * //   workspaceLayout: { appsDir: 'apps', libsDir: 'libs' },
+ * //   detectedFrom: [
+ * //     { type: 'config-file', path: 'nx.json' },
+ * //     { type: 'package.json', field: 'dependencies.nx' },
+ * //     { type: 'directory', path: 'apps/ or libs/' }
+ * //   ]
+ * // }
+ * ```
  */
-function lernaDetector(workspacePath, packageJson) {
+function nxDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
     const sources = [];
     let confidence = 0;
     let version;
-    let configPath;
-    const lernaJsonPath = node_path.join(workspacePath, 'lerna.json');
-    if (exists(lernaJsonPath)) {
-        confidence += 80;
-        configPath = 'lerna.json';
-        sources.push({ type: 'config-file', path: 'lerna.json' });
+    let workspaceLayout;
+    const nxJsonPath = node_path.join(workspacePath, 'nx.json');
+    if (exists(nxJsonPath)) {
+        confidence += 70;
+        sources.push({ type: 'config-file', path: 'nx.json' });
     }
     const deps = collectAllDependencies(pkg);
-    if (deps['lerna']) {
-        confidence += 15;
-        version = parseVersionString(deps['lerna']);
-        sources.push({ type: 'package.json', field: 'dependencies.lerna' });
+    if (deps['nx']) {
+        confidence += 20;
+        version = parseVersionString(deps['nx']);
+        sources.push({ type: 'package.json', field: 'dependencies.nx' });
     }
-    if (exists(node_path.join(workspacePath, 'packages'))) {
-        confidence += 5;
-        sources.push({ type: 'directory', path: 'packages/' });
+    const hasApps = exists(node_path.join(workspacePath, 'apps'));
+    const hasLibs = exists(node_path.join(workspacePath, 'libs'));
+    if (hasApps || hasLibs) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'apps/ or libs/' });
+        workspaceLayout = {
+            appsDir: hasApps ? 'apps' : '',
+            libsDir: hasLibs ? 'libs' : '',
+        };
+    }
+    const nxPackages = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@nx/') || d.startsWith('@nrwl/'));
+    if (nxPackages.length > 0) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: '@nx/* packages' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'lerna',
-        name: 'Lerna',
+        id: 'nx',
+        name: 'NX',
         version,
-        configPath,
-        confidence: min(confidence, 100),
+        configPath: exists(nxJsonPath) ? 'nx.json' : undefined,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
+        workspaceLayout,
     };
 }
 
@@ -2696,6 +2592,19 @@ function lernaDetector(workspacePath, packageJson) {
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Rush monorepo
+ * ```typescript
+ * // Project with rush.json config file
+ * const result = rushDetector('/path/to/rush-project')
+ * // => {
+ * //   id: 'rush',
+ * //   name: 'Rush',
+ * //   confidence: 90,
+ * //   configPath: 'rush.json',
+ * //   detectedFrom: [{ type: 'config-file', path: 'rush.json' }]
+ * // }
+ * ```
  */
 function rushDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
@@ -2723,77 +2632,71 @@ function rushDetector(workspacePath, packageJson) {
         return null;
     }
     return {
-        id: 'rush',
-        name: 'Rush',
-        version,
-        configPath,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect pnpm workspaces in project.
- *
- * @param workspacePath - Workspace directory path
- * @returns Detection result or null if not detected
- */
-function pnpmWorkspacesDetector(workspacePath) {
-    const sources = [];
-    let confidence = 0;
-    let configPath;
-    const pnpmWorkspacePath = node_path.join(workspacePath, 'pnpm-workspace.yaml');
-    if (exists(pnpmWorkspacePath)) {
-        confidence += 90;
-        configPath = 'pnpm-workspace.yaml';
-        sources.push({ type: 'config-file', path: 'pnpm-workspace.yaml' });
-    }
-    if (exists(node_path.join(workspacePath, 'pnpm-lock.yaml'))) {
-        confidence += 10;
-        sources.push({ type: 'lockfile', path: 'pnpm-lock.yaml' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'pnpm-workspaces',
-        name: 'pnpm Workspaces',
+        id: 'rush',
+        name: 'Rush',
+        version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
 /**
- * Detect npm workspaces in project.
+ * Detect Turborepo in project.
  *
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Turborepo monorepo
+ * ```typescript
+ * // Project with turbo.json and turbo dependency
+ * const result = turborepoDetector('/path/to/turbo-project')
+ * // => {
+ * //   id: 'turborepo',
+ * //   name: 'Turborepo',
+ * //   confidence: 95,
+ * //   configPath: 'turbo.json',
+ * //   version: '2.0.0',
+ * //   detectedFrom: [
+ * //     { type: 'config-file', path: 'turbo.json' },
+ * //     { type: 'package.json', field: 'dependencies.turbo' }
+ * //   ]
+ * // }
+ * ```
  */
-function npmWorkspacesDetector(workspacePath, packageJson) {
+function turborepoDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
     const sources = [];
     let confidence = 0;
-    if (pkg?.workspaces) {
+    let version;
+    let configPath;
+    const turboJsonPath = node_path.join(workspacePath, 'turbo.json');
+    if (exists(turboJsonPath)) {
         confidence += 80;
-        sources.push({ type: 'package.json', field: 'workspaces' });
+        configPath = 'turbo.json';
+        sources.push({ type: 'config-file', path: 'turbo.json' });
     }
-    if (exists(node_path.join(workspacePath, 'package-lock.json'))) {
-        confidence += 10;
-        sources.push({ type: 'lockfile', path: 'package-lock.json' });
+    const deps = collectAllDependencies(pkg);
+    if (deps['turbo']) {
+        confidence += 15;
+        version = parseVersionString(deps['turbo']);
+        sources.push({ type: 'package.json', field: 'dependencies.turbo' });
     }
-    if (exists(node_path.join(workspacePath, 'yarn.lock'))) {
-        return null; // Let yarn workspace detector handle this
+    const scripts = pkg?.scripts ?? {};
+    if (index_cjs_js$2.values(scripts).some((s) => s?.includes('turbo'))) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'scripts (turbo commands)' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'npm-workspaces',
-        name: 'npm Workspaces',
-        configPath: 'package.json',
-        confidence: min(confidence, 100),
+        id: 'turborepo',
+        name: 'Turborepo',
+        version,
+        configPath,
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2804,6 +2707,23 @@ function npmWorkspacesDetector(workspacePath, packageJson) {
  * @param workspacePath - Workspace directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting yarn workspaces
+ * ```typescript
+ * // Project with workspaces in package.json and yarn.lock
+ * const result = yarnWorkspacesDetector('/path/to/yarn-project')
+ * // => {
+ * //   id: 'yarn-workspaces',
+ * //   name: 'Yarn Workspaces',
+ * //   confidence: 100,
+ * //   configPath: 'package.json',
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'workspaces' },
+ * //     { type: 'lockfile', path: 'yarn.lock' },
+ * //     { type: 'config-file', path: '.yarnrc.yml' }
+ * //   ]
+ * // }
+ * ```
  */
 function yarnWorkspacesDetector(workspacePath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
@@ -2828,7 +2748,7 @@ function yarnWorkspacesDetector(workspacePath, packageJson) {
         id: 'yarn-workspaces',
         name: 'Yarn Workspaces',
         configPath: 'package.json',
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2844,111 +2764,129 @@ const monorepoDetectors = [
     { id: 'yarn-workspaces', name: 'Yarn Workspaces', detect: yarnWorkspacesDetector },
 ];
 
-/** Config patterns for Jest */
-const JEST_CONFIG_PATTERNS = ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs', 'jest.config.json'];
+/** Config patterns for Cypress */
+const CYPRESS_CONFIG_PATTERNS = ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs', 'cypress.json'];
 /**
- * Detect Jest in project.
+ * Detect Cypress in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Cypress testing framework
+ * ```typescript
+ * import { cypressDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = cypressDetector('./my-project')
+ * if (result) {
+ *   console.log(`Cypress ${result.version} detected (${result.confidence}% confidence)`)
+ *   // => "Cypress 13.6.0 detected (95% confidence)"
+ * }
+ * ```
  */
-function jestDetector(projectPath, packageJson) {
+function cypressDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['jest']) {
+    if (deps['cypress']) {
         confidence += 60;
-        version = parseVersionString(deps['jest']);
-        sources.push({ type: 'package.json', field: 'dependencies.jest' });
+        version = parseVersionString(deps['cypress']);
+        sources.push({ type: 'package.json', field: 'dependencies.cypress' });
     }
-    const configPath = locateConfigFile(projectPath, JEST_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, CYPRESS_CONFIG_PATTERNS);
     if (configPath) {
         confidence += 30;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (pkg && 'jest' in pkg) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'jest' });
-    }
-    const testScript = pkg?.scripts?.['test'] ?? '';
-    if (testScript.includes('jest')) {
+    if (exists(node_path.join(projectPath, 'cypress'))) {
         confidence += 10;
-        sources.push({ type: 'package.json', field: 'scripts.test' });
-    }
-    if (deps['@types/jest']) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies.@types/jest' });
+        sources.push({ type: 'directory', path: 'cypress/' });
     }
-    if (deps['ts-jest']) {
+    const e2eScript = pkg?.scripts?.['e2e'] ?? pkg?.scripts?.['test:e2e'] ?? '';
+    if (e2eScript.includes('cypress')) {
         confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies.ts-jest' });
+        sources.push({ type: 'package.json', field: 'scripts.e2e or scripts.test:e2e' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'jest',
-        name: 'Jest',
-        type: 'unit',
+        id: 'cypress',
+        name: 'Cypress',
+        type: 'e2e',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Vitest */
-const VITEST_CONFIG_PATTERNS = ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'];
+/** Config patterns for Jest */
+const JEST_CONFIG_PATTERNS = ['jest.config.js', 'jest.config.ts', 'jest.config.mjs', 'jest.config.cjs', 'jest.config.json'];
 /**
- * Detect Vitest in project.
+ * Detect Jest in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Jest testing framework
+ * ```typescript
+ * import { jestDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = jestDetector('./my-project')
+ * if (result) {
+ *   console.log(`Jest ${result.version} detected`)
+ *   console.log('Sources:', result.detectedFrom.map(s => s.type))
+ *   // => "Sources: ['package.json', 'config-file']"
+ * }
+ * ```
  */
-function vitestDetector(projectPath, packageJson) {
+function jestDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['vitest']) {
-        confidence += 70;
-        version = parseVersionString(deps['vitest']);
-        sources.push({ type: 'package.json', field: 'dependencies.vitest' });
+    if (deps['jest']) {
+        confidence += 60;
+        version = parseVersionString(deps['jest']);
+        sources.push({ type: 'package.json', field: 'dependencies.jest' });
     }
-    const configPath = locateConfigFile(projectPath, VITEST_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, JEST_CONFIG_PATTERNS);
     if (configPath) {
-        confidence += 25;
+        confidence += 30;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (!configPath) {
-        const viteConfig = exists(node_path.join(projectPath, 'vite.config.ts')) ||
-            exists(node_path.join(projectPath, 'vite.config.js')) ||
-            exists(node_path.join(projectPath, 'vite.config.mjs'));
-        if (viteConfig && deps['vitest']) {
-            confidence += 5;
-            sources.push({ type: 'config-file', path: 'vite.config.*' });
-        }
+    if (pkg && 'jest' in pkg) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'jest' });
     }
     const testScript = pkg?.scripts?.['test'] ?? '';
-    if (testScript.includes('vitest')) {
+    if (testScript.includes('jest')) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'scripts.test' });
     }
+    if (deps['@types/jest']) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies.@types/jest' });
+    }
+    if (deps['ts-jest']) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies.ts-jest' });
+    }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'vitest',
-        name: 'Vitest',
+        id: 'jest',
+        name: 'Jest',
         type: 'unit',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -2961,6 +2899,17 @@ const MOCHA_CONFIG_PATTERNS = ['.mocharc.js', '.mocharc.json', '.mocharc.yaml',
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Mocha testing framework
+ * ```typescript
+ * import { mochaDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = mochaDetector('./my-project')
+ * if (result) {
+ *   console.log(`Mocha ${result.version} detected (${result.confidence}%)`)
+ *   // => "Mocha 10.2.0 detected (95%)"
+ * }
+ * ```
  */
 function mochaDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -3000,42 +2949,58 @@ function mochaDetector(projectPath, packageJson) {
         type: 'unit',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Cypress */
-const CYPRESS_CONFIG_PATTERNS = ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs', 'cypress.json'];
+/** Config patterns for Playwright */
+const PLAYWRIGHT_CONFIG_PATTERNS = ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs'];
 /**
- * Detect Cypress in project.
+ * Detect Playwright in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Playwright testing framework
+ * ```typescript
+ * import { playwrightDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = playwrightDetector('./my-project')
+ * if (result) {
+ *   console.log(`Playwright ${result.version} (${result.type} tests)`)
+ *   // => "Playwright 1.42.0 (e2e tests)"
+ * }
+ * ```
  */
-function cypressDetector(projectPath, packageJson) {
+function playwrightDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['cypress']) {
-        confidence += 60;
-        version = parseVersionString(deps['cypress']);
-        sources.push({ type: 'package.json', field: 'dependencies.cypress' });
+    if (deps['@playwright/test']) {
+        confidence += 70;
+        version = parseVersionString(deps['@playwright/test']);
+        sources.push({ type: 'package.json', field: 'dependencies.@playwright/test' });
     }
-    const configPath = locateConfigFile(projectPath, CYPRESS_CONFIG_PATTERNS);
+    if (deps['playwright']) {
+        confidence += 50;
+        version = version ?? parseVersionString(deps['playwright']);
+        sources.push({ type: 'package.json', field: 'dependencies.playwright' });
+    }
+    const configPath = locateConfigFile(projectPath, PLAYWRIGHT_CONFIG_PATTERNS);
     if (configPath) {
-        confidence += 30;
+        confidence += 25;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (exists(node_path.join(projectPath, 'cypress'))) {
-        confidence += 10;
-        sources.push({ type: 'directory', path: 'cypress/' });
+    if (exists(node_path.join(projectPath, 'e2e')) || exists(node_path.join(projectPath, 'tests'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'e2e/ or tests/' });
     }
     const e2eScript = pkg?.scripts?.['e2e'] ?? pkg?.scripts?.['test:e2e'] ?? '';
-    if (e2eScript.includes('cypress')) {
+    if (e2eScript.includes('playwright')) {
         confidence += 5;
         sources.push({ type: 'package.json', field: 'scripts.e2e or scripts.test:e2e' });
     }
@@ -3043,65 +3008,77 @@ function cypressDetector(projectPath, packageJson) {
         return null;
     }
     return {
-        id: 'cypress',
-        name: 'Cypress',
+        id: 'playwright',
+        name: 'Playwright',
         type: 'e2e',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
 
-/** Config patterns for Playwright */
-const PLAYWRIGHT_CONFIG_PATTERNS = ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs'];
+/** Config patterns for Vitest */
+const VITEST_CONFIG_PATTERNS = ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'];
 /**
- * Detect Playwright in project.
+ * Detect Vitest in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Vitest testing framework
+ * ```typescript
+ * import { vitestDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = vitestDetector('./my-project')
+ * if (result) {
+ *   console.log(`Vitest ${result.version} detected`)
+ *   console.log('Config:', result.configPath)
+ *   // => "Config: vitest.config.ts"
+ * }
+ * ```
  */
-function playwrightDetector(projectPath, packageJson) {
+function vitestDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@playwright/test']) {
+    if (deps['vitest']) {
         confidence += 70;
-        version = parseVersionString(deps['@playwright/test']);
-        sources.push({ type: 'package.json', field: 'dependencies.@playwright/test' });
-    }
-    if (deps['playwright']) {
-        confidence += 50;
-        version = version ?? parseVersionString(deps['playwright']);
-        sources.push({ type: 'package.json', field: 'dependencies.playwright' });
+        version = parseVersionString(deps['vitest']);
+        sources.push({ type: 'package.json', field: 'dependencies.vitest' });
     }
-    const configPath = locateConfigFile(projectPath, PLAYWRIGHT_CONFIG_PATTERNS);
+    const configPath = locateConfigFile(projectPath, VITEST_CONFIG_PATTERNS);
     if (configPath) {
         confidence += 25;
         sources.push({ type: 'config-file', path: configPath });
     }
-    if (exists(node_path.join(projectPath, 'e2e')) || exists(node_path.join(projectPath, 'tests'))) {
-        confidence += 5;
-        sources.push({ type: 'directory', path: 'e2e/ or tests/' });
+    if (!configPath) {
+        const viteConfig = exists(node_path.join(projectPath, 'vite.config.ts')) ||
+            exists(node_path.join(projectPath, 'vite.config.js')) ||
+            exists(node_path.join(projectPath, 'vite.config.mjs'));
+        if (viteConfig && deps['vitest']) {
+            confidence += 5;
+            sources.push({ type: 'config-file', path: 'vite.config.*' });
+        }
     }
-    const e2eScript = pkg?.scripts?.['e2e'] ?? pkg?.scripts?.['test:e2e'] ?? '';
-    if (e2eScript.includes('playwright')) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'scripts.e2e or scripts.test:e2e' });
+    const testScript = pkg?.scripts?.['test'] ?? '';
+    if (testScript.includes('vitest')) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'scripts.test' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'playwright',
-        name: 'Playwright',
-        type: 'e2e',
+        id: 'vitest',
+        name: 'Vitest',
+        type: 'unit',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -3127,9 +3104,8 @@ function checkTsConfigStrict(projectPath) {
     if (!content)
         return undefined;
     try {
-        // Simple JSON parsing - doesn't handle comments but good enough for strict check
         const cleanContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-        const parsed = parse(cleanContent);
+        const parsed = index_cjs_js$6.parse(cleanContent);
         return parsed?.compilerOptions?.strict === true;
     }
     catch {
@@ -3142,6 +3118,19 @@ function checkTsConfigStrict(projectPath) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting TypeScript
+ * ```typescript
+ * import { typescriptDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = typescriptDetector('./my-project')
+ * if (result) {
+ *   console.log(`TypeScript ${result.version}`)
+ *   console.log(`Strict mode: ${result.strictMode ?? 'unknown'}`)
+ *   // => "TypeScript 5.3.0"
+ *   // => "Strict mode: true"
+ * }
+ * ```
  */
 function typescriptDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -3150,19 +3139,16 @@ function typescriptDetector(projectPath, packageJson) {
     let configPath;
     let version;
     const deps = collectAllDependencies(pkg);
-    // TypeScript package
     if (deps['typescript']) {
         confidence += 50;
         version = parseVersionString(deps['typescript']);
         sources.push({ type: 'package.json', field: 'dependencies.typescript' });
     }
-    // tsconfig.json
     if (exists(node_path.join(projectPath, 'tsconfig.json'))) {
         confidence += 40;
         configPath = 'tsconfig.json';
         sources.push({ type: 'config-file', path: 'tsconfig.json' });
     }
-    // tsconfig.*.json variants
     const tsconfigVariants = ['tsconfig.build.json', 'tsconfig.lib.json', 'tsconfig.spec.json', 'tsconfig.app.json'];
     for (const variant of tsconfigVariants) {
         if (exists(node_path.join(projectPath, variant))) {
@@ -3171,8 +3157,7 @@ function typescriptDetector(projectPath, packageJson) {
             break;
         }
     }
-    // @types packages
-    const typePackages = keys(deps).filter((d) => d.startsWith('@types/'));
+    const typePackages = index_cjs_js$2.keys(deps).filter((d) => d.startsWith('@types/'));
     if (typePackages.length > 0) {
         confidence += 10;
         sources.push({ type: 'package.json', field: '@types/* packages' });
@@ -3187,7 +3172,7 @@ function typescriptDetector(projectPath, packageJson) {
         version,
         configPath,
         strictMode,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -3197,6 +3182,17 @@ function typescriptDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Flow type system
+ * ```typescript
+ * import { flowDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = flowDetector('./my-project')
+ * if (result) {
+ *   console.log(`Flow ${result.version} with config: ${result.configPath}`)
+ *   // => "Flow 0.232.0 with config: .flowconfig"
+ * }
+ * ```
  */
 function flowDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -3205,24 +3201,20 @@ function flowDetector(projectPath, packageJson) {
     let configPath;
     let version;
     const deps = collectAllDependencies(pkg);
-    // flow-bin package
     if (deps['flow-bin']) {
         confidence += 60;
         version = parseVersionString(deps['flow-bin']);
         sources.push({ type: 'package.json', field: 'dependencies.flow-bin' });
     }
-    // .flowconfig
     if (exists(node_path.join(projectPath, '.flowconfig'))) {
         confidence += 40;
         configPath = '.flowconfig';
         sources.push({ type: 'config-file', path: '.flowconfig' });
     }
-    // flow-typed directory
     if (exists(node_path.join(projectPath, 'flow-typed'))) {
         confidence += 10;
         sources.push({ type: 'directory', path: 'flow-typed/' });
     }
-    // @babel/preset-flow
     if (deps['@babel/preset-flow']) {
         confidence += 10;
         sources.push({ type: 'package.json', field: 'dependencies.@babel/preset-flow' });
@@ -3235,7 +3227,7 @@ function flowDetector(projectPath, packageJson) {
         name: 'Flow',
         version,
         configPath,
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -3246,7 +3238,6 @@ function flowDetector(projectPath, packageJson) {
  * @returns `true` if the content contains JSDoc type annotations.
  */
 function hasJsDocTypes(content) {
-    // Check for JSDoc type annotations
     return (content.includes('@type {') ||
         content.includes('@param {') ||
         content.includes('@returns {') ||
@@ -3259,26 +3250,35 @@ function hasJsDocTypes(content) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting JSDoc type annotations
+ * ```typescript
+ * import { jsdocDetector } from '@hyperfrontend/project-scope'
+ *
+ * const result = jsdocDetector('./my-project')
+ * if (result) {
+ *   console.log('JSDoc types detected')
+ *   console.log('Sources:', result.detectedFrom.map(s => s.path ?? s.field))
+ *   // => "Sources: ['jsconfig.json', 'src/utils.js (JSDoc annotations)']"
+ * }
+ * ```
  */
 function jsdocDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     const deps = collectAllDependencies(pkg);
-    // jsdoc package
     if (deps['jsdoc']) {
         confidence += 30;
         sources.push({ type: 'package.json', field: 'dependencies.jsdoc' });
     }
-    // typescript with checkJs (JSDoc type checking)
     if (deps['typescript']) {
-        // Check if checkJs is enabled in tsconfig
         const tsconfigPath = node_path.join(projectPath, 'tsconfig.json');
         const content = readFileIfExists(tsconfigPath);
         if (content) {
             try {
                 const cleanContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-                const parsed = parse(cleanContent);
+                const parsed = index_cjs_js$6.parse(cleanContent);
                 if (parsed?.compilerOptions?.checkJs === true || parsed?.compilerOptions?.allowJs === true) {
                     confidence += 30;
                     sources.push({ type: 'config-file', path: 'tsconfig.json (checkJs/allowJs)' });
@@ -3289,12 +3289,10 @@ function jsdocDetector(projectPath, packageJson) {
             }
         }
     }
-    // Check for jsconfig.json (VS Code JS type checking)
     if (exists(node_path.join(projectPath, 'jsconfig.json'))) {
         confidence += 40;
         sources.push({ type: 'config-file', path: 'jsconfig.json' });
     }
-    // Sample check for JSDoc annotations in source files
     const srcDir = node_path.join(projectPath, 'src');
     if (exists(srcDir)) {
         try {
@@ -3319,7 +3317,7 @@ function jsdocDetector(projectPath, packageJson) {
     return {
         id: 'jsdoc',
         name: 'JSDoc',
-        confidence: min(confidence, 100),
+        confidence: index_cjs_js$8.min(confidence, 100),
         detectedFrom: sources,
     };
 }
@@ -3345,8 +3343,6 @@ const detectAllCache = createCache({ ttl: 60000, maxSize: 50 });
 function isDetectAllOptions(value) {
     if (typeof value !== 'object' || value === null)
         return false;
-    // DetectAllOptions has skipCache or packageJson fields specifically
-    // PackageJson never has skipCache field
     return 'skipCache' in value || 'packageJson' in value;
 }
 /**
@@ -3359,7 +3355,7 @@ function isDetectAllOptions(value) {
  * @param packageJsonOrOptions - Optional pre-loaded package.json or options object
  * @returns All detection results organized by category
  *
- * @example
+ * @example Running all tech detectors
  * ```typescript
  * import { detectAll } from '@hyperfrontend/project-scope'
  *
@@ -3378,9 +3374,7 @@ function isDetectAllOptions(value) {
  * ```
  */
 function detectAll(projectPath, packageJsonOrOptions) {
-    // Handle backward-compatible arguments
     const options = isDetectAllOptions(packageJsonOrOptions) ? packageJsonOrOptions : { packageJson: packageJsonOrOptions };
-    // Check cache first (unless skipCache is true)
     if (!options.skipCache) {
         const cached = detectAllCache.get(projectPath);
         if (cached) {
@@ -3431,7 +3425,6 @@ function detectAll(projectPath, packageJsonOrOptions) {
         legacyFrameworks: result.legacyFrameworks.map((f) => f.id),
         testingFrameworks: result.testingFrameworks.map((f) => f.id),
     });
-    // Cache the result
     detectAllCache.set(projectPath, result);
     return result;
 }
@@ -3479,7 +3472,7 @@ function buildSummary(frontend, backend, testing) {
  * @param options - Identification options
  * @returns Framework identification result
  *
- * @example
+ * @example Identifying all frameworks in project
  * ```typescript
  * import { identifyFrameworks } from '@hyperfrontend/project-scope'
  *
@@ -3594,6 +3587,14 @@ function identifyFrameworks(projectPath, options) {
  * Clear the framework identification cache.
  *
  * Useful for testing or when the project files have changed.
+ *
+ * @example Clearing the framework cache
+ * ```typescript
+ * import { clearFrameworkIdentificationCache } from '@hyperfrontend/project-scope'
+ *
+ * // Reset cache before re-identifying frameworks
+ * clearFrameworkIdentificationCache()
+ * ```
  */
 function clearFrameworkIdentificationCache() {
     frameworkIdCache.clear();
@@ -3605,6 +3606,15 @@ function clearFrameworkIdentificationCache() {
  * @param frameworkId - Framework identifier to check
  * @param minConfidence - Minimum confidence threshold (default: 50)
  * @returns True if the framework is detected with sufficient confidence
+ *
+ * @example Checking for a specific framework
+ * ```typescript
+ * import { usesFramework } from '@hyperfrontend/project-scope'
+ *
+ * if (usesFramework('/path/to/project', 'react', 70)) {
+ *   console.log('Project uses React with high confidence')
+ * }
+ * ```
  */
 function usesFramework(projectPath, frameworkId, minConfidence = 50) {
     const identification = identifyFrameworks(projectPath, { minConfidence });
@@ -3615,4 +3625,3 @@ function usesFramework(projectPath, frameworkId, minConfidence = 50) {
 exports.clearFrameworkIdentificationCache = clearFrameworkIdentificationCache;
 exports.identifyFrameworks = identifyFrameworks;
 exports.usesFramework = usesFramework;
-//# sourceMappingURL=index.cjs.js.map