@hyperfrontend/project-scope 0.2.1 → 0.2.3

package/tech/frontend/index.esm.js

@@ -1,393 +1,16 @@
 import { join } from 'node:path';
+import { min } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.esm.js';
 import { existsSync, readFileSync } from '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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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);
+import { isArray } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { error, warn, log, info, debug } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/console/index.esm.js';
+import { stringify, parse } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.esm.js';
+import { freeze, entries, keys, values } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { createLogger } from '../../_dependencies/@hyperfrontend/logging/index.esm.js';
+import { createError } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+import { isSafePath } from '../../_shared/core/fs/guard/index.esm.js';
+import { exists } from '../../_shared/core/fs/stat/index.esm.js';
+import { collectAllDependencies, parseVersionString } from '../../_shared/tech/shared-utils/detector-helpers/index.esm.js';
 
 /**
  * Global log level registry.
@@ -427,6 +50,13 @@ function isSensitiveKey(key) {
  *
  * @param obj - Object to sanitize
  * @returns New object with sensitive values redacted
+ *
+ * @example Sanitizing sensitive data
+ * ```typescript
+ * const config = { apiKey: 'secret123', endpoint: 'https://api.example.com' }
+ * const safe = sanitize(config)
+ * // => { apiKey: '[REDACTED]', endpoint: 'https://api.example.com' }
+ * ```
  */
 function sanitize(obj) {
     if (obj === null || obj === undefined) {
@@ -477,7 +107,7 @@ function formatMessage(namespace, message, meta) {
  * @param options - Logger configuration options
  * @returns A configured scoped logger instance
  *
- * @example
+ * @example Creating a scoped logger
  * ```typescript
  * const logger = createScopedLogger('project-scope')
  * logger.setLogLevel('debug')
@@ -514,7 +144,7 @@ function createScopedLogger(namespace, options = {}) {
  * Default logger instance for the project-scope library.
  * Use this for general logging within the library.
  *
- * @example
+ * @example Using the default logger
  * ```typescript
  * import { logger } from '@hyperfrontend/project-scope/core'
  *
@@ -531,9 +161,17 @@ createScopedLogger('project-scope:fs');
  * @param filePath - Path to file
  * @param encoding - File encoding (default: utf-8)
  * @returns File contents or null if file doesn't exist
+ *
+ * @example Reading file if it exists
+ * ```typescript
+ * const content = readFileIfExists('./optional-config.json')
+ * if (content) {
+ *   // File existed, use content
+ * }
+ * ```
  */
 function readFileIfExists(filePath, encoding = 'utf-8') {
-    if (!existsSync(filePath)) {
+    if (!isSafePath(filePath) || !existsSync(filePath)) {
         return null;
     }
     try {
@@ -544,22 +182,12 @@ function readFileIfExists(filePath, encoding = 'utf-8') {
     }
 }
 
-createScopedLogger('project-scope:fs:write');
-
-/**
- * Check if path exists.
- *
- * @param filePath - Path to check
- * @returns True if path exists
- */
-function exists(filePath) {
-    return existsSync(filePath);
-}
-
 createScopedLogger('project-scope:fs:dir');
 
 createScopedLogger('project-scope:fs:traversal');
 
+createScopedLogger('project-scope:fs:write');
+
 const packageLogger = createScopedLogger('project-scope:project:package');
 /**
  * Verifies that a value is an object with only string values,
@@ -629,6 +257,16 @@ function validatePackageJson(data) {
  *
  * @param projectPath - Project directory path or path to package.json
  * @returns Parsed package.json or null if not found
+ *
+ * @example Reading package.json if it exists
+ * ```typescript
+ * import { readPackageJsonIfExists } from '@hyperfrontend/project-scope'
+ *
+ * const pkg = readPackageJsonIfExists('/path/to/project')
+ * if (pkg) {
+ *   console.log('Found:', pkg.name)
+ * }
+ * ```
  */
 function readPackageJsonIfExists(projectPath) {
     const packageJsonPath = projectPath.endsWith('package.json') ? projectPath : join(projectPath, 'package.json');
@@ -649,118 +287,187 @@ function readPackageJsonIfExists(projectPath) {
 }
 
 /**
- * Get combined dependencies from package.json.
- * Merges dependencies, devDependencies, peerDependencies, and optionalDependencies.
+ * Detect Angular in project.
  *
- * @param packageJson - The package.json object to extract dependencies from
- * @returns Combined dependencies as a single record
- */
-function collectAllDependencies(packageJson) {
-    return {
-        ...packageJson?.dependencies,
-        ...packageJson?.devDependencies,
-        ...packageJson?.peerDependencies,
-        ...packageJson?.optionalDependencies,
-    };
-}
-/**
- * Extract clean version from dependency version string.
- * Removes semver prefixes like ^, ~, >=, etc.
- * Uses character-by-character parsing to avoid ReDoS vulnerabilities.
+ * @param projectPath - Project directory path
+ * @param packageJson - Optional pre-loaded package.json
+ * @returns Detection result or null if not detected
  *
- * @param versionString - The version string with optional prefix characters
- * @returns The cleaned version string without prefix characters
+ * @example Detecting Angular framework
+ * ```typescript
+ * const result = angularDetector('/path/to/angular-app', {
+ *   dependencies: { '@angular/core': '^17.0.0', '@angular/cli': '^17.0.0' }
+ * })
+ * // => {
+ * //   id: 'angular',
+ * //   name: 'Angular',
+ * //   category: 'frontend',
+ * //   version: '17.0.0',
+ * //   confidence: 85,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@angular/core' },
+ * //     { type: 'package.json', field: 'dependencies.@angular/cli' }
+ * //   ]
+ * // }
+ * ```
  */
-function parseVersionString(versionString) {
-    if (versionString === undefined || versionString === null)
-        return undefined;
-    let start = 0;
-    while (start < versionString.length) {
-        const char = versionString[start];
-        if (char !== '^' && char !== '~' && char !== '>' && char !== '=' && char !== '<') {
-            break;
-        }
-        start++;
+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(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 versionString.slice(start);
+    return {
+        id: 'angular',
+        name: 'Angular',
+        category: 'frontend',
+        version,
+        confidence: min(confidence, 100),
+        detectedFrom: sources,
+    };
 }
 
 /**
- * Detect React in project.
+ * Detect Astro in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Astro framework
+ * ```typescript
+ * const result = astroDetector('/path/to/astro-project', {
+ *   dependencies: { 'astro': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'astro',
+ * //   name: 'Astro',
+ * //   category: 'meta-framework',
+ * //   version: '4.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.astro' }]
+ * // }
+ * ```
  */
-function reactDetector(projectPath, packageJson) {
+function astroDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
-    const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    if (deps['react']) {
-        confidence += 60;
-        version = parseVersionString(deps['react']);
-        sources.push({ type: 'package.json', field: 'dependencies.react' });
+    if (deps['astro']) {
+        confidence += 70;
+        version = parseVersionString(deps['astro']);
+        sources.push({ type: 'package.json', field: 'dependencies.astro' });
     }
-    if (deps['react-dom']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.react-dom' });
+    if (exists(join(projectPath, 'astro.config.mjs')) ||
+        exists(join(projectPath, 'astro.config.ts')) ||
+        exists(join(projectPath, 'astro.config.js'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'astro.config.*' });
     }
-    if (deps['react-native']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.react-native' });
+    if (exists(join(projectPath, 'src', 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'src/pages/' });
     }
-    const hasJsxFiles = exists(join(projectPath, 'src', 'App.tsx')) ||
-        exists(join(projectPath, 'src', 'App.jsx')) ||
-        exists(join(projectPath, 'src', 'index.tsx')) ||
-        exists(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 (confidence === 0) {
+        return null;
     }
+    return {
+        id: 'astro',
+        name: 'Astro',
+        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
+ *
+ * @example Detecting Gatsby framework
+ * ```typescript
+ * const result = gatsbyDetector('/path/to/gatsby-blog', {
+ *   dependencies: {
+ *     'gatsby': '^5.0.0',
+ *     'gatsby-plugin-image': '^3.0.0',
+ *     'gatsby-source-filesystem': '^5.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'gatsby',
+ * //   name: 'Gatsby',
+ * //   category: 'meta-framework',
+ * //   version: '5.0.0',
+ * //   confidence: 75,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.gatsby' },
+ * //     { type: 'package.json', field: 'dependencies (gatsby plugins)' }
+ * //   ]
+ * // }
+ * ```
+ */
+function gatsbyDetector(projectPath, packageJson) {
+    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
+    const sources = [];
+    let confidence = 0;
+    let version;
+    const deps = collectAllDependencies(pkg);
     if (deps['gatsby']) {
-        metaFrameworks.push({
-            id: 'gatsby',
-            name: 'Gatsby',
-            category: 'meta-framework',
-            version: parseVersionString(deps['gatsby']),
-            confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.gatsby' }],
-        });
+        confidence += 70;
+        version = parseVersionString(deps['gatsby']);
+        sources.push({ type: 'package.json', field: 'dependencies.gatsby' });
     }
-    if (deps['@remix-run/react'] || deps['remix']) {
-        metaFrameworks.push({
-            id: 'remix',
-            name: 'Remix',
-            category: 'meta-framework',
-            version: parseVersionString(deps['@remix-run/react'] ?? deps['remix']),
-            confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.@remix-run/react' }],
-        });
+    if (exists(join(projectPath, 'gatsby-config.js')) || exists(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: 'react',
-        name: 'React',
-        category: 'frontend',
+        id: 'gatsby',
+        name: 'Gatsby',
+        category: 'meta-framework',
         version,
         confidence: min(confidence, 100),
         detectedFrom: sources,
-        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
 }
 
@@ -770,6 +477,21 @@ function reactDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Next.js framework
+ * ```typescript
+ * const result = nextjsDetector('/path/to/nextjs-app', {
+ *   dependencies: { 'next': '^14.0.0', 'react': '^18.0.0' }
+ * })
+ * // => {
+ * //   id: 'nextjs',
+ * //   name: 'Next.js',
+ * //   category: 'meta-framework',
+ * //   version: '14.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }]
+ * // }
+ * ```
  */
 function nextjsDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -809,37 +531,52 @@ function nextjsDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Remix in project.
+ * Detect Nuxt in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Nuxt framework
+ * ```typescript
+ * const result = nuxtDetector('/path/to/nuxt-app', {
+ *   dependencies: { 'nuxt': '^3.0.0', 'vue': '^3.0.0' }
+ * })
+ * // => {
+ * //   id: 'nuxt',
+ * //   name: 'Nuxt',
+ * //   category: 'meta-framework',
+ * //   version: '3.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }]
+ * // }
+ * ```
  */
-function remixDetector(projectPath, packageJson) {
+function nuxtDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@remix-run/react']) {
+    if (deps['nuxt'] || deps['nuxt3']) {
         confidence += 70;
-        version = parseVersionString(deps['@remix-run/react']);
-        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/react' });
+        version = parseVersionString(deps['nuxt'] ?? deps['nuxt3']);
+        sources.push({ type: 'package.json', field: 'dependencies.nuxt' });
     }
-    if (deps['@remix-run/node'] || deps['@remix-run/cloudflare'] || deps['@remix-run/deno']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/*' });
+    if (exists(join(projectPath, 'nuxt.config.js')) || exists(join(projectPath, 'nuxt.config.ts'))) {
+        confidence += 25;
+        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
     }
-    if (exists(join(projectPath, 'remix.config.js')) || exists(join(projectPath, 'remix.config.ts'))) {
-        confidence += 10;
-        sources.push({ type: 'config-file', path: 'remix.config.*' });
+    if (exists(join(projectPath, 'pages'))) {
+        confidence += 5;
+        sources.push({ type: 'directory', path: 'pages/' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'remix',
-        name: 'Remix',
+        id: 'nuxt',
+        name: 'Nuxt',
         category: 'meta-framework',
         version,
         confidence: min(confidence, 100),
@@ -848,39 +585,59 @@ function remixDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Gatsby in project.
+ * Detect Qwik in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Qwik framework
+ * ```typescript
+ * const result = qwikDetector('/path/to/qwik-app', {
+ *   dependencies: {
+ *     '@builder.io/qwik': '^1.0.0',
+ *     '@builder.io/qwik-city': '^1.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'qwik',
+ * //   name: 'Qwik',
+ * //   category: 'frontend',
+ * //   version: '1.0.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@builder.io/qwik' },
+ * //     { type: 'package.json', field: 'dependencies.@builder.io/qwik-city' }
+ * //   ]
+ * // }
+ * ```
  */
-function gatsbyDetector(projectPath, packageJson) {
+function qwikDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['gatsby']) {
+    if (deps['@builder.io/qwik']) {
         confidence += 70;
-        version = parseVersionString(deps['gatsby']);
-        sources.push({ type: 'package.json', field: 'dependencies.gatsby' });
+        version = parseVersionString(deps['@builder.io/qwik']);
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik' });
     }
-    if (exists(join(projectPath, 'gatsby-config.js')) || exists(join(projectPath, 'gatsby-config.ts'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'gatsby-config.*' });
+    if (deps['@builder.io/qwik-city']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik-city' });
     }
-    const gatsbyPlugins = keys(deps).filter((d) => d.startsWith('gatsby-plugin-') || d.startsWith('gatsby-source-'));
-    if (gatsbyPlugins.length > 0) {
-        confidence += 5;
-        sources.push({ type: 'package.json', field: 'dependencies (gatsby plugins)' });
+    if (exists(join(projectPath, 'qwik.config.ts')) || exists(join(projectPath, 'qwik.config.js'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'qwik.config.*' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'gatsby',
-        name: 'Gatsby',
-        category: 'meta-framework',
+        id: 'qwik',
+        name: 'Qwik',
+        category: 'frontend',
         version,
         confidence: min(confidence, 100),
         detectedFrom: sources,
@@ -888,53 +645,94 @@ function gatsbyDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Vue in project.
+ * Detect React in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting React library
+ * ```typescript
+ * const result = reactDetector('/path/to/react-app', {
+ *   dependencies: { 'react': '^18.0.0', 'react-dom': '^18.0.0' }
+ * })
+ * // => {
+ * //   id: 'react',
+ * //   name: 'React',
+ * //   category: 'frontend',
+ * //   version: '18.0.0',
+ * //   confidence: 80,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.react' },
+ * //     { type: 'package.json', field: 'dependencies.react-dom' }
+ * //   ]
+ * // }
+ * ```
  */
-function vueDetector(projectPath, packageJson) {
+function reactDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    if (deps['vue']) {
-        confidence += 70;
-        version = parseVersionString(deps['vue']);
-        sources.push({ type: 'package.json', field: 'dependencies.vue' });
+    if (deps['react']) {
+        confidence += 60;
+        version = parseVersionString(deps['react']);
+        sources.push({ type: 'package.json', field: 'dependencies.react' });
     }
-    if (deps['@vue/cli-service']) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies.@vue/cli-service' });
+    if (deps['react-dom']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.react-dom' });
     }
-    const hasVueFiles = exists(join(projectPath, 'src', 'App.vue')) || exists(join(projectPath, 'src', 'main.vue'));
-    if (hasVueFiles) {
+    if (deps['react-native']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.react-native' });
+    }
+    const hasJsxFiles = exists(join(projectPath, 'src', 'App.tsx')) ||
+        exists(join(projectPath, 'src', 'App.jsx')) ||
+        exists(join(projectPath, 'src', 'index.tsx')) ||
+        exists(join(projectPath, 'src', 'index.jsx'));
+    if (hasJsxFiles) {
         confidence += 10;
-        sources.push({ type: 'directory', path: 'src/*.vue' });
+        sources.push({ type: 'directory', path: 'src/*.tsx or src/*.jsx' });
     }
-    if (exists(join(projectPath, 'vue.config.js'))) {
-        confidence += 5;
-        sources.push({ type: 'config-file', path: 'vue.config.js' });
+    if (deps['next']) {
+        metaFrameworks.push({
+            id: 'nextjs',
+            name: 'Next.js',
+            category: 'meta-framework',
+            version: parseVersionString(deps['next']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.next' }],
+        });
     }
-    if (deps['nuxt'] || deps['nuxt3']) {
+    if (deps['gatsby']) {
         metaFrameworks.push({
-            id: 'nuxt',
-            name: 'Nuxt',
+            id: 'gatsby',
+            name: 'Gatsby',
             category: 'meta-framework',
-            version: parseVersionString(deps['nuxt'] ?? deps['nuxt3']),
+            version: parseVersionString(deps['gatsby']),
             confidence: 90,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }],
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.gatsby' }],
+        });
+    }
+    if (deps['@remix-run/react'] || deps['remix']) {
+        metaFrameworks.push({
+            id: 'remix',
+            name: 'Remix',
+            category: 'meta-framework',
+            version: parseVersionString(deps['@remix-run/react'] ?? deps['remix']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.@remix-run/react' }],
         });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'vue',
-        name: 'Vue',
+        id: 'react',
+        name: 'React',
         category: 'frontend',
         version,
         confidence: min(confidence, 100),
@@ -944,37 +742,58 @@ function vueDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Nuxt in project.
+ * Detect Remix in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Remix framework
+ * ```typescript
+ * const result = remixDetector('/path/to/remix-app', {
+ *   dependencies: {
+ *     '@remix-run/react': '^2.0.0',
+ *     '@remix-run/node': '^2.0.0'
+ *   }
+ * })
+ * // => {
+ * //   id: 'remix',
+ * //   name: 'Remix',
+ * //   category: 'meta-framework',
+ * //   version: '2.0.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.@remix-run/react' },
+ * //     { type: 'package.json', field: 'dependencies.@remix-run/*' }
+ * //   ]
+ * // }
+ * ```
  */
-function nuxtDetector(projectPath, packageJson) {
+function remixDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['nuxt'] || deps['nuxt3']) {
+    if (deps['@remix-run/react']) {
         confidence += 70;
-        version = parseVersionString(deps['nuxt'] ?? deps['nuxt3']);
-        sources.push({ type: 'package.json', field: 'dependencies.nuxt' });
+        version = parseVersionString(deps['@remix-run/react']);
+        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/react' });
     }
-    if (exists(join(projectPath, 'nuxt.config.js')) || exists(join(projectPath, 'nuxt.config.ts'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'nuxt.config.*' });
+    if (deps['@remix-run/node'] || deps['@remix-run/cloudflare'] || deps['@remix-run/deno']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.@remix-run/*' });
     }
-    if (exists(join(projectPath, 'pages'))) {
-        confidence += 5;
-        sources.push({ type: 'directory', path: 'pages/' });
+    if (exists(join(projectPath, 'remix.config.js')) || exists(join(projectPath, 'remix.config.ts'))) {
+        confidence += 10;
+        sources.push({ type: 'config-file', path: 'remix.config.*' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'nuxt',
-        name: 'Nuxt',
+        id: 'remix',
+        name: 'Remix',
         category: 'meta-framework',
         version,
         confidence: min(confidence, 100),
@@ -983,47 +802,55 @@ function nuxtDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Angular in project.
+ * Detect Solid in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Solid.js framework
+ * ```typescript
+ * const result = solidDetector('/path/to/solid-app', {
+ *   dependencies: { 'solid-js': '^1.8.0', 'vite-plugin-solid': '^2.0.0' }
+ * })
+ * // => {
+ * //   id: 'solid',
+ * //   name: 'Solid',
+ * //   category: 'frontend',
+ * //   version: '1.8.0',
+ * //   confidence: 90,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.solid-js' },
+ * //     { type: 'package.json', field: 'dependencies.vite-plugin-solid' }
+ * //   ]
+ * // }
+ * ```
  */
-function angularDetector(projectPath, packageJson) {
+function solidDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
     const deps = collectAllDependencies(pkg);
-    if (deps['@angular/core']) {
+    if (deps['solid-js']) {
         confidence += 70;
-        version = parseVersionString(deps['@angular/core']);
-        sources.push({ type: 'package.json', field: 'dependencies.@angular/core' });
-    }
-    if (deps['@angular/cli']) {
-        confidence += 15;
-        sources.push({ type: 'package.json', field: 'dependencies.@angular/cli' });
+        version = parseVersionString(deps['solid-js']);
+        sources.push({ type: 'package.json', field: 'dependencies.solid-js' });
     }
-    if (exists(join(projectPath, 'angular.json'))) {
-        confidence += 15;
-        sources.push({ type: 'config-file', path: 'angular.json' });
+    if (deps['vite-plugin-solid']) {
+        confidence += 20;
+        sources.push({ type: 'package.json', field: 'dependencies.vite-plugin-solid' });
     }
-    if (deps['angular'] && !deps['@angular/core']) {
-        return {
-            id: 'angularjs',
-            name: 'AngularJS (Legacy)',
-            category: 'frontend',
-            version: parseVersionString(deps['angular']),
-            confidence: 80,
-            detectedFrom: [{ type: 'package.json', field: 'dependencies.angular' }],
-        };
+    if (deps['solid-start'] || deps['@solidjs/start']) {
+        confidence += 10;
+        sources.push({ type: 'package.json', field: 'dependencies.solid-start' });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'angular',
-        name: 'Angular',
+        id: 'solid',
+        name: 'Solid',
         category: 'frontend',
         version,
         confidence: min(confidence, 100),
@@ -1037,6 +864,21 @@ function angularDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting Svelte framework
+ * ```typescript
+ * const result = svelteDetector('/path/to/svelte-app', {
+ *   devDependencies: { 'svelte': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'svelte',
+ * //   name: 'Svelte',
+ * //   category: 'frontend',
+ * //   version: '4.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.svelte' }]
+ * // }
+ * ```
  */
 function svelteDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1089,6 +931,21 @@ function svelteDetector(projectPath, packageJson) {
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
+ *
+ * @example Detecting SvelteKit framework
+ * ```typescript
+ * const result = sveltekitDetector('/path/to/sveltekit-app', {
+ *   devDependencies: { '@sveltejs/kit': '^2.0.0', 'svelte': '^4.0.0' }
+ * })
+ * // => {
+ * //   id: 'sveltekit',
+ * //   name: 'SvelteKit',
+ * //   category: 'meta-framework',
+ * //   version: '2.0.0',
+ * //   confidence: 70,
+ * //   detectedFrom: [{ type: 'package.json', field: 'dependencies.@sveltejs/kit' }]
+ * // }
+ * ```
  */
 function sveltekitDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1123,121 +980,76 @@ function sveltekitDetector(projectPath, packageJson) {
 }
 
 /**
- * Detect Solid in project.
+ * Detect Vue in project.
  *
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Detection result or null if not detected
- */
-function solidDetector(projectPath, packageJson) {
-    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
-    const sources = [];
-    let confidence = 0;
-    let version;
-    const deps = collectAllDependencies(pkg);
-    if (deps['solid-js']) {
-        confidence += 70;
-        version = parseVersionString(deps['solid-js']);
-        sources.push({ type: 'package.json', field: 'dependencies.solid-js' });
-    }
-    if (deps['vite-plugin-solid']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.vite-plugin-solid' });
-    }
-    if (deps['solid-start'] || deps['@solidjs/start']) {
-        confidence += 10;
-        sources.push({ type: 'package.json', field: 'dependencies.solid-start' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'solid',
-        name: 'Solid',
-        category: 'frontend',
-        version,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect Qwik in project.
  *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
+ * @example Detecting Vue.js framework
+ * ```typescript
+ * const result = vueDetector('/path/to/vue-app', {
+ *   dependencies: { 'vue': '^3.0.0', '@vue/cli-service': '^5.0.0' }
+ * })
+ * // => {
+ * //   id: 'vue',
+ * //   name: 'Vue',
+ * //   category: 'frontend',
+ * //   version: '3.0.0',
+ * //   confidence: 85,
+ * //   detectedFrom: [
+ * //     { type: 'package.json', field: 'dependencies.vue' },
+ * //     { type: 'package.json', field: 'dependencies.@vue/cli-service' }
+ * //   ]
+ * // }
+ * ```
  */
-function qwikDetector(projectPath, packageJson) {
+function vueDetector(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
     const sources = [];
     let confidence = 0;
     let version;
+    const metaFrameworks = [];
     const deps = collectAllDependencies(pkg);
-    if (deps['@builder.io/qwik']) {
+    if (deps['vue']) {
         confidence += 70;
-        version = parseVersionString(deps['@builder.io/qwik']);
-        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik' });
+        version = parseVersionString(deps['vue']);
+        sources.push({ type: 'package.json', field: 'dependencies.vue' });
     }
-    if (deps['@builder.io/qwik-city']) {
-        confidence += 20;
-        sources.push({ type: 'package.json', field: 'dependencies.@builder.io/qwik-city' });
+    if (deps['@vue/cli-service']) {
+        confidence += 15;
+        sources.push({ type: 'package.json', field: 'dependencies.@vue/cli-service' });
     }
-    if (exists(join(projectPath, 'qwik.config.ts')) || exists(join(projectPath, 'qwik.config.js'))) {
+    const hasVueFiles = exists(join(projectPath, 'src', 'App.vue')) || exists(join(projectPath, 'src', 'main.vue'));
+    if (hasVueFiles) {
         confidence += 10;
-        sources.push({ type: 'config-file', path: 'qwik.config.*' });
-    }
-    if (confidence === 0) {
-        return null;
-    }
-    return {
-        id: 'qwik',
-        name: 'Qwik',
-        category: 'frontend',
-        version,
-        confidence: min(confidence, 100),
-        detectedFrom: sources,
-    };
-}
-
-/**
- * Detect Astro in project.
- *
- * @param projectPath - Project directory path
- * @param packageJson - Optional pre-loaded package.json
- * @returns Detection result or null if not detected
- */
-function astroDetector(projectPath, packageJson) {
-    const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
-    const sources = [];
-    let confidence = 0;
-    let version;
-    const deps = collectAllDependencies(pkg);
-    if (deps['astro']) {
-        confidence += 70;
-        version = parseVersionString(deps['astro']);
-        sources.push({ type: 'package.json', field: 'dependencies.astro' });
-    }
-    if (exists(join(projectPath, 'astro.config.mjs')) ||
-        exists(join(projectPath, 'astro.config.ts')) ||
-        exists(join(projectPath, 'astro.config.js'))) {
-        confidence += 25;
-        sources.push({ type: 'config-file', path: 'astro.config.*' });
+        sources.push({ type: 'directory', path: 'src/*.vue' });
     }
-    if (exists(join(projectPath, 'src', 'pages'))) {
+    if (exists(join(projectPath, 'vue.config.js'))) {
         confidence += 5;
-        sources.push({ type: 'directory', path: 'src/pages/' });
+        sources.push({ type: 'config-file', path: 'vue.config.js' });
+    }
+    if (deps['nuxt'] || deps['nuxt3']) {
+        metaFrameworks.push({
+            id: 'nuxt',
+            name: 'Nuxt',
+            category: 'meta-framework',
+            version: parseVersionString(deps['nuxt'] ?? deps['nuxt3']),
+            confidence: 90,
+            detectedFrom: [{ type: 'package.json', field: 'dependencies.nuxt' }],
+        });
     }
     if (confidence === 0) {
         return null;
     }
     return {
-        id: 'astro',
-        name: 'Astro',
-        category: 'meta-framework',
+        id: 'vue',
+        name: 'Vue',
+        category: 'frontend',
         version,
         confidence: min(confidence, 100),
         detectedFrom: sources,
+        metaFrameworks: metaFrameworks.length > 0 ? metaFrameworks : undefined,
     };
 }
 
@@ -1262,6 +1074,17 @@ const frameworkDetectors = [
  * @param projectPath - Project directory path
  * @param packageJson - Optional pre-loaded package.json
  * @returns Array of detected frameworks, sorted by confidence
+ *
+ * @example Detecting multiple frontend frameworks
+ * ```typescript
+ * const frameworks = detectFrontendFrameworks('/path/to/nextjs-app', {
+ *   dependencies: { 'react': '^18.0.0', 'next': '^14.0.0' }
+ * })
+ * // => [
+ * //   { id: 'nextjs', name: 'Next.js', category: 'meta-framework', confidence: 70, ... },
+ * //   { id: 'react', name: 'React', category: 'frontend', confidence: 60, ... }
+ * // ]
+ * ```
  */
 function detectFrontendFrameworks(projectPath, packageJson) {
     const pkg = packageJson ?? readPackageJsonIfExists(projectPath);
@@ -1276,4 +1099,3 @@ function detectFrontendFrameworks(projectPath, packageJson) {
 }
 
 export { angularDetector, astroDetector, detectFrontendFrameworks, frameworkDetectors, gatsbyDetector, nextjsDetector, nuxtDetector, qwikDetector, reactDetector, remixDetector, solidDetector, svelteDetector, sveltekitDetector, vueDetector };
-//# sourceMappingURL=index.esm.js.map