@hyperfrontend/project-scope 0.1.0

package/heuristics/project-type/index.esm.js

@@ -0,0 +1,3631 @@
+import { join as join$1 } from 'node:path';
+import { existsSync, readFileSync, statSync, lstatSync, readdirSync } from 'node:fs';
+
+/**
+ * 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;
+
+/**
+ * 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 value of a number rounded to the nearest integer.
+ */
+const round = _Math.round;
+/**
+ * (Safe copy) Returns the smaller of zero or more numbers.
+ */
+const min = _Math.min;
+
+/**
+ * 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 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$2 = 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$2.construct(_Error, [message, options]);
+
+/**
+ * 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 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] : []);
+
+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 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 = 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.construct(_Map, iterable ? [iterable] : []);
+
+/* 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);
+
+/**
+ * Global log level registry.
+ * Tracks all created scoped loggers to allow global log level changes.
+ */
+const loggerRegistry = createSet();
+/** Redacted placeholder for sensitive values */
+const REDACTED = '[REDACTED]';
+/**
+ * Patterns that indicate a sensitive key name.
+ * Keys containing these patterns will have their values sanitized.
+ */
+const SENSITIVE_KEY_PATTERNS = [
+    /token/i,
+    /key/i,
+    /password/i,
+    /secret/i,
+    /credential/i,
+    /auth/i,
+    /bearer/i,
+    /api[_-]?key/i,
+    /private/i,
+    /passphrase/i,
+];
+/**
+ * Checks if a key name indicates sensitive data.
+ *
+ * @param key - Key name to check
+ * @returns True if the key indicates sensitive data
+ */
+function isSensitiveKey(key) {
+    return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+/**
+ * Sanitizes an object by replacing sensitive values with REDACTED.
+ * This function recursively processes nested objects and arrays.
+ *
+ * @param obj - Object to sanitize
+ * @returns New object with sensitive values redacted
+ */
+function sanitize(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (isArray(obj)) {
+        return obj.map((item) => sanitize(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of entries(obj)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                result[key] = sanitize(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Formats a log message with optional metadata.
+ *
+ * @param namespace - Logger namespace prefix
+ * @param message - Log message
+ * @param meta - Optional metadata object
+ * @returns Formatted log string
+ */
+function formatMessage(namespace, message, meta) {
+    const prefix = `[${namespace}]`;
+    if (meta && keys(meta).length > 0) {
+        const sanitizedMeta = sanitize(meta);
+        return `${prefix} ${message} ${stringify(sanitizedMeta)}`;
+    }
+    return `${prefix} ${message}`;
+}
+/**
+ * Creates a scoped logger with namespace prefix and optional secret sanitization.
+ * All log messages will be prefixed with [namespace] and sensitive metadata
+ * values will be automatically redacted.
+ *
+ * @param namespace - Logger namespace (e.g., 'project-scope', 'analyze')
+ * @param options - Logger configuration options
+ * @returns A configured scoped logger instance
+ *
+ * @example
+ * ```typescript
+ * const logger = createScopedLogger('project-scope')
+ * logger.setLogLevel('debug')
+ *
+ * // Basic logging
+ * logger.info('Starting analysis', { path: './project' })
+ *
+ * // Sensitive data is automatically redacted
+ * logger.debug('Config loaded', { apiKey: 'secret123' })
+ * // Output: [project-scope] Config loaded {"apiKey":"[REDACTED]"}
+ * ```
+ */
+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)
+    baseLogger.setLogLevel(level);
+    const scopedLogger = freeze({
+        error: (message, meta) => baseLogger.error(message, meta),
+        warn: (message, meta) => baseLogger.warn(message, meta),
+        log: (message, meta) => baseLogger.log(message, meta),
+        info: (message, meta) => baseLogger.info(message, meta),
+        debug: (message, meta) => baseLogger.debug(message, meta),
+        setLogLevel: baseLogger.setLogLevel,
+        getLogLevel: baseLogger.getLogLevel,
+    });
+    // Register logger for global level management
+    loggerRegistry.add(scopedLogger);
+    return scopedLogger;
+}
+/**
+ * Default logger instance for the project-scope library.
+ * Use this for general logging within the library.
+ *
+ * @example
+ * ```typescript
+ * import { logger } from '@hyperfrontend/project-scope/core'
+ *
+ * logger.setLogLevel('debug')
+ * logger.debug('Analyzing project', { path: './src' })
+ * ```
+ */
+createScopedLogger('project-scope');
+
+createScopedLogger('project-scope:fs');
+/**
+ * Create a file system error with code and context.
+ *
+ * @param message - The error message describing what went wrong
+ * @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
+ */
+function createFileSystemError(message, code, context) {
+    const error = createError(message);
+    defineProperties(error, {
+        code: { value: code, enumerable: true },
+        context: { value: context, enumerable: true },
+    });
+    return error;
+}
+/**
+ * Read file if exists, return null otherwise.
+ *
+ * @param filePath - Path to file
+ * @param encoding - File encoding (default: utf-8)
+ * @returns File contents or null if file doesn't exist
+ */
+function readFileIfExists(filePath, encoding = 'utf-8') {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return readFileSync(filePath, { encoding });
+    }
+    catch {
+        return null;
+    }
+}
+
+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 (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const stat = followSymlinks ? statSync(filePath) : 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 existsSync(filePath);
+}
+
+const fsDirLogger = createScopedLogger('project-scope:fs:dir');
+/**
+ * List immediate contents of a directory.
+ *
+ * @param dirPath - Absolute or relative path to the directory
+ * @returns Array of entries with metadata for each file/directory
+ * @throws {Error} If directory doesn't exist or isn't a directory
+ *
+ * @example
+ * ```typescript
+ * import { readDirectory } from '@hyperfrontend/project-scope'
+ *
+ * const entries = readDirectory('./src')
+ * for (const entry of entries) {
+ *   console.log(entry.name, entry.isFile ? 'file' : 'directory')
+ * }
+ * ```
+ */
+function readDirectory(dirPath) {
+    fsDirLogger.debug('Reading directory', { path: dirPath });
+    if (!existsSync(dirPath)) {
+        fsDirLogger.debug('Directory not found', { path: dirPath });
+        throw createFileSystemError(`Directory not found: ${dirPath}`, 'FS_NOT_FOUND', { path: dirPath, operation: 'readdir' });
+    }
+    if (!isDirectory(dirPath)) {
+        fsDirLogger.debug('Path is not a directory', { path: dirPath });
+        throw createFileSystemError(`Not a directory: ${dirPath}`, 'FS_NOT_A_DIRECTORY', { path: dirPath, operation: 'readdir' });
+    }
+    try {
+        const entries = readdirSync(dirPath, { withFileTypes: true });
+        fsDirLogger.debug('Directory read complete', { path: dirPath, entryCount: entries.length });
+        return entries.map((entry) => ({
+            name: entry.name,
+            path: join$1(dirPath, entry.name),
+            isFile: entry.isFile(),
+            isDirectory: entry.isDirectory(),
+            isSymlink: entry.isSymbolicLink(),
+        }));
+    }
+    catch (error) {
+        fsDirLogger.warn('Failed to read directory', { path: dirPath, error: error instanceof Error ? error.message : String(error) });
+        throw createFileSystemError(`Failed to read directory: ${dirPath}`, 'FS_READ_ERROR', {
+            path: dirPath,
+            operation: 'readdir',
+            cause: error,
+        });
+    }
+}
+
+/**
+ * Join path segments.
+ * Uses platform-specific separators (e.g., / or \).
+ *
+ * @param paths - Path segments to join
+ * @returns Joined path
+ */
+function join(...paths) {
+    return join$1(...paths);
+}
+
+createScopedLogger('project-scope:fs:traversal');
+
+const packageLogger = createScopedLogger('project-scope:project:package');
+/**
+ * Verifies that a value is an object with only string values,
+ * used for validating dependency maps and script definitions.
+ *
+ * @param value - Value to check
+ * @returns True if value is a record of strings
+ */
+function isStringRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return values(value).every((v) => typeof v === 'string');
+}
+/**
+ * Extracts and normalizes the workspaces field from package.json,
+ * supporting both array format and object with packages array.
+ *
+ * @param value - Raw workspaces value from package.json
+ * @returns Normalized workspace patterns or undefined if invalid
+ */
+function parseWorkspaces(value) {
+    if (isArray(value) && value.every((v) => typeof v === 'string')) {
+        return value;
+    }
+    if (typeof value === 'object' && value !== null) {
+        const obj = value;
+        if (isArray(obj['packages'])) {
+            return { packages: obj['packages'] };
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate and normalize package.json data.
+ *
+ * @param data - Raw parsed data
+ * @returns Validated package.json
+ */
+function validatePackageJson(data) {
+    if (typeof data !== 'object' || data === null) {
+        throw createError('package.json must be an object');
+    }
+    const pkg = data;
+    return {
+        name: typeof pkg['name'] === 'string' ? pkg['name'] : undefined,
+        version: typeof pkg['version'] === 'string' ? pkg['version'] : undefined,
+        description: typeof pkg['description'] === 'string' ? pkg['description'] : undefined,
+        main: typeof pkg['main'] === 'string' ? pkg['main'] : undefined,
+        module: typeof pkg['module'] === 'string' ? pkg['module'] : undefined,
+        browser: typeof pkg['browser'] === 'string' ? pkg['browser'] : undefined,
+        types: typeof pkg['types'] === 'string' ? pkg['types'] : undefined,
+        bin: typeof pkg['bin'] === 'string' || isStringRecord(pkg['bin']) ? pkg['bin'] : undefined,
+        scripts: isStringRecord(pkg['scripts']) ? pkg['scripts'] : undefined,
+        dependencies: isStringRecord(pkg['dependencies']) ? pkg['dependencies'] : undefined,
+        devDependencies: isStringRecord(pkg['devDependencies']) ? pkg['devDependencies'] : undefined,
+        peerDependencies: isStringRecord(pkg['peerDependencies']) ? pkg['peerDependencies'] : undefined,
+        optionalDependencies: isStringRecord(pkg['optionalDependencies']) ? pkg['optionalDependencies'] : undefined,
+        workspaces: parseWorkspaces(pkg['workspaces']),
+        exports: typeof pkg['exports'] === 'object' ? pkg['exports'] : undefined,
+        engines: isStringRecord(pkg['engines']) ? pkg['engines'] : undefined,
+        ...pkg,
+    };
+}
+/**
+ * Attempts to read and parse package.json if it exists,
+ * returning null on missing file or parse failure.
+ *
+ * @param projectPath - Project directory path or path to package.json
+ * @returns Parsed package.json or null if not found
+ */
+function readPackageJsonIfExists(projectPath) {
+    const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : join$1(projectPath, 'package.json');
+    const content = readFileIfExists(packageJsonPath);
+    if (!content) {
+        packageLogger.debug('Package.json not found', { path: packageJsonPath });
+        return null;
+    }
+    try {
+        const validated = validatePackageJson(parse(content));
+        packageLogger.debug('Package.json loaded', { path: packageJsonPath, name: validated.name });
+        return validated;
+    }
+    catch {
+        packageLogger.debug('Failed to parse package.json, returning null', { path: packageJsonPath });
+        return null;
+    }
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Get combined dependencies from package.json.
+ * Merges dependencies, devDependencies, peerDependencies, and optionalDependencies.
+ *
+ * @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 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
+ */
+function expressDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['express']) {
+        confidence += 80;
+        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');
+    if (expressMiddleware.length > 0) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies (express middleware)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'express',
+        name: 'Express',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect NestJS in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function nestDetector(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 (exists(join$1(projectPath, 'nest-cli.json'))) {
+        confidence += 15;
+        configPath = 'nest-cli.json';
+        sources.push({ type: 'config-file', path: 'nest-cli.json' });
+    }
+    const nestPackages = 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: 'nestjs',
+        name: 'NestJS',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Fastify in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function fastifyDetector(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' });
+    }
+    const fastifyPlugins = keys(deps).filter((d) => d.startsWith('@fastify/') || d.startsWith('fastify-'));
+    if (fastifyPlugins.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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'fastify',
+        name: 'Fastify',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Koa in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function koaDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['koa']) {
+        confidence += 80;
+        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/'));
+    if (koaMiddleware.length > 0) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies (koa middleware)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'koa',
+        name: 'Koa',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Hono in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function honoDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['hono']) {
+        confidence += 85;
+        version = parseVersionString(deps['hono']);
+        sources.push({ type: 'package.json', field: 'dependencies.hono' });
+    }
+    const honoAdapters = keys(deps).filter((d) => d.startsWith('@hono/'));
+    if (honoAdapters.length > 0) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies (@hono adapters)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'hono',
+        name: 'Hono',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** All backend framework detectors */
+const backendDetectors = [
+    { id: 'express', name: 'Express', detect: expressDetector },
+    { id: 'nestjs', name: 'NestJS', detect: nestDetector },
+    { id: 'fastify', name: 'Fastify', detect: fastifyDetector },
+    { id: 'koa', name: 'Koa', detect: koaDetector },
+    { 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',
+];
+/**
+ * Detect Webpack in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function webpackDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['webpack']) {
+        confidence += 50;
+        version = parseVersionString(deps['webpack']);
+        sources.push({ type: 'package.json', field: 'dependencies.webpack' });
+    }
+    const configPath = locateConfigFile(projectPath, WEBPACK_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (deps['webpack-cli']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.webpack-cli' });
+    }
+    const scriptMatches = filterScriptsByCommand(pkg?.scripts, 'webpack');
+    for (const name of scriptMatches) {
+        confidence = min(confidence + 5, 100);
+        sources.push({ type: 'package.json', field: `scripts.${name}` });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'webpack',
+        name: 'Webpack',
+        version,
+        configPath,
+        confidence: 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'];
+/**
+ * Detect Vite in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function viteDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['vite']) {
+        confidence += 60;
+        version = parseVersionString(deps['vite']);
+        sources.push({ type: 'package.json', field: 'dependencies.vite' });
+    }
+    const configPath = locateConfigFile(projectPath, VITE_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 35;
+        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)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'vite',
+        name: 'Vite',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Rollup */
+const ROLLUP_CONFIG_PATTERNS = ['rollup.config.js', 'rollup.config.ts', 'rollup.config.mjs', 'rollup.config.cjs'];
+/**
+ * Detect Rollup in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function rollupDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['rollup']) {
+        confidence += 55;
+        version = parseVersionString(deps['rollup']);
+        sources.push({ type: 'package.json', field: 'dependencies.rollup' });
+    }
+    const configPath = locateConfigFile(projectPath, ROLLUP_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    const rollupPlugins = 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);
+        sources.push({ type: 'package.json', field: `scripts.${name}` });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'rollup',
+        name: 'Rollup',
+        version,
+        configPath,
+        confidence: 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
+ */
+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 = 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 + 10, 100);
+        sources.push({ type: 'package.json', field: `scripts.${name}` });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'esbuild',
+        name: 'esbuild',
+        version,
+        confidence: 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'];
+/**
+ * Detect Babel in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function babelDetector(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' });
+    }
+    const configPath = locateConfigFile(projectPath, BABEL_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (pkg && 'babel' in pkg) {
+        confidence += 30;
+        sources.push({ type: 'package.json', field: 'babel' });
+    }
+    const babelPackages = keys(deps).filter((d) => d.startsWith('@babel/'));
+    if (babelPackages.length > 1) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies (@babel packages)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'babel',
+        name: 'Babel',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for SWC */
+const SWC_CONFIG_PATTERNS = ['.swcrc', 'swc.config.js'];
+/**
+ * Detect SWC in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function swcDetector(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' });
+    }
+    const configPath = locateConfigFile(projectPath, SWC_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 35;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (deps['@swc/cli']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.@swc/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)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'swc',
+        name: 'SWC',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Parcel */
+const PARCEL_CONFIG_PATTERNS = ['.parcelrc'];
+/**
+ * Detect Parcel in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function parcelDetector(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['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 += 30;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    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 (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'parcel',
+        name: 'Parcel',
+        version,
+        configPath,
+        confidence: 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.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function reactDetector(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['react-native']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.react-native' });
+    }
+    const hasJsxFiles = exists(join$1(projectPath, 'src', 'App.tsx')) ||
+        exists(join$1(projectPath, 'src', 'App.jsx')) ||
+        exists(join$1(projectPath, 'src', 'index.tsx')) ||
+        exists(join$1(projectPath, 'src', 'index.jsx'));
+    if (hasJsxFiles) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/*.tsx or src/*.jsx' });
+    }
+    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['gatsby']) {
+        metaFrameworks.push({
+            id: 'gatsby',
+            name: 'Gatsby',
+            category: 'meta-framework',
+            version: parseVersionString(deps['gatsby']),
+            confidence: 90,
+            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: 'react',
+        name: 'React',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
+    };
+}
+
+/**
+ * Detect Next.js in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function nextjsDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['next']) {
+        confidence += 70;
+        version = parseVersionString(deps['next']);
+        sources.push({ type: 'package.json', field: 'dependencies.next' });
+    }
+    if (exists(join$1(projectPath, 'next.config.js')) ||
+        exists(join$1(projectPath, 'next.config.mjs')) ||
+        exists(join$1(projectPath, 'next.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'next.config.*' });
+    }
+    if (exists(join$1(projectPath, 'pages')) ||
+        exists(join$1(projectPath, 'app')) ||
+        exists(join$1(projectPath, 'src', 'pages')) ||
+        exists(join$1(projectPath, 'src', 'app'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'pages/ or app/' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'nextjs',
+        name: 'Next.js',
+        category: 'meta-framework',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Remix in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function remixDetector(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']) {
+        confidence += 70;
+        version = parseVersionString(deps['@remix-run/react']);
+        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/react' });
+    }
+    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(join$1(projectPath, 'remix.config.js')) || exists(join$1(projectPath, 'remix.config.ts'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'remix.config.*' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'remix',
+        name: 'Remix',
+        category: 'meta-framework',
+        version,
+        confidence: 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
+ */
+function gatsbyDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['gatsby']) {
+        confidence += 70;
+        version = parseVersionString(deps['gatsby']);
+        sources.push({ type: 'package.json', field: 'dependencies.gatsby' });
+    }
+    if (exists(join$1(projectPath, 'gatsby-config.js')) || exists(join$1(projectPath, 'gatsby-config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'gatsby-config.*' });
+    }
+    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 (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'gatsby',
+        name: 'Gatsby',
+        category: 'meta-framework',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * 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 vueDetector(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['@vue/cli-service']) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies.@vue/cli-service' });
+    }
+    const hasVueFiles = exists(join$1(projectPath, 'src', 'App.vue')) || exists(join$1(projectPath, 'src', 'main.vue'));
+    if (hasVueFiles) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/*.vue' });
+    }
+    if (exists(join$1(projectPath, 'vue.config.js'))) {
+        confidence += 5;
+        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: 'vue',
+        name: 'Vue',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
+    };
+}
+
+/**
+ * Detect Nuxt in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function nuxtDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['nuxt'] || deps['nuxt3']) {
+        confidence += 70;
+        version = parseVersionString(deps['nuxt'] ?? deps['nuxt3']);
+        sources.push({ type: 'package.json', field: 'dependencies.nuxt' });
+    }
+    if (exists(join$1(projectPath, 'nuxt.config.js')) || exists(join$1(projectPath, 'nuxt.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
+    }
+    if (exists(join$1(projectPath, 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'pages/' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'nuxt',
+        name: 'Nuxt',
+        category: 'meta-framework',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Angular in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function angularDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['@angular/core']) {
+        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' });
+    }
+    if (exists(join$1(projectPath, 'angular.json'))) {
+        confidence += 15;
+        sources.push({ type: 'config-file', path: 'angular.json' });
+    }
+    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: 'angular',
+        name: 'Angular',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Svelte in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function svelteDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const metaFrameworks = [];
+    const deps = collectAllDependencies(pkg);
+    if (deps['svelte']) {
+        confidence += 70;
+        version = parseVersionString(deps['svelte']);
+        sources.push({ type: 'package.json', field: 'dependencies.svelte' });
+    }
+    if (exists(join$1(projectPath, 'svelte.config.js'))) {
+        confidence += 20;
+        sources.push({ type: 'config-file', path: 'svelte.config.js' });
+    }
+    const hasSvelteFiles = exists(join$1(projectPath, 'src', 'App.svelte')) || exists(join$1(projectPath, 'src', 'routes'));
+    if (hasSvelteFiles) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/*.svelte or src/routes/' });
+    }
+    if (deps['@sveltejs/kit']) {
+        metaFrameworks.push({
+            id: 'sveltekit',
+            name: 'SvelteKit',
+            category: 'meta-framework',
+            version: parseVersionString(deps['@sveltejs/kit']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.@sveltejs/kit' }],
+        });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'svelte',
+        name: 'Svelte',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
+    };
+}
+
+/**
+ * Detect SvelteKit in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function sveltekitDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    // @sveltejs/kit package
+    if (deps['@sveltejs/kit']) {
+        confidence += 70;
+        version = parseVersionString(deps['@sveltejs/kit']);
+        sources.push({ type: 'package.json', field: 'dependencies.@sveltejs/kit' });
+    }
+    if (exists(join$1(projectPath, 'svelte.config.js'))) {
+        confidence += 20;
+        sources.push({ type: 'config-file', path: 'svelte.config.js' });
+    }
+    if (exists(join$1(projectPath, 'src', 'routes'))) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/routes/' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'sveltekit',
+        name: 'SvelteKit',
+        category: 'meta-framework',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Solid 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
+ */
+function qwikDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    // @builder.io/qwik package
+    if (deps['@builder.io/qwik']) {
+        confidence += 70;
+        version = parseVersionString(deps['@builder.io/qwik']);
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik' });
+    }
+    // @builder.io/qwik-city
+    if (deps['@builder.io/qwik-city']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik-city' });
+    }
+    if (exists(join$1(projectPath, 'qwik.config.ts')) || exists(join$1(projectPath, 'qwik.config.js'))) {
+        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(join$1(projectPath, 'astro.config.mjs')) ||
+        exists(join$1(projectPath, 'astro.config.ts')) ||
+        exists(join$1(projectPath, 'astro.config.js'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'astro.config.*' });
+    }
+    if (exists(join$1(projectPath, 'src', 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'src/pages/' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'astro',
+        name: 'Astro',
+        category: 'meta-framework',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** All frontend framework detectors */
+const frameworkDetectors = [
+    { id: 'react', name: 'React', category: 'frontend', detect: reactDetector },
+    { id: 'nextjs', name: 'Next.js', category: 'meta-framework', detect: nextjsDetector },
+    { id: 'remix', name: 'Remix', category: 'meta-framework', detect: remixDetector },
+    { id: 'gatsby', name: 'Gatsby', category: 'meta-framework', detect: gatsbyDetector },
+    { id: 'vue', name: 'Vue', category: 'frontend', detect: vueDetector },
+    { id: 'nuxt', name: 'Nuxt', category: 'meta-framework', detect: nuxtDetector },
+    { id: 'angular', name: 'Angular', category: 'frontend', detect: angularDetector },
+    { id: 'svelte', name: 'Svelte', category: 'frontend', detect: svelteDetector },
+    { id: 'sveltekit', name: 'SvelteKit', category: 'meta-framework', detect: sveltekitDetector },
+    { id: 'solid', name: 'Solid', category: 'frontend', detect: solidDetector },
+    { id: 'qwik', name: 'Qwik', category: 'frontend', detect: qwikDetector },
+    { id: 'astro', name: 'Astro', category: 'meta-framework', detect: astroDetector },
+];
+
+/**
+ * Detect AngularJS (1.x) in project.
+ * AngularJS is the original Angular framework, distinct from Angular 2+.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function angularJSDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'angularjs',
+        name: 'AngularJS',
+        category: 'legacy-frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Backbone.js in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function backboneDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'backbone',
+        name: 'Backbone.js',
+        category: 'legacy-frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Ember.js in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function emberDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'ember',
+        name: 'Ember.js',
+        category: 'legacy-frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect jQuery in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function jqueryDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    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' });
+    }
+    // jQuery UI
+    if (deps['jquery-ui']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.jquery-ui' });
+    }
+    // jQuery plugins
+    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: 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',
+    'eslint.config.mjs',
+    'eslint.config.cjs',
+    'eslint.config.ts',
+    '.eslintrc.js',
+    '.eslintrc.cjs',
+    '.eslintrc.json',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+    '.eslintrc',
+];
+/**
+ * Detect ESLint in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function eslintDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['eslint']) {
+        confidence += 50;
+        version = parseVersionString(deps['eslint']);
+        sources.push({ type: 'package.json', field: 'dependencies.eslint' });
+    }
+    const configPath = locateConfigFile(projectPath, ESLINT_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (pkg && 'eslintConfig' in pkg) {
+        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-'));
+    if (eslintPlugins.length > 0) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies (eslint plugins)' });
+    }
+    const lintScript = pkg?.scripts?.['lint'] ?? '';
+    if (lintScript.includes('eslint')) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'scripts.lint' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'eslint',
+        name: 'ESLint',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Prettier */
+const PRETTIER_CONFIG_PATTERNS = [
+    'prettier.config.js',
+    'prettier.config.mjs',
+    'prettier.config.cjs',
+    '.prettierrc',
+    '.prettierrc.json',
+    '.prettierrc.yaml',
+    '.prettierrc.yml',
+    '.prettierrc.js',
+    '.prettierrc.cjs',
+    '.prettierrc.toml',
+];
+/**
+ * Detect Prettier in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function prettierDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['prettier']) {
+        confidence += 50;
+        version = parseVersionString(deps['prettier']);
+        sources.push({ type: 'package.json', field: 'dependencies.prettier' });
+    }
+    const configPath = locateConfigFile(projectPath, PRETTIER_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (pkg && 'prettier' in pkg) {
+        confidence += 30;
+        sources.push({ type: 'package.json', field: 'prettier' });
+    }
+    // .prettierignore file
+    if (exists(join$1(projectPath, '.prettierignore'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: '.prettierignore' });
+    }
+    const prettierPlugins = keys(deps).filter((d) => d.startsWith('prettier-plugin-'));
+    if (prettierPlugins.length > 0) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies (prettier plugins)' });
+    }
+    const formatScript = pkg?.scripts?.['format'] ?? pkg?.scripts?.['prettier'] ?? '';
+    if (formatScript.includes('prettier')) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'scripts.format' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'prettier',
+        name: 'Prettier',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Stylelint */
+const STYLELINT_CONFIG_PATTERNS = [
+    '.stylelintrc',
+    '.stylelintrc.json',
+    '.stylelintrc.js',
+    'stylelint.config.js',
+    'stylelint.config.cjs',
+];
+/**
+ * Detect Stylelint in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function stylelintDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let configPath;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['stylelint']) {
+        confidence += 60;
+        version = parseVersionString(deps['stylelint']);
+        sources.push({ type: 'package.json', field: 'dependencies.stylelint' });
+    }
+    for (const config of STYLELINT_CONFIG_PATTERNS) {
+        if (exists(join$1(projectPath, config))) {
+            confidence += 35;
+            configPath = config;
+            sources.push({ type: 'config-file', path: config });
+            break;
+        }
+    }
+    const stylelintPlugins = keys(deps).filter((d) => d.startsWith('stylelint-'));
+    if (stylelintPlugins.length > 0) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies (stylelint plugins)' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'stylelint',
+        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(join$1(projectPath, 'biome.json'))) {
+        confidence += 30;
+        configPath = 'biome.json';
+        sources.push({ type: 'config-file', path: 'biome.json' });
+    }
+    if (!configPath && exists(join$1(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),
+        detectedFrom: sources,
+    };
+}
+
+/** All linting tool detectors */
+const lintingDetectors = [
+    { id: 'eslint', name: 'ESLint', detect: eslintDetector },
+    { id: 'prettier', name: 'Prettier', detect: prettierDetector },
+    { id: 'stylelint', name: 'Stylelint', detect: stylelintDetector },
+    { id: 'biome', name: 'Biome', detect: biomeDetector },
+];
+
+/**
+ * Detect NX in project.
+ *
+ * @param workspacePath - Workspace directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function nxDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    let workspaceLayout;
+    const nxJsonPath = join$1(workspacePath, 'nx.json');
+    if (exists(nxJsonPath)) {
+        confidence += 70;
+        sources.push({ type: 'config-file', path: 'nx.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(join$1(workspacePath, 'apps'));
+    const hasLibs = exists(join$1(workspacePath, 'libs'));
+    if (hasApps || hasLibs) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'apps/ or libs/' });
+        workspaceLayout = {
+            appsDir: hasApps ? 'apps' : '',
+            libsDir: hasLibs ? 'libs' : '',
+        };
+    }
+    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 (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'nx',
+        name: 'NX',
+        version,
+        configPath: exists(nxJsonPath) ? 'nx.json' : undefined,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+        workspaceLayout,
+    };
+}
+
+/**
+ * Detect Turborepo in project.
+ *
+ * @param workspacePath - Workspace directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function turborepoDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    let configPath;
+    const turboJsonPath = join$1(workspacePath, 'turbo.json');
+    if (exists(turboJsonPath)) {
+        confidence += 80;
+        configPath = 'turbo.json';
+        sources.push({ type: 'config-file', path: 'turbo.json' });
+    }
+    const deps = collectAllDependencies(pkg);
+    if (deps['turbo']) {
+        confidence += 15;
+        version = parseVersionString(deps['turbo']);
+        sources.push({ type: 'package.json', field: 'dependencies.turbo' });
+    }
+    const scripts = pkg?.scripts ?? {};
+    if (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: 'turborepo',
+        name: 'Turborepo',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Lerna in project.
+ *
+ * @param workspacePath - Workspace directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function lernaDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    let configPath;
+    const lernaJsonPath = join$1(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['lerna']) {
+        confidence += 15;
+        version = parseVersionString(deps['lerna']);
+        sources.push({ type: 'package.json', field: 'dependencies.lerna' });
+    }
+    if (exists(join$1(workspacePath, 'packages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'packages/' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'lerna',
+        name: 'Lerna',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Rush in project.
+ *
+ * @param workspacePath - Workspace directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function rushDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    let configPath;
+    const rushJsonPath = join$1(workspacePath, 'rush.json');
+    if (exists(rushJsonPath)) {
+        confidence += 90;
+        configPath = 'rush.json';
+        sources.push({ type: 'config-file', path: 'rush.json' });
+    }
+    const deps = collectAllDependencies(pkg);
+    if (deps['@microsoft/rush']) {
+        confidence += 10;
+        version = parseVersionString(deps['@microsoft/rush']);
+        sources.push({ type: 'package.json', field: 'dependencies.@microsoft/rush' });
+    }
+    if (exists(join$1(workspacePath, 'common', 'config', 'rush'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'common/config/rush/' });
+    }
+    if (confidence === 0) {
+        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 = join$1(workspacePath, 'pnpm-workspace.yaml');
+    if (exists(pnpmWorkspacePath)) {
+        confidence += 90;
+        configPath = 'pnpm-workspace.yaml';
+        sources.push({ type: 'config-file', path: 'pnpm-workspace.yaml' });
+    }
+    if (exists(join$1(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',
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * 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
+ */
+function npmWorkspacesDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    if (pkg?.workspaces) {
+        confidence += 80;
+        sources.push({ type: 'package.json', field: 'workspaces' });
+    }
+    if (exists(join$1(workspacePath, 'package-lock.json'))) {
+        confidence += 10;
+        sources.push({ type: 'lockfile', path: 'package-lock.json' });
+    }
+    if (exists(join$1(workspacePath, 'yarn.lock'))) {
+        return null; // Let yarn workspace detector handle this
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'npm-workspaces',
+        name: 'npm Workspaces',
+        configPath: 'package.json',
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect yarn workspaces in project.
+ *
+ * @param workspacePath - Workspace directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function yarnWorkspacesDetector(workspacePath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(workspacePath);
+    const sources = [];
+    let confidence = 0;
+    if (pkg?.workspaces) {
+        confidence += 70;
+        sources.push({ type: 'package.json', field: 'workspaces' });
+    }
+    if (exists(join$1(workspacePath, 'yarn.lock'))) {
+        confidence += 20;
+        sources.push({ type: 'lockfile', path: 'yarn.lock' });
+    }
+    if (exists(join$1(workspacePath, '.yarnrc.yml'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: '.yarnrc.yml' });
+    }
+    if (confidence === 0 || !pkg?.workspaces) {
+        return null;
+    }
+    return {
+        id: 'yarn-workspaces',
+        name: 'Yarn Workspaces',
+        configPath: 'package.json',
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** All monorepo detectors */
+const monorepoDetectors = [
+    { id: 'nx', name: 'NX', detect: nxDetector },
+    { id: 'turborepo', name: 'Turborepo', detect: turborepoDetector },
+    { id: 'lerna', name: 'Lerna', detect: lernaDetector },
+    { id: 'rush', name: 'Rush', detect: rushDetector },
+    { id: 'pnpm-workspaces', name: 'pnpm Workspaces', detect: pnpmWorkspacesDetector },
+    { id: 'npm-workspaces', name: 'npm Workspaces', detect: npmWorkspacesDetector },
+    { 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'];
+/**
+ * Detect Jest in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function jestDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['jest']) {
+        confidence += 60;
+        version = parseVersionString(deps['jest']);
+        sources.push({ type: 'package.json', field: 'dependencies.jest' });
+    }
+    const configPath = locateConfigFile(projectPath, JEST_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')) {
+        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: 'jest',
+        name: 'Jest',
+        type: 'unit',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Vitest */
+const VITEST_CONFIG_PATTERNS = ['vitest.config.js', 'vitest.config.ts', 'vitest.config.mjs'];
+/**
+ * Detect Vitest in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function vitestDetector(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' });
+    }
+    const configPath = locateConfigFile(projectPath, VITEST_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (!configPath) {
+        const viteConfig = exists(join$1(projectPath, 'vite.config.ts')) ||
+            exists(join$1(projectPath, 'vite.config.js')) ||
+            exists(join$1(projectPath, 'vite.config.mjs'));
+        if (viteConfig && deps['vitest']) {
+            confidence += 5;
+            sources.push({ type: 'config-file', path: 'vite.config.*' });
+        }
+    }
+    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: 'vitest',
+        name: 'Vitest',
+        type: 'unit',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Mocha */
+const MOCHA_CONFIG_PATTERNS = ['.mocharc.js', '.mocharc.json', '.mocharc.yaml', '.mocharc.yml', 'mocha.opts'];
+/**
+ * Detect Mocha in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function mochaDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['mocha']) {
+        confidence += 65;
+        version = parseVersionString(deps['mocha']);
+        sources.push({ type: 'package.json', field: 'dependencies.mocha' });
+    }
+    const configPath = locateConfigFile(projectPath, MOCHA_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 30;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (deps['@types/mocha']) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies.@types/mocha' });
+    }
+    if (deps['chai']) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'dependencies.chai' });
+    }
+    const testScript = pkg?.scripts?.['test'] ?? '';
+    if (testScript.includes('mocha')) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'scripts.test' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'mocha',
+        name: 'Mocha',
+        type: 'unit',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Cypress */
+const CYPRESS_CONFIG_PATTERNS = ['cypress.config.js', 'cypress.config.ts', 'cypress.config.mjs', 'cypress.json'];
+/**
+ * Detect Cypress in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function cypressDetector(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' });
+    }
+    const configPath = locateConfigFile(projectPath, CYPRESS_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 30;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (exists(join$1(projectPath, 'cypress'))) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'cypress/' });
+    }
+    const e2eScript = pkg?.scripts?.['e2e'] ?? pkg?.scripts?.['test:e2e'] ?? '';
+    if (e2eScript.includes('cypress')) {
+        confidence += 5;
+        sources.push({ type: 'package.json', field: 'scripts.e2e or scripts.test:e2e' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'cypress',
+        name: 'Cypress',
+        type: 'e2e',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** Config patterns for Playwright */
+const PLAYWRIGHT_CONFIG_PATTERNS = ['playwright.config.js', 'playwright.config.ts', 'playwright.config.mjs'];
+/**
+ * Detect Playwright in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function playwrightDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['@playwright/test']) {
+        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' });
+    }
+    const configPath = locateConfigFile(projectPath, PLAYWRIGHT_CONFIG_PATTERNS);
+    if (configPath) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: configPath });
+    }
+    if (exists(join$1(projectPath, 'e2e')) || exists(join$1(projectPath, 'tests'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'e2e/ or tests/' });
+    }
+    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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'playwright',
+        name: 'Playwright',
+        type: 'e2e',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/** All testing framework detectors */
+const testingDetectors = [
+    { id: 'jest', name: 'Jest', testType: 'unit', detect: jestDetector },
+    { id: 'vitest', name: 'Vitest', testType: 'unit', detect: vitestDetector },
+    { id: 'mocha', name: 'Mocha', testType: 'unit', detect: mochaDetector },
+    { id: 'cypress', name: 'Cypress', testType: 'e2e', detect: cypressDetector },
+    { id: 'playwright', name: 'Playwright', testType: 'e2e', detect: playwrightDetector },
+];
+
+/**
+ * Check if tsconfig has strict mode enabled.
+ *
+ * @param projectPath - The project directory path
+ * @returns True if strict mode is enabled, undefined if unable to determine
+ */
+function checkTsConfigStrict(projectPath) {
+    const tsconfigPath = join$1(projectPath, 'tsconfig.json');
+    const content = readFileIfExists(tsconfigPath);
+    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);
+        return parsed?.compilerOptions?.strict === true;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Detect TypeScript in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function typescriptDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    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(join$1(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(join$1(projectPath, variant))) {
+            confidence += 5;
+            sources.push({ type: 'config-file', path: variant });
+            break;
+        }
+    }
+    // @types packages
+    const typePackages = keys(deps).filter((d) => d.startsWith('@types/'));
+    if (typePackages.length > 0) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: '@types/* packages' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    const strictMode = checkTsConfigStrict(projectPath);
+    return {
+        id: 'typescript',
+        name: 'TypeScript',
+        version,
+        configPath,
+        strictMode,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+/**
+ * Detect Flow in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function flowDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    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(join$1(projectPath, '.flowconfig'))) {
+        confidence += 40;
+        configPath = '.flowconfig';
+        sources.push({ type: 'config-file', path: '.flowconfig' });
+    }
+    // flow-typed directory
+    if (exists(join$1(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' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'flow',
+        name: 'Flow',
+        version,
+        configPath,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+/**
+ * Check if a file contains JSDoc type annotations.
+ *
+ * @param content - The file content to check.
+ * @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 {') ||
+        content.includes('@typedef') ||
+        content.includes('@template'));
+}
+/**
+ * Detect JSDoc type annotations in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+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 = join$1(projectPath, 'tsconfig.json');
+        const content = readFileIfExists(tsconfigPath);
+        if (content) {
+            try {
+                const cleanContent = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+                const parsed = parse(cleanContent);
+                if (parsed?.compilerOptions?.checkJs === true || parsed?.compilerOptions?.allowJs === true) {
+                    confidence += 30;
+                    sources.push({ type: 'config-file', path: 'tsconfig.json (checkJs/allowJs)' });
+                }
+            }
+            catch {
+                // Ignore parsing errors
+            }
+        }
+    }
+    // Check for jsconfig.json (VS Code JS type checking)
+    if (exists(join$1(projectPath, 'jsconfig.json'))) {
+        confidence += 40;
+        sources.push({ type: 'config-file', path: 'jsconfig.json' });
+    }
+    // Sample check for JSDoc annotations in source files
+    const srcDir = join$1(projectPath, 'src');
+    if (exists(srcDir)) {
+        try {
+            const entries = readDirectory(srcDir);
+            const files = entries.filter((e) => e.isFile && (e.name.endsWith('.js') || e.name.endsWith('.mjs'))).map((e) => e.name);
+            for (const file of files.slice(0, 3)) {
+                const content = readFileIfExists(join$1(srcDir, file));
+                if (content && hasJsDocTypes(content)) {
+                    confidence += 20;
+                    sources.push({ type: 'directory', path: `src/${file} (JSDoc annotations)` });
+                    break;
+                }
+            }
+        }
+        catch {
+            // Ignore directory read errors
+        }
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'jsdoc',
+        name: 'JSDoc',
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+/** All type system detectors */
+const typeSystemDetectors = [
+    { id: 'typescript', name: 'TypeScript', detect: typescriptDetector },
+    { id: 'flow', name: 'Flow', detect: flowDetector },
+    { id: 'jsdoc', name: 'JSDoc', detect: jsdocDetector },
+];
+
+const techLogger = createScopedLogger('project-scope:tech');
+/**
+ * Cache for tech detection results.
+ * TTL: 60 seconds (tech stack can change during active development)
+ */
+const detectAllCache = createCache({ ttl: 60000, maxSize: 50 });
+/**
+ * Check if the value is a DetectAllOptions object.
+ *
+ * @param value - Value to check
+ * @returns True if value is DetectAllOptions
+ */
+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;
+}
+/**
+ * Run all technology detectors on a project.
+ *
+ * Results are cached for 60 seconds per project path to avoid
+ * redundant file system operations on repeated calls.
+ *
+ * @param projectPath - Path to project directory
+ * @param packageJsonOrOptions - Optional pre-loaded package.json or options object
+ * @returns All detection results organized by category
+ *
+ * @example
+ * ```typescript
+ * import { detectAll } from '@hyperfrontend/project-scope'
+ *
+ * const detections = detectAll('./my-project')
+ *
+ * // Check frontend frameworks
+ * for (const fw of detections.frontendFrameworks) {
+ *   console.log(`${fw.name} v${fw.version} (${fw.confidence}% confidence)`)
+ * }
+ *
+ * // Check build tools
+ * console.log('Build tools:', detections.buildTools.map(t => t.name))
+ *
+ * // Check testing frameworks
+ * console.log('Testing:', detections.testingFrameworks.map(t => t.name))
+ * ```
+ */
+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) {
+            techLogger.debug('Returning cached tech detection results', { projectPath });
+            return cached;
+        }
+    }
+    const pkg = options.packageJson ?? readPackageJsonIfExists(projectPath);
+    techLogger.debug('Running all tech detectors', { projectPath });
+    const result = {
+        buildTools: buildToolDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        monorepo: monorepoDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        frontendFrameworks: frameworkDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        backendFrameworks: backendDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        legacyFrameworks: legacyDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        testingFrameworks: testingDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        typeSystem: typeSystemDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+        linting: lintingDetectors
+            .map((d) => d.detect(projectPath, pkg ?? undefined))
+            .filter((r) => r !== null)
+            .sort((a, b) => b.confidence - a.confidence),
+    };
+    techLogger.debug('Tech detection complete', {
+        buildTools: result.buildTools.map((t) => t.id),
+        frontendFrameworks: result.frontendFrameworks.map((f) => f.id),
+        backendFrameworks: result.backendFrameworks.map((f) => f.id),
+        legacyFrameworks: result.legacyFrameworks.map((f) => f.id),
+        testingFrameworks: result.testingFrameworks.map((f) => f.id),
+    });
+    // Cache the result
+    detectAllCache.set(projectPath, result);
+    return result;
+}
+
+const projectTypeLogger = createScopedLogger('project-scope:heuristics:project-type');
+/**
+ * Detect the type of a project based on its structure and configuration.
+ *
+ * Uses multiple heuristics including:
+ * - Package name patterns
+ * - Exports/main/module fields
+ * - Binary (bin) field
+ * - Entry point patterns
+ * - Testing framework presence
+ * - Directory structure
+ * - Framework detection
+ * - NX project type field
+ *
+ * @param projectPath - Project directory path
+ * @param options - Detection options
+ * @returns Project type detection result with confidence score
+ *
+ * @example
+ * ```typescript
+ * import { detectProjectType } from '@hyperfrontend/project-scope'
+ *
+ * const result = detectProjectType('./my-lib')
+ * console.log(result.type)       // 'library' | 'application' | 'e2e' | 'tool' | 'plugin'
+ * console.log(result.confidence) // 85
+ * console.log(result.evidence)   // [{ factor: 'exports', confidence: 20, ... }]
+ * ```
+ */
+function detectProjectType(projectPath, options) {
+    projectTypeLogger.debug('Detecting project type', { projectPath, skipTechDetection: options?.skipTechDetection });
+    const evidence = [];
+    const typeScores = {
+        application: 0,
+        library: 0,
+        e2e: 0,
+        tool: 0,
+        plugin: 0,
+        unknown: 0,
+    };
+    const packageJson = readPackageJsonIfExists(projectPath);
+    if (packageJson?.name) {
+        const name = packageJson.name;
+        if (name.includes('-e2e') || name.endsWith('-test') || name.includes('e2e-')) {
+            typeScores.e2e += 30;
+            evidence.push({ factor: 'name-pattern', confidence: 30, description: `Name suggests e2e: ${name}` });
+        }
+        if (name.includes('-plugin') || name.includes('/plugin-')) {
+            typeScores.plugin += 30;
+            evidence.push({ factor: 'name-pattern', confidence: 30, description: `Name suggests plugin: ${name}` });
+        }
+        if (name.includes('-cli') || name.includes('/cli') || name.endsWith('-cli')) {
+            typeScores.tool += 25;
+            evidence.push({ factor: 'name-pattern', confidence: 25, description: `Name suggests CLI tool: ${name}` });
+        }
+        if (name.includes('-lib') || name.includes('/lib-') || name.includes('-utils') || name.includes('/utils')) {
+            typeScores.library += 15;
+            evidence.push({ factor: 'name-pattern', confidence: 15, description: `Name suggests library: ${name}` });
+        }
+        if (name.includes('-app') || name.includes('/app-') || name.includes('-web') || name.includes('-frontend')) {
+            typeScores.application += 15;
+            evidence.push({ factor: 'name-pattern', confidence: 15, description: `Name suggests application: ${name}` });
+        }
+    }
+    if (packageJson?.exports || packageJson?.main || packageJson?.module) {
+        typeScores.library += 20;
+        evidence.push({ factor: 'exports', confidence: 20, description: 'Has exports/main/module field' });
+    }
+    if (packageJson && 'bin' in packageJson) {
+        typeScores.tool += 40;
+        evidence.push({ factor: 'bin-field', confidence: 40, description: 'Has bin field (CLI executable)' });
+    }
+    const serverEntryPatterns = ['src/server.ts', 'src/server.js', 'server.ts', 'server.js', 'src/main.ts', 'src/app.ts'];
+    const indexEntryPatterns = ['src/index.ts', 'src/index.js', 'index.ts', 'index.js', 'lib/index.ts', 'lib/index.js'];
+    const hasServerEntry = serverEntryPatterns.some((p) => exists(join$1(projectPath, p)));
+    const hasIndexEntry = indexEntryPatterns.some((p) => exists(join$1(projectPath, p)));
+    if (hasServerEntry) {
+        typeScores.application += 30;
+        evidence.push({ factor: 'entry-point', confidence: 30, description: 'Has server/app entry point' });
+    }
+    if (hasIndexEntry && !hasServerEntry) {
+        typeScores.library += 20;
+        evidence.push({ factor: 'entry-point', confidence: 20, description: 'Has library-style index entry' });
+    }
+    if (options?.skipTechDetection !== true) {
+        const techDetections = detectAll(projectPath, packageJson ?? undefined);
+        const e2eFrameworkIds = ['cypress', 'playwright', 'puppeteer', 'webdriverio'];
+        const hasE2EFramework = techDetections.testingFrameworks.some((t) => e2eFrameworkIds.includes(t.id));
+        if (hasE2EFramework) {
+            typeScores.e2e += 25;
+            evidence.push({ factor: 'e2e-framework', confidence: 25, description: 'Has E2E testing framework' });
+        }
+        const unitFrameworkIds = ['jest', 'vitest', 'mocha'];
+        const hasUnitFramework = techDetections.testingFrameworks.some((t) => unitFrameworkIds.includes(t.id) && t.type === 'unit');
+        if (hasUnitFramework && !hasE2EFramework) {
+            typeScores.library += 10;
+            evidence.push({ factor: 'unit-framework', confidence: 10, description: 'Has unit testing framework' });
+        }
+        const hasFrontendFramework = techDetections.frontendFrameworks.length > 0;
+        const hasBackendFramework = techDetections.backendFrameworks.length > 0;
+        if (hasFrontendFramework || hasBackendFramework) {
+            typeScores.application += 20;
+            const frameworks = [
+                ...techDetections.frontendFrameworks.map((f) => f.name),
+                ...techDetections.backendFrameworks.map((f) => f.name),
+            ].join(', ');
+            evidence.push({ factor: 'framework', confidence: 20, description: `Uses application framework: ${frameworks}` });
+        }
+    }
+    const hasPublicDir = exists(join$1(projectPath, 'public'));
+    const hasStaticDir = exists(join$1(projectPath, 'static'));
+    const hasAssetsDir = exists(join$1(projectPath, 'assets'));
+    const hasPagesDir = exists(join$1(projectPath, 'pages')) || exists(join$1(projectPath, 'src', 'pages'));
+    const hasAppDir = exists(join$1(projectPath, 'app')) || exists(join$1(projectPath, 'src', 'app'));
+    const hasLibDir = exists(join$1(projectPath, 'lib')) || exists(join$1(projectPath, 'src', 'lib'));
+    const hasCypressDir = exists(join$1(projectPath, 'cypress'));
+    const hasE2EDir = exists(join$1(projectPath, 'e2e'));
+    if (hasPublicDir || hasStaticDir || hasAssetsDir) {
+        typeScores.application += 15;
+        evidence.push({ factor: 'structure', confidence: 15, description: 'Has public/static/assets directory' });
+    }
+    if (hasPagesDir || hasAppDir) {
+        typeScores.application += 15;
+        evidence.push({ factor: 'structure', confidence: 15, description: 'Has pages/app directory' });
+    }
+    if (hasLibDir && !hasPagesDir && !hasAppDir) {
+        typeScores.library += 10;
+        evidence.push({ factor: 'structure', confidence: 10, description: 'Has lib directory' });
+    }
+    if (hasCypressDir || hasE2EDir) {
+        typeScores.e2e += 20;
+        evidence.push({ factor: 'structure', confidence: 20, description: 'Has cypress/e2e directory' });
+    }
+    const projectJsonPath = join$1(projectPath, 'project.json');
+    const projectJsonContent = readFileIfExists(projectJsonPath);
+    if (projectJsonContent) {
+        try {
+            const projectJson = parse(projectJsonContent);
+            if (projectJson.projectType) {
+                const nxType = projectJson.projectType === 'library' ? 'library' : 'application';
+                typeScores[nxType] += 50;
+                evidence.push({ factor: 'nx-project-type', confidence: 50, description: `NX project type: ${projectJson.projectType}` });
+            }
+            const tags = projectJson.tags ?? [];
+            if (tags.some((t) => t.includes('e2e'))) {
+                typeScores.e2e += 15;
+                evidence.push({ factor: 'nx-tags', confidence: 15, description: 'NX tags contain e2e' });
+            }
+            if (tags.some((t) => t.includes('util') || t.includes('lib'))) {
+                typeScores.library += 10;
+                evidence.push({ factor: 'nx-tags', confidence: 10, description: 'NX tags suggest library' });
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    const hasNextConfig = exists(join$1(projectPath, 'next.config.js')) || exists(join$1(projectPath, 'next.config.mjs'));
+    const hasAngularJson = exists(join$1(projectPath, 'angular.json'));
+    const hasDockerfile = exists(join$1(projectPath, 'Dockerfile'));
+    if (hasNextConfig || hasAngularJson) {
+        typeScores.application += 25;
+        evidence.push({ factor: 'framework-config', confidence: 25, description: 'Has framework config (Next.js/Angular)' });
+    }
+    if (hasDockerfile) {
+        typeScores.application += 10;
+        evidence.push({ factor: 'docker', confidence: 10, description: 'Has Dockerfile' });
+    }
+    const sortedTypes = entries(typeScores)
+        .sort(([, a], [, b]) => b - a)
+        .filter(([, score]) => score > 0);
+    const [primaryType, primaryScore] = sortedTypes[0] ?? ['unknown', 0];
+    const secondaryTypes = sortedTypes.slice(1).map(([type]) => type);
+    const totalScore = values(typeScores).reduce((a, b) => a + b, 0);
+    const confidence = totalScore > 0 ? min(round((primaryScore / totalScore) * 100), 100) : 0;
+    projectTypeLogger.debug('Project type detection complete', {
+        projectPath,
+        detectedType: primaryType,
+        confidence,
+        evidenceCount: evidence.length,
+        secondaryTypes,
+    });
+    return {
+        type: primaryType,
+        secondaryTypes,
+        confidence,
+        evidence,
+    };
+}
+
+export { detectProjectType };
+//# sourceMappingURL=index.esm.js.map