@opencodereview/core 1.9.1

package/dist/languages/registry.js

@@ -0,0 +1,150 @@
+/**
+ * Language Registry
+ *
+ * Manages registered LanguageAdapters and auto-selects the appropriate
+ * adapter based on file extension.
+ *
+ * @since 0.3.0
+ */
+/**
+ * LanguageRegistry — singleton that maps file extensions to language adapters.
+ *
+ * Usage:
+ *   const registry = LanguageRegistry.getInstance();
+ *   registry.register(new TypeScriptAdapter());
+ *   const adapter = registry.getByExtension('.ts');
+ */
+export class LanguageRegistry {
+    static instance = null;
+    /** Adapter map by language ID */
+    adapters = new Map();
+    /** Extension → language ID lookup */
+    extensionMap = new Map();
+    constructor() { }
+    /** Get the singleton instance */
+    static getInstance() {
+        if (!LanguageRegistry.instance) {
+            LanguageRegistry.instance = new LanguageRegistry();
+        }
+        return LanguageRegistry.instance;
+    }
+    /**
+     * Reset the singleton (for testing).
+     */
+    static resetInstance() {
+        LanguageRegistry.instance = null;
+    }
+    /**
+     * Register a language adapter.
+     * @param adapter The language adapter to register
+     * @throws If an adapter with the same ID is already registered
+     */
+    register(adapter) {
+        if (this.adapters.has(adapter.id)) {
+            throw new Error(`Language adapter '${adapter.id}' is already registered`);
+        }
+        this.adapters.set(adapter.id, adapter);
+        for (const ext of adapter.extensions) {
+            this.extensionMap.set(ext.toLowerCase(), adapter.id);
+        }
+    }
+    /**
+     * Unregister a language adapter by ID.
+     * @param id Language identifier
+     */
+    unregister(id) {
+        const adapter = this.adapters.get(id);
+        if (adapter) {
+            for (const ext of adapter.extensions) {
+                this.extensionMap.delete(ext.toLowerCase());
+            }
+            this.adapters.delete(id);
+        }
+    }
+    /**
+     * Get a language adapter by language ID.
+     * @param id Language identifier (e.g. 'typescript')
+     * @returns The adapter, or undefined if not registered
+     */
+    getById(id) {
+        return this.adapters.get(id);
+    }
+    /**
+     * Get a language adapter by file extension.
+     * @param ext File extension including dot (e.g. '.ts')
+     * @returns The adapter, or undefined if no adapter matches
+     */
+    getByExtension(ext) {
+        const langId = this.extensionMap.get(ext.toLowerCase());
+        if (langId) {
+            return this.adapters.get(langId);
+        }
+        return undefined;
+    }
+    /**
+     * Get a language adapter for a file path.
+     * Extracts the extension and looks up the adapter.
+     * @param filePath File path
+     * @returns The adapter, or undefined if no adapter matches
+     */
+    getByFilePath(filePath) {
+        const ext = extractExtension(filePath);
+        if (ext) {
+            return this.getByExtension(ext);
+        }
+        return undefined;
+    }
+    /**
+     * Detect the language for a file path.
+     * @param filePath File path
+     * @returns The language identifier, or undefined
+     */
+    detectLanguage(filePath) {
+        const ext = extractExtension(filePath);
+        if (ext) {
+            const langId = this.extensionMap.get(ext.toLowerCase());
+            return langId;
+        }
+        return undefined;
+    }
+    /**
+     * Get all registered language IDs.
+     */
+    getRegisteredLanguages() {
+        return Array.from(this.adapters.keys());
+    }
+    /**
+     * Get all supported extensions.
+     */
+    getSupportedExtensions() {
+        return Array.from(this.extensionMap.keys());
+    }
+    /**
+     * Check if a file extension is supported.
+     */
+    isSupported(extOrPath) {
+        if (extOrPath.startsWith('.')) {
+            return this.extensionMap.has(extOrPath.toLowerCase());
+        }
+        const ext = extractExtension(extOrPath);
+        return ext ? this.extensionMap.has(ext.toLowerCase()) : false;
+    }
+}
+/**
+ * Extract file extension from a path (including the dot).
+ * Handles compound extensions like .d.ts, .test.ts etc.
+ */
+function extractExtension(filePath) {
+    const basename = filePath.split(/[/\\]/).pop();
+    if (!basename)
+        return undefined;
+    // Handle .d.ts, .d.mts, .d.cts
+    if (/\.d\.[mc]?ts$/.test(basename)) {
+        return basename.match(/\.d\.[mc]?ts$/)?.[0];
+    }
+    const dotIndex = basename.lastIndexOf('.');
+    if (dotIndex === -1 || dotIndex === 0)
+        return undefined;
+    return basename.slice(dotIndex);
+}
+//# sourceMappingURL=registry.js.map

package/dist/languages/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/languages/registry.ts"],"names":[],"mappings":"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"}

package/dist/languages/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Language Adapter Types
+ *
+ * Defines the unified LanguageAdapter interface that all language-specific
+ * adapters must implement. This enables language-agnostic detection.
+ *
+ * @since 0.3.0
+ */
+import type { SupportedLanguage } from '../types.js';
+/**
+ * Abstract AST node — language adapters produce their own AST structures,
+ * but they all go through this common interface for traversal.
+ */
+export interface ASTNode {
+    type: string;
+    [key: string]: unknown;
+}
+/** Extracted import/require statement */
+export interface ImportInfo {
+    /** The module specifier (e.g. 'lodash', './utils', 'node:fs') */
+    module: string;
+    /** Individual imported bindings (e.g. ['readFile', 'writeFile']) */
+    bindings: string[];
+    /** Line number where the import appears */
+    line: number;
+    /** Whether this is a relative import (./foo, ../bar) */
+    isRelative: boolean;
+    /** Whether this is a built-in module */
+    isBuiltin: boolean;
+}
+/** Extracted function/method call */
+export interface CallInfo {
+    /** The fully qualified call name (e.g. 'fs.readFile', 'console.log') */
+    name: string;
+    /** Line number */
+    line: number;
+    /** Column number */
+    column?: number;
+    /** Whether this is a method call (obj.method()) */
+    isMethodCall: boolean;
+}
+/** Result of package existence verification */
+export interface PackageVerifyResult {
+    /** Package name */
+    name: string;
+    /** Whether the package exists in the registry */
+    exists: boolean;
+    /** If deprecated, the deprecation message */
+    deprecation?: string;
+    /** When the check was performed */
+    checkedAt: number;
+}
+/** Information about a deprecated API */
+export interface DeprecatedInfo {
+    /** The deprecated API name/pattern */
+    api: string;
+    /** Why it was deprecated */
+    reason: string;
+    /** What to use instead */
+    replacement?: string;
+    /** Since which version it was deprecated */
+    since?: string;
+    /** Reference URL */
+    reference?: string;
+}
+/** Complexity metrics for a code unit (function/file) */
+export interface ComplexityMetrics {
+    /** Cyclomatic complexity */
+    cyclomatic: number;
+    /** Cognitive complexity */
+    cognitive: number;
+    /** Lines of code */
+    loc: number;
+    /** Number of functions */
+    functionCount: number;
+    /** Maximum nesting depth */
+    maxNestingDepth: number;
+}
+/**
+ * LanguageAdapter — unified interface for multi-language support.
+ *
+ * Each supported language implements this interface to provide:
+ * - AST parsing
+ * - Import/call extraction
+ * - Package verification
+ * - Deprecated API checking
+ * - Complexity computation
+ *
+ * Detectors use LanguageAdapter to remain language-agnostic.
+ */
+export interface LanguageAdapter {
+    /** Language identifier (e.g. 'typescript', 'python') */
+    readonly id: SupportedLanguage;
+    /** Supported file extensions (e.g. ['.ts', '.tsx', '.js', '.jsx']) */
+    readonly extensions: string[];
+    /**
+     * Parse source code into an AST.
+     * @param source File content
+     * @param filePath File path (for error reporting)
+     * @returns Parsed AST
+     */
+    parse(source: string, filePath: string): Promise<ASTNode>;
+    /**
+     * Extract import/require statements from parsed AST or source.
+     * @param source File content
+     * @param ast Parsed AST (optional, for performance)
+     * @returns Array of import information
+     */
+    extractImports(source: string, ast?: ASTNode): ImportInfo[];
+    /**
+     * Extract function/method calls from parsed AST or source.
+     * @param source File content
+     * @param ast Parsed AST (optional, for performance)
+     * @returns Array of call information
+     */
+    extractCalls(source: string, ast?: ASTNode): CallInfo[];
+    /**
+     * Verify if a package exists in the language's package registry.
+     * @param name Package name
+     * @returns Verification result
+     */
+    verifyPackage(name: string): Promise<PackageVerifyResult>;
+    /**
+     * Check if an API is deprecated.
+     * @param api The API name/call
+     * @returns Deprecation info, or null if not deprecated
+     */
+    checkDeprecated(api: string): DeprecatedInfo | null;
+    /**
+     * Compute complexity metrics for a source file.
+     * @param source File content
+     * @param ast Parsed AST (optional)
+     * @returns Complexity metrics
+     */
+    computeComplexity(source: string, ast?: ASTNode): ComplexityMetrics;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/languages/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/languages/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAID,yCAAyC;AACzC,MAAM,WAAW,UAAU;IACzB,iEAAiE;IACjE,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB,wCAAwC;IACxC,SAAS,EAAE,OAAO,CAAC;CACpB;AAID,qCAAqC;AACrC,MAAM,WAAW,QAAQ;IACvB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;CACvB;AAID,+CAA+C;AAC/C,MAAM,WAAW,mBAAmB;IAClC,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;CACnB;AAID,yCAAyC;AACzC,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oBAAoB;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAID,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IAChC,4BAA4B;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,0BAA0B;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,4BAA4B;IAC5B,eAAe,EAAE,MAAM,CAAC;CACzB;AAID;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAC;IAE/B,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAC;IAE9B;;;;;OAKG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE1D;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE,CAAC;IAE5D;;;;;OAKG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,QAAQ,EAAE,CAAC;IAExD;;;;OAIG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAE1D;;;;OAIG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;IAEpD;;;;;OAKG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,iBAAiB,CAAC;CACrE"}

package/dist/languages/types.js

@@ -0,0 +1,10 @@
+/**
+ * Language Adapter Types
+ *
+ * Defines the unified LanguageAdapter interface that all language-specific
+ * adapters must implement. This enables language-agnostic detection.
+ *
+ * @since 0.3.0
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/languages/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/languages/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/languages/typescript/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TypeScript/JavaScript Language Adapter — Exports
+ *
+ * @since 0.3.0
+ */
+export { TypeScriptAdapter } from './parser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/languages/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/languages/typescript/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/languages/typescript/index.js

@@ -0,0 +1,7 @@
+/**
+ * TypeScript/JavaScript Language Adapter — Exports
+ *
+ * @since 0.3.0
+ */
+export { TypeScriptAdapter } from './parser.js';
+//# sourceMappingURL=index.js.map

package/dist/languages/typescript/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/languages/typescript/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/languages/typescript/parser.d.ts

@@ -0,0 +1,51 @@
+/**
+ * TypeScript / JavaScript Language Adapter
+ *
+ * Uses oxc-parser for fast AST parsing (Tier 1).
+ * Provides import/call extraction, complexity metrics, and built-in module detection.
+ *
+ * @since 0.3.0
+ */
+import type { SupportedLanguage } from '../../types.js';
+import type { LanguageAdapter, ASTNode, ImportInfo, CallInfo, PackageVerifyResult, DeprecatedInfo, ComplexityMetrics } from '../types.js';
+/**
+ * TypeScriptAdapter — LanguageAdapter implementation for TypeScript and JavaScript.
+ *
+ * Covers: .ts, .tsx, .js, .jsx, .mts, .cts, .mjs, .cjs
+ */
+export declare class TypeScriptAdapter implements LanguageAdapter {
+    readonly id: SupportedLanguage;
+    readonly extensions: string[];
+    /**
+     * Parse source code using oxc-parser.
+     */
+    parse(source: string, filePath: string): Promise<ASTNode>;
+    /**
+     * Extract import/require statements using regex (fast, works without AST).
+     * This is a robust regex-based approach that matches the existing detector logic.
+     */
+    extractImports(source: string, _ast?: ASTNode): ImportInfo[];
+    /**
+     * Extract function/method calls using regex.
+     * This is a lightweight extraction — AST-based extraction can be added later.
+     */
+    extractCalls(source: string, _ast?: ASTNode): CallInfo[];
+    /**
+     * Verify if an npm package exists.
+     * Uses HEAD request to registry.npmjs.org.
+     * Note: This is a placeholder — actual HTTP verification will be done
+     * in DeepHallucinationDetector (Phase 2).
+     */
+    verifyPackage(name: string): Promise<PackageVerifyResult>;
+    /**
+     * Check if an API is deprecated.
+     * Placeholder — real deprecated-apis.json will be added in Phase 2 (StaleAPIDetector).
+     */
+    checkDeprecated(_api: string): DeprecatedInfo | null;
+    /**
+     * Compute complexity metrics for a TypeScript/JavaScript file.
+     * Uses simple heuristic counting — AST-based metrics in Phase 2.
+     */
+    computeComplexity(source: string, _ast?: ASTNode): ComplexityMetrics;
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/languages/typescript/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/languages/typescript/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EACV,eAAe,EACf,OAAO,EACP,UAAU,EACV,QAAQ,EACR,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAkCrB;;;;GAIG;AACH,qBAAa,iBAAkB,YAAW,eAAe;IACvD,QAAQ,CAAC,EAAE,EAAE,iBAAiB,CAAgB;IAC9C,QAAQ,CAAC,UAAU,WAAkE;IAErF;;OAEG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAU/D;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,UAAU,EAAE;IAwH5D;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,EAAE;IAiDxD;;;;;OAKG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAU/D;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIpD;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,iBAAiB;CAmDrE"}

package/dist/languages/typescript/parser.js

@@ -0,0 +1,286 @@
+/**
+ * TypeScript / JavaScript Language Adapter
+ *
+ * Uses oxc-parser for fast AST parsing (Tier 1).
+ * Provides import/call extraction, complexity metrics, and built-in module detection.
+ *
+ * @since 0.3.0
+ */
+// ─── Node.js Built-in Modules ───
+const NODE_BUILTINS = new Set([
+    'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console',
+    'constants', 'crypto', 'dgram', 'diagnostics_channel', 'dns', 'domain',
+    'events', 'fs', 'http', 'http2', 'https', 'inspector', 'module', 'net',
+    'os', 'path', 'perf_hooks', 'process', 'punycode', 'querystring',
+    'readline', 'repl', 'stream', 'string_decoder', 'test', 'timers',
+    'tls', 'trace_events', 'tty', 'url', 'util', 'v8', 'vm',
+    'wasi', 'worker_threads', 'zlib',
+    // Subpath imports
+    'fs/promises', 'stream/promises', 'timers/promises',
+    'dns/promises', 'readline/promises',
+]);
+/**
+ * Check if a module specifier refers to a Node.js built-in.
+ */
+function isNodeBuiltin(specifier) {
+    if (specifier.startsWith('node:')) {
+        return true;
+    }
+    return NODE_BUILTINS.has(specifier);
+}
+/**
+ * Check if an import specifier is a relative path.
+ */
+function isRelativeImport(specifier) {
+    return specifier.startsWith('.') || specifier.startsWith('/');
+}
+/**
+ * TypeScriptAdapter — LanguageAdapter implementation for TypeScript and JavaScript.
+ *
+ * Covers: .ts, .tsx, .js, .jsx, .mts, .cts, .mjs, .cjs
+ */
+export class TypeScriptAdapter {
+    id = 'typescript';
+    extensions = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'];
+    /**
+     * Parse source code using oxc-parser.
+     */
+    async parse(source, filePath) {
+        const { parseSync } = await import('oxc-parser');
+        const result = parseSync(filePath, source);
+        if (result.errors && result.errors.length > 0) {
+            // Non-fatal: return program even with parse errors
+            // Detectors can check for errors separately
+        }
+        return result.program;
+    }
+    /**
+     * Extract import/require statements using regex (fast, works without AST).
+     * This is a robust regex-based approach that matches the existing detector logic.
+     */
+    extractImports(source, _ast) {
+        const imports = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // ES import: import { a, b } from 'module'
+            // ES import: import name from 'module'
+            // ES import: import * as name from 'module'
+            const esMatch = line.match(/import\s+(?:(?:\{([^}]*)\}|(\w+)|\*\s+as\s+(\w+))(?:\s*,\s*(?:\{([^}]*)\}|(\w+)|\*\s+as\s+(\w+)))?\s+from\s+)?['"]([^'"]+)['"]/);
+            if (esMatch) {
+                const mod = esMatch[7];
+                const bindings = [];
+                // Named imports: { a, b as c }
+                for (const group of [esMatch[1], esMatch[4]]) {
+                    if (group) {
+                        group.split(',').forEach(s => {
+                            const name = s.trim().split(/\s+as\s+/).pop()?.trim();
+                            if (name)
+                                bindings.push(name);
+                        });
+                    }
+                }
+                // Default import
+                if (esMatch[2])
+                    bindings.push(esMatch[2]);
+                if (esMatch[5])
+                    bindings.push(esMatch[5]);
+                // Namespace import
+                if (esMatch[3])
+                    bindings.push(esMatch[3]);
+                if (esMatch[6])
+                    bindings.push(esMatch[6]);
+                imports.push({
+                    module: mod,
+                    bindings,
+                    line: lineNum,
+                    isRelative: isRelativeImport(mod),
+                    isBuiltin: isNodeBuiltin(mod),
+                });
+                continue;
+            }
+            // Side-effect import: import 'module'
+            const sideEffectMatch = line.match(/import\s+['"]([^'"]+)['"]/);
+            if (sideEffectMatch) {
+                imports.push({
+                    module: sideEffectMatch[1],
+                    bindings: [],
+                    line: lineNum,
+                    isRelative: isRelativeImport(sideEffectMatch[1]),
+                    isBuiltin: isNodeBuiltin(sideEffectMatch[1]),
+                });
+                continue;
+            }
+            // Dynamic import: import('module')
+            const dynamicMatch = line.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (dynamicMatch) {
+                imports.push({
+                    module: dynamicMatch[1],
+                    bindings: [],
+                    line: lineNum,
+                    isRelative: isRelativeImport(dynamicMatch[1]),
+                    isBuiltin: isNodeBuiltin(dynamicMatch[1]),
+                });
+                continue;
+            }
+            // CommonJS: const { a, b } = require('module')
+            const cjsDestructMatch = line.match(/(?:const|let|var)\s+\{([^}]*)\}\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (cjsDestructMatch) {
+                const bindings = cjsDestructMatch[1]
+                    .split(',')
+                    .map(s => s.trim().split(/\s+as\s+/).pop()?.trim())
+                    .filter(Boolean);
+                imports.push({
+                    module: cjsDestructMatch[2],
+                    bindings,
+                    line: lineNum,
+                    isRelative: isRelativeImport(cjsDestructMatch[2]),
+                    isBuiltin: isNodeBuiltin(cjsDestructMatch[2]),
+                });
+                continue;
+            }
+            // CommonJS: const name = require('module')
+            const cjsMatch = line.match(/(?:const|let|var)\s+(\w+)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (cjsMatch) {
+                imports.push({
+                    module: cjsMatch[2],
+                    bindings: [cjsMatch[1]],
+                    line: lineNum,
+                    isRelative: isRelativeImport(cjsMatch[2]),
+                    isBuiltin: isNodeBuiltin(cjsMatch[2]),
+                });
+                continue;
+            }
+            // Bare require: require('module')
+            const bareRequireMatch = line.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+            if (bareRequireMatch && !cjsDestructMatch && !cjsMatch) {
+                imports.push({
+                    module: bareRequireMatch[1],
+                    bindings: [],
+                    line: lineNum,
+                    isRelative: isRelativeImport(bareRequireMatch[1]),
+                    isBuiltin: isNodeBuiltin(bareRequireMatch[1]),
+                });
+            }
+        }
+        return imports;
+    }
+    /**
+     * Extract function/method calls using regex.
+     * This is a lightweight extraction — AST-based extraction can be added later.
+     */
+    extractCalls(source, _ast) {
+        const calls = [];
+        const lines = source.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            // Skip comments
+            const trimmed = line.trim();
+            if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*')) {
+                continue;
+            }
+            // Match method calls: obj.method(...)
+            const methodCallPattern = /(\w+(?:\.\w+)+)\s*\(/g;
+            let match;
+            while ((match = methodCallPattern.exec(line)) !== null) {
+                calls.push({
+                    name: match[1],
+                    line: lineNum,
+                    column: match.index + 1,
+                    isMethodCall: true,
+                });
+            }
+            // Match standalone function calls: func(...)
+            const funcCallPattern = /(?<!\.)(?<!\w)([a-zA-Z_$]\w*)\s*\(/g;
+            while ((match = funcCallPattern.exec(line)) !== null) {
+                const name = match[1];
+                // Skip keywords
+                if (['if', 'for', 'while', 'switch', 'catch', 'return', 'throw', 'new',
+                    'typeof', 'instanceof', 'void', 'delete', 'await', 'yield', 'function',
+                    'class', 'const', 'let', 'var', 'import', 'export', 'async', 'from',
+                    'case', 'type', 'interface', 'enum'].includes(name)) {
+                    continue;
+                }
+                calls.push({
+                    name,
+                    line: lineNum,
+                    column: match.index + 1,
+                    isMethodCall: false,
+                });
+            }
+        }
+        return calls;
+    }
+    /**
+     * Verify if an npm package exists.
+     * Uses HEAD request to registry.npmjs.org.
+     * Note: This is a placeholder — actual HTTP verification will be done
+     * in DeepHallucinationDetector (Phase 2).
+     */
+    async verifyPackage(name) {
+        // Placeholder: return exists=true for now
+        // Real implementation in Phase 2 (DeepHallucinationDetector)
+        return {
+            name,
+            exists: true,
+            checkedAt: Date.now(),
+        };
+    }
+    /**
+     * Check if an API is deprecated.
+     * Placeholder — real deprecated-apis.json will be added in Phase 2 (StaleAPIDetector).
+     */
+    checkDeprecated(_api) {
+        return null;
+    }
+    /**
+     * Compute complexity metrics for a TypeScript/JavaScript file.
+     * Uses simple heuristic counting — AST-based metrics in Phase 2.
+     */
+    computeComplexity(source, _ast) {
+        const lines = source.split('\n');
+        const nonEmptyLines = lines.filter(l => l.trim().length > 0);
+        let cyclomatic = 1; // base
+        let cognitive = 0;
+        let maxNestingDepth = 0;
+        let currentDepth = 0;
+        let functionCount = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Count decision points for cyclomatic complexity
+            const decisions = (trimmed.match(/\b(if|else\s+if|for|while|case|catch|\?\?|&&|\|\|)\b/g) || []).length;
+            cyclomatic += decisions;
+            // Count ternary operators
+            const ternaries = (trimmed.match(/\?[^?:]*:/g) || []).length;
+            cyclomatic += ternaries;
+            // Track nesting depth
+            const opens = (trimmed.match(/\{/g) || []).length;
+            const closes = (trimmed.match(/\}/g) || []).length;
+            currentDepth += opens - closes;
+            if (currentDepth > maxNestingDepth) {
+                maxNestingDepth = currentDepth;
+            }
+            // Cognitive complexity: nested conditions add more
+            if (/\b(if|for|while|catch)\b/.test(trimmed)) {
+                cognitive += 1 + Math.max(0, currentDepth - 1);
+            }
+            // Count functions
+            if (/\b(function|=>)\b/.test(trimmed) || /\b(async\s+)?\w+\s*\(/.test(trimmed)) {
+                // Very rough function counter
+                if (/(?:function\s+\w+|(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\(|(?:async\s+)?(?:get|set)?\s*\w+\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{)/.test(trimmed)) {
+                    functionCount++;
+                }
+            }
+        }
+        return {
+            cyclomatic,
+            cognitive,
+            loc: nonEmptyLines.length,
+            functionCount,
+            maxNestingDepth,
+        };
+    }
+}
+//# sourceMappingURL=parser.js.map