@hyperfrontend/project-scope 0.1.0

package/tech/frontend/index.cjs.js

@@ -0,0 +1,1310 @@
+'use strict';
+
+var node_path = require('node:path');
+var node_fs = require('node:fs');
+
+/**
+ * Safe copies of Math built-in methods.
+ *
+ * These references are captured at module initialization time to protect against
+ * prototype pollution attacks. Import only what you need for tree-shaking.
+ *
+ * @module @hyperfrontend/immutable-api-utils/built-in-copy/math
+ */
+// Capture references at module initialization time
+const _Math = globalThis.Math;
+/**
+ * (Safe copy) Returns the smaller of zero or more numbers.
+ */
+const min = _Math.min;
+
+/**
+ * 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$1 = 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$1.construct(_Error, [message, options]);
+
+/**
+ * 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 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 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 = 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.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;
+};
+
+/* 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');
+/**
+ * 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 (!node_fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return node_fs.readFileSync(filePath, { encoding });
+    }
+    catch {
+        return null;
+    }
+}
+
+createScopedLogger('project-scope:fs:write');
+
+/**
+ * Check if path exists.
+ *
+ * @param filePath - Path to check
+ * @returns True if path exists
+ */
+function exists(filePath) {
+    return node_fs.existsSync(filePath);
+}
+
+createScopedLogger('project-scope:fs:dir');
+
+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 : node_path.join(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;
+    }
+}
+
+/**
+ * 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);
+}
+
+/**
+ * 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(node_path.join(projectPath, 'src', 'App.tsx')) ||
+        exists(node_path.join(projectPath, 'src', 'App.jsx')) ||
+        exists(node_path.join(projectPath, 'src', 'index.tsx')) ||
+        exists(node_path.join(projectPath, 'src', 'index.jsx'));
+    if (hasJsxFiles) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/*.tsx or src/*.jsx' });
+    }
+    if (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(node_path.join(projectPath, 'next.config.js')) ||
+        exists(node_path.join(projectPath, 'next.config.mjs')) ||
+        exists(node_path.join(projectPath, 'next.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'next.config.*' });
+    }
+    if (exists(node_path.join(projectPath, 'pages')) ||
+        exists(node_path.join(projectPath, 'app')) ||
+        exists(node_path.join(projectPath, 'src', 'pages')) ||
+        exists(node_path.join(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(node_path.join(projectPath, 'remix.config.js')) || exists(node_path.join(projectPath, 'remix.config.ts'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'remix.config.*' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: '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(node_path.join(projectPath, 'gatsby-config.js')) || exists(node_path.join(projectPath, 'gatsby-config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'gatsby-config.*' });
+    }
+    const gatsbyPlugins = 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(node_path.join(projectPath, 'src', 'App.vue')) || exists(node_path.join(projectPath, 'src', 'main.vue'));
+    if (hasVueFiles) {
+        confidence += 10;
+        sources.push({ type: 'directory', path: 'src/*.vue' });
+    }
+    if (exists(node_path.join(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(node_path.join(projectPath, 'nuxt.config.js')) || exists(node_path.join(projectPath, 'nuxt.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
+    }
+    if (exists(node_path.join(projectPath, '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(node_path.join(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(node_path.join(projectPath, 'svelte.config.js'))) {
+        confidence += 20;
+        sources.push({ type: 'config-file', path: 'svelte.config.js' });
+    }
+    const hasSvelteFiles = exists(node_path.join(projectPath, 'src', 'App.svelte')) || exists(node_path.join(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(node_path.join(projectPath, 'svelte.config.js'))) {
+        confidence += 20;
+        sources.push({ type: 'config-file', path: 'svelte.config.js' });
+    }
+    if (exists(node_path.join(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(node_path.join(projectPath, 'qwik.config.ts')) || exists(node_path.join(projectPath, 'qwik.config.js'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'qwik.config.*' });
+    }
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        id: 'qwik',
+        name: 'Qwik',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
+}
+
+/**
+ * Detect Astro in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
+ */
+function astroDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
+    if (deps['astro']) {
+        confidence += 70;
+        version = parseVersionString(deps['astro']);
+        sources.push({ type: 'package.json', field: 'dependencies.astro' });
+    }
+    if (exists(node_path.join(projectPath, 'astro.config.mjs')) ||
+        exists(node_path.join(projectPath, 'astro.config.ts')) ||
+        exists(node_path.join(projectPath, 'astro.config.js'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'astro.config.*' });
+    }
+    if (exists(node_path.join(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 all frontend frameworks in project.
+ *
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Array of detected frameworks, sorted by confidence
+ */
+function detectFrontendFrameworks(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const results = [];
+    for (const detector of frameworkDetectors) {
+        const detection = detector.detect(projectPath, pkg ?? undefined);
+        if (detection) {
+            results.push(detection);
+        }
+    }
+    return results.sort((a, b) => b.confidence - a.confidence);
+}
+
+exports.angularDetector = angularDetector;
+exports.astroDetector = astroDetector;
+exports.detectFrontendFrameworks = detectFrontendFrameworks;
+exports.frameworkDetectors = frameworkDetectors;
+exports.gatsbyDetector = gatsbyDetector;
+exports.nextjsDetector = nextjsDetector;
+exports.nuxtDetector = nuxtDetector;
+exports.qwikDetector = qwikDetector;
+exports.reactDetector = reactDetector;
+exports.remixDetector = remixDetector;
+exports.solidDetector = solidDetector;
+exports.svelteDetector = svelteDetector;
+exports.sveltekitDetector = sveltekitDetector;
+exports.vueDetector = vueDetector;
+//# sourceMappingURL=index.cjs.js.map