code-graph-context 2.0.1 → 2.2.0

package/dist/core/utils/code-normalizer.js

@@ -0,0 +1,299 @@
+/**
+ * Code Normalizer Utility
+ * Normalizes code for structural duplicate detection by:
+ * - Stripping comments and whitespace
+ * - Replacing variable names with positional placeholders
+ * - Replacing literals with type placeholders
+ * - Computing SHA256 hash for comparison
+ */
+import * as crypto from 'crypto';
+// TypeScript/JavaScript keywords and built-in identifiers to preserve during normalization
+const RESERVED_KEYWORDS = new Set([
+    // Keywords
+    'async',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'of',
+    'private',
+    'protected',
+    'public',
+    'readonly',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+    // TypeScript-specific keywords
+    'abstract',
+    'as',
+    'asserts',
+    'constructor',
+    'declare',
+    'get',
+    'set',
+    'infer',
+    'is',
+    'keyof',
+    'module',
+    'namespace',
+    'require',
+    'type',
+    'satisfies',
+    'using',
+    // Built-in types
+    'any',
+    'boolean',
+    'never',
+    'number',
+    'object',
+    'string',
+    'symbol',
+    'unknown',
+    // Common built-ins
+    'Array',
+    'Object',
+    'String',
+    'Number',
+    'Boolean',
+    'Promise',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Date',
+    'Error',
+    'console',
+    'JSON',
+    'Math',
+    'BigInt',
+    'Symbol',
+    'Proxy',
+    'Reflect',
+    // Our placeholders
+    '$STR',
+    '$NUM',
+]);
+/**
+ * Normalize code for structural comparison.
+ * Removes formatting differences while preserving semantic structure.
+ */
+export const normalizeCode = (code) => {
+    if (!code || code.trim().length === 0) {
+        return {
+            normalizedCode: '',
+            normalizedHash: '',
+            metrics: {
+                parameterCount: 0,
+                statementCount: 0,
+                controlFlowDepth: 0,
+                lineCount: 0,
+                tokenCount: 0,
+            },
+        };
+    }
+    // Step 1: Replace string literals FIRST (to protect their contents from comment removal)
+    // This prevents strings containing "//" or "/*" from being corrupted
+    let normalized = replaceStringLiterals(code);
+    // Step 2: Remove comments (now safe since strings are already placeholders)
+    normalized = removeComments(normalized);
+    // Step 3: Normalize whitespace
+    normalized = normalizeWhitespace(normalized);
+    // Step 4: Replace numeric literals with placeholder
+    normalized = replaceNumericLiterals(normalized);
+    // Step 5: Replace variable names with positional placeholders
+    normalized = replaceVariableNames(normalized);
+    // Step 6: Calculate metrics
+    const metrics = calculateMetrics(code);
+    // Step 7: Compute hash
+    const normalizedHash = computeHash(normalized);
+    return {
+        normalizedCode: normalized,
+        normalizedHash,
+        metrics,
+    };
+};
+/**
+ * Remove single-line and multi-line comments from code.
+ */
+const removeComments = (code) => {
+    // Remove multi-line comments /* ... */
+    let result = code.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Remove single-line comments // ...
+    result = result.replace(/\/\/.*$/gm, '');
+    return result;
+};
+/**
+ * Normalize whitespace: collapse multiple spaces, remove leading/trailing.
+ */
+const normalizeWhitespace = (code) => {
+    return code
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+};
+/**
+ * Replace string literals with $STR placeholder.
+ * Handles single quotes, double quotes, and template literals.
+ */
+const replaceStringLiterals = (code) => {
+    // Replace template literals (backticks) - handle simple cases
+    let result = code.replace(/`[^`]*`/g, '$STR');
+    // Replace double-quoted strings
+    result = result.replace(/"(?:[^"\\]|\\.)*"/g, '$STR');
+    // Replace single-quoted strings
+    result = result.replace(/'(?:[^'\\]|\\.)*'/g, '$STR');
+    return result;
+};
+/**
+ * Replace numeric literals with $NUM placeholder.
+ * Handles: integers, floats, hex (0x), binary (0b), octal (0o), scientific notation, BigInt (n suffix)
+ */
+const replaceNumericLiterals = (code) => {
+    // Handle hex literals (0xFF, 0XAB)
+    let result = code.replace(/\b0[xX][0-9a-fA-F_]+n?\b/g, '$NUM');
+    // Handle binary literals (0b1010)
+    result = result.replace(/\b0[bB][01_]+n?\b/g, '$NUM');
+    // Handle octal literals (0o777)
+    result = result.replace(/\b0[oO][0-7_]+n?\b/g, '$NUM');
+    // Handle regular numbers (integers, floats, scientific notation, BigInt)
+    // Supports underscore separators (1_000_000) and BigInt suffix (123n)
+    // But not numbers that are part of variable names like $VAR_1
+    result = result.replace(/(?<![a-zA-Z_$])\b\d[\d_]*(\.\d[\d_]*)?([eE][+-]?\d[\d_]*)?n?\b/g, '$NUM');
+    return result;
+};
+/**
+ * Replace variable and parameter names with positional placeholders.
+ * Preserves keywords, built-in types, and operators.
+ */
+const replaceVariableNames = (code) => {
+    // Track variable name mappings
+    const variableMap = new Map();
+    let varCounter = 1;
+    // Match identifiers (variable names, function names, etc.)
+    // This is a simplified approach - matches word characters after boundaries
+    const identifierPattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
+    return code.replace(identifierPattern, (match) => {
+        // Skip keywords and built-ins (uses module-level constant)
+        if (RESERVED_KEYWORDS.has(match)) {
+            return match;
+        }
+        // Check if we've seen this identifier before
+        if (variableMap.has(match)) {
+            return variableMap.get(match);
+        }
+        // Assign new placeholder
+        const placeholder = `$VAR_${varCounter++}`;
+        variableMap.set(match, placeholder);
+        return placeholder;
+    });
+};
+/**
+ * Calculate structural metrics from the original code.
+ */
+const calculateMetrics = (code) => {
+    // Count parameters: look for function/method signatures
+    const paramMatches = code.match(/\([^)]*\)/g) ?? [];
+    let parameterCount = 0;
+    for (const match of paramMatches) {
+        // Count commas + 1 for non-empty param lists
+        const inner = match.slice(1, -1).trim();
+        if (inner.length > 0) {
+            parameterCount += inner.split(',').filter((p) => p.trim().length > 0).length;
+        }
+    }
+    // Count statements: approximate by counting semicolons and block closures
+    const statementCount = (code.match(/[;{}]/g)?.length ?? 0) / 2;
+    // Calculate control flow depth: count nesting of if/for/while/switch
+    let maxDepth = 0;
+    let currentDepth = 0;
+    const controlFlowPattern = /\b(if|for|while|switch|try|catch)\s*\(|{|}/g;
+    let match;
+    while ((match = controlFlowPattern.exec(code)) !== null) {
+        if (match[0] === '{') {
+            currentDepth++;
+            maxDepth = Math.max(maxDepth, currentDepth);
+        }
+        else if (match[0] === '}') {
+            currentDepth = Math.max(0, currentDepth - 1);
+        }
+    }
+    // Count lines (non-empty)
+    const lineCount = code.split('\n').filter((line) => line.trim().length > 0).length;
+    // Approximate token count
+    const tokenCount = code.split(/\s+/).filter((t) => t.length > 0).length;
+    return {
+        parameterCount,
+        statementCount: Math.round(statementCount),
+        controlFlowDepth: maxDepth,
+        lineCount,
+        tokenCount,
+    };
+};
+/**
+ * Compute SHA256 hash of the normalized code.
+ */
+const computeHash = (normalizedCode) => {
+    if (normalizedCode.length === 0) {
+        return '';
+    }
+    return crypto.createHash('sha256').update(normalizedCode).digest('hex');
+};
+/**
+ * Check if two code blocks are structurally similar based on metrics.
+ * Used for near-duplicate detection when hashes don't match.
+ */
+export const areMetricsSimilar = (metrics1, metrics2, threshold = 0.8) => {
+    // Compare each metric and calculate similarity score
+    const paramSim = 1 -
+        Math.abs(metrics1.parameterCount - metrics2.parameterCount) /
+            Math.max(metrics1.parameterCount, metrics2.parameterCount, 1);
+    const stmtSim = 1 -
+        Math.abs(metrics1.statementCount - metrics2.statementCount) /
+            Math.max(metrics1.statementCount, metrics2.statementCount, 1);
+    const depthSim = 1 -
+        Math.abs(metrics1.controlFlowDepth - metrics2.controlFlowDepth) /
+            Math.max(metrics1.controlFlowDepth, metrics2.controlFlowDepth, 1);
+    const lineSim = 1 - Math.abs(metrics1.lineCount - metrics2.lineCount) / Math.max(metrics1.lineCount, metrics2.lineCount, 1);
+    // Weighted average (statement count and line count are more important)
+    const avgSim = paramSim * 0.15 + stmtSim * 0.35 + depthSim * 0.15 + lineSim * 0.35;
+    return avgSim >= threshold;
+};

package/dist/core/utils/file-change-detection.js

@@ -5,9 +5,21 @@
 import { stat, realpath } from 'fs/promises';
 import { resolve, sep } from 'path';
 import { glob } from 'glob';
-import { EXCLUDE_PATTERNS_GLOB } from '../../constants.js';
+import { EXCLUDE_PATTERNS_GLOB, EXCLUDE_PATTERNS_REGEX } from '../../constants.js';
 import { QUERIES } from '../../storage/neo4j/neo4j.service.js';
 import { hashFile } from './file-utils.js';
+/**
+ * Check if a file path matches any of the exclude patterns.
+ * Uses the same patterns as the TypeScript parser.
+ */
+const shouldExcludeFile = (filePath) => {
+    for (const pattern of EXCLUDE_PATTERNS_REGEX) {
+        if (filePath.includes(pattern) || new RegExp(pattern).test(filePath)) {
+            return true;
+        }
+    }
+    return false;
+};
 /**
  * Detect which files have changed and need reparsing.
  * Compares current files on disk with indexed files in Neo4j.
@@ -59,7 +71,10 @@ export const detectChangedFiles = async (projectPath, neo4jService, projectId, o
     for (const filePath of currentFiles) {
         const indexed = indexedMap.get(filePath);
         if (!indexed) {
-            // New file - needs parsing
+            // New file - check if it should be excluded (same rules as parser)
+            if (shouldExcludeFile(filePath)) {
+                continue; // Skip excluded files
+            }
             filesToReparse.push(filePath);
             continue;
         }

package/dist/core/utils/file-utils.js

@@ -1,20 +1,55 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs/promises';
 import * as path from 'path';
-const DEBUG_LOG_FILE = 'debug-search.log';
-const LOG_SEPARATOR = '---';
-const JSON_INDENT = 2;
+import { LOG_CONFIG } from '../../constants.js';
 export const hashFile = async (filePath) => {
     const content = await fs.readFile(filePath);
     return crypto.createHash('sha256').update(content).digest('hex');
 };
 export const debugLog = async (message, data) => {
     const timestamp = new Date().toISOString();
-    const logEntry = `[${timestamp}] ${message}\n${data ? JSON.stringify(data, null, JSON_INDENT) : ''}\n${LOG_SEPARATOR}\n`;
+    const logEntry = `[${timestamp}] ${message}\n${data ? JSON.stringify(data, null, LOG_CONFIG.jsonIndent) : ''}\n${LOG_CONFIG.separator}\n`;
     try {
-        await fs.appendFile(path.join(process.cwd(), DEBUG_LOG_FILE), logEntry);
+        await fs.appendFile(path.join(process.cwd(), LOG_CONFIG.debugLogFile), logEntry);
     }
     catch (error) {
         console.error('Failed to write debug log:', error);
     }
 };
+/**
+ * Safely test if a file path matches a pattern (string or regex).
+ * Falls back to literal string matching if the pattern is an invalid regex.
+ */
+export const matchesPattern = (filePath, pattern) => {
+    // First try literal string match (always safe)
+    if (filePath.includes(pattern)) {
+        return true;
+    }
+    // Then try regex match with error handling
+    try {
+        return new RegExp(pattern).test(filePath);
+    }
+    catch {
+        // Invalid regex pattern - already checked via includes() above
+        return false;
+    }
+};
+/**
+ * Clean up a TypeScript type name by removing generics, imports, etc.
+ * Examples:
+ *   import("./foo").ClassName -> ClassName
+ *   ClassName<T> -> ClassName
+ *   ClassName[] -> ClassName
+ */
+export const cleanTypeName = (typeName) => {
+    // Remove import paths: import("...").ClassName -> ClassName
+    let cleaned = typeName.replace(/import\([^)]+\)\./g, '');
+    // Remove generics: ClassName<T> -> ClassName
+    const genericIndex = cleaned.indexOf('<');
+    if (genericIndex > 0) {
+        cleaned = cleaned.substring(0, genericIndex);
+    }
+    // Remove array notation: ClassName[] -> ClassName
+    cleaned = cleaned.replace(/\[\]$/, '');
+    return cleaned.trim();
+};

package/dist/core/utils/graph-factory.js

@@ -0,0 +1,161 @@
+/**
+ * Graph Factory
+ * Shared utilities for creating/converting graph nodes and edges
+ */
+import crypto from 'crypto';
+import { CoreEdgeType, CORE_TYPESCRIPT_SCHEMA } from '../config/schema.js';
+// ============================================
+// Node ID Generation
+// ============================================
+/**
+ * Generate a deterministic node ID based on stable properties.
+ * This ensures the same node gets the same ID across reparses.
+ *
+ * Identity is based on: projectId + coreType + filePath + name (+ parentId for nested nodes)
+ * This is stable because when it matters (one side of edge not reparsed),
+ * names are guaranteed unchanged (or imports would break, triggering reparse).
+ *
+ * Including projectId ensures nodes from different projects have unique IDs
+ * even if they have identical file paths and names.
+ */
+export const generateDeterministicId = (projectId, coreType, filePath, name, parentId) => {
+    const parts = parentId ? [projectId, coreType, filePath, parentId, name] : [projectId, coreType, filePath, name];
+    const identity = parts.join('::');
+    const hash = crypto.createHash('sha256').update(identity).digest('hex').substring(0, 16);
+    return `${projectId}:${coreType}:${hash}`;
+};
+/**
+ * Generate a deterministic edge ID based on semantic type, source, and target.
+ * Uses SHA256 hash truncated to 16 characters for uniqueness.
+ */
+export const generateFrameworkEdgeId = (semanticType, sourceNodeId, targetNodeId) => {
+    const edgeIdentity = `${semanticType}::${sourceNodeId}::${targetNodeId}`;
+    const edgeHash = crypto.createHash('sha256').update(edgeIdentity).digest('hex').substring(0, 16);
+    return `${semanticType}:${edgeHash}`;
+};
+/**
+ * Create framework edge ID and properties.
+ * Returns common edge data that can be used to construct either ParsedEdge or Neo4jEdge.
+ *
+ * @param params - Edge parameters
+ * @returns Edge ID and properties object
+ */
+export const createFrameworkEdgeData = (params) => {
+    const { semanticType, sourceNodeId, targetNodeId, projectId, context = {}, relationshipWeight = 0.5 } = params;
+    const id = generateFrameworkEdgeId(semanticType, sourceNodeId, targetNodeId);
+    const properties = {
+        coreType: semanticType,
+        projectId,
+        semanticType,
+        source: 'pattern',
+        confidence: 0.8,
+        relationshipWeight,
+        filePath: '',
+        createdAt: new Date().toISOString(),
+        context,
+    };
+    return { id, properties };
+};
+/**
+ * Generate a deterministic edge ID for core edges.
+ */
+export const generateCoreEdgeId = (edgeType, sourceNodeId, targetNodeId) => {
+    const edgeIdentity = `${edgeType}::${sourceNodeId}::${targetNodeId}`;
+    const edgeHash = crypto.createHash('sha256').update(edgeIdentity).digest('hex').substring(0, 16);
+    return `${edgeType}:${edgeHash}`;
+};
+/**
+ * Create a core edge (CONTAINS, IMPORTS, EXTENDS, IMPLEMENTS, etc.)
+ */
+export const createCoreEdge = (params) => {
+    const { edgeType, sourceNodeId, targetNodeId, projectId, filePath = '' } = params;
+    const coreEdgeSchema = CORE_TYPESCRIPT_SCHEMA.edgeTypes[edgeType];
+    const relationshipWeight = coreEdgeSchema?.relationshipWeight ?? 0.5;
+    const id = generateCoreEdgeId(edgeType, sourceNodeId, targetNodeId);
+    return {
+        id,
+        type: edgeType,
+        startNodeId: sourceNodeId,
+        endNodeId: targetNodeId,
+        properties: {
+            coreType: edgeType,
+            projectId,
+            source: 'ast',
+            confidence: 1.0,
+            relationshipWeight,
+            filePath,
+            createdAt: new Date().toISOString(),
+        },
+    };
+};
+/**
+ * Create a CALLS edge with call-specific context.
+ */
+export const createCallsEdge = (params) => {
+    const { sourceNodeId, targetNodeId, projectId, callContext } = params;
+    const coreEdgeSchema = CORE_TYPESCRIPT_SCHEMA.edgeTypes[CoreEdgeType.CALLS];
+    const relationshipWeight = coreEdgeSchema?.relationshipWeight ?? 0.85;
+    // Confidence: higher if we resolved the receiver type
+    const confidence = callContext?.receiverType ? 0.9 : 0.7;
+    // Generate deterministic edge ID based on type + source + target + line
+    const lineNum = callContext?.lineNumber ?? 0;
+    const edgeIdentity = `CALLS::${sourceNodeId}::${targetNodeId}::${lineNum}`;
+    const edgeHash = crypto.createHash('sha256').update(edgeIdentity).digest('hex').substring(0, 16);
+    const id = `CALLS:${edgeHash}`;
+    return {
+        id,
+        type: 'CALLS',
+        startNodeId: sourceNodeId,
+        endNodeId: targetNodeId,
+        properties: {
+            coreType: CoreEdgeType.CALLS,
+            projectId,
+            source: 'ast',
+            confidence,
+            relationshipWeight,
+            filePath: '',
+            createdAt: new Date().toISOString(),
+            lineNumber: callContext?.lineNumber,
+            context: callContext
+                ? {
+                    isAsync: callContext.isAsync,
+                    argumentCount: callContext.argumentCount,
+                    receiverType: callContext.receiverType,
+                }
+                : undefined,
+        },
+    };
+};
+// ============================================
+// Node/Edge Conversion Functions
+// Convert internal parsed types to Neo4j types
+// ============================================
+/**
+ * Convert a ParsedNode to Neo4jNode format for storage/export.
+ */
+export const toNeo4jNode = (parsedNode) => ({
+    id: parsedNode.id,
+    labels: parsedNode.labels,
+    properties: parsedNode.properties,
+    skipEmbedding: parsedNode.skipEmbedding ?? false,
+});
+/**
+ * Convert a ParsedEdge to Neo4jEdge format for storage/export.
+ */
+export const toNeo4jEdge = (parsedEdge) => ({
+    id: parsedEdge.id,
+    type: parsedEdge.relationshipType,
+    startNodeId: parsedEdge.sourceNodeId,
+    endNodeId: parsedEdge.targetNodeId,
+    properties: parsedEdge.properties,
+});
+/**
+ * Convert a Neo4jEdge to ParsedEdge format for internal use.
+ */
+export const toParsedEdge = (neo4jEdge) => ({
+    id: neo4jEdge.id,
+    relationshipType: neo4jEdge.type,
+    sourceNodeId: neo4jEdge.startNodeId,
+    targetNodeId: neo4jEdge.endNodeId,
+    properties: neo4jEdge.properties,
+});

package/dist/core/utils/shared-utils.js

@@ -0,0 +1,79 @@
+/**
+ * Shared Utilities
+ * Common interfaces, types, and helper functions used across dead code and duplicate code detection tools.
+ */
+import path from 'path';
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Convert Neo4j value to JavaScript number.
+ * Handles both regular numbers and Neo4j Integer objects.
+ */
+export const toNumber = (value) => {
+    if (value === null || value === undefined) {
+        return 0;
+    }
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'object' && value !== null && 'toNumber' in value) {
+        return value.toNumber();
+    }
+    return 0;
+};
+/**
+ * Check if file path indicates a UI component.
+ * Must be in UI component directory AND be a React/Vue component file.
+ * Cross-platform: matches both / and \ path separators.
+ */
+export const isUIComponent = (filePath) => {
+    const isInUIDir = /[/\\](components[/\\]ui|ui[/\\]components)[/\\]/.test(filePath);
+    const isFrontendFile = /\.(tsx|jsx|vue)$/.test(filePath);
+    return isInUIDir && isFrontendFile;
+};
+/**
+ * Check if file is in a package directory (monorepo packages).
+ * Cross-platform: matches both / and \ path separators.
+ */
+export const isPackageExport = (filePath) => {
+    return /[/\\]packages[/\\][^/\\]+[/\\]/.test(filePath);
+};
+/**
+ * Extract monorepo app name from file path.
+ * Cross-platform: matches both / and \ path separators.
+ */
+export const getMonorepoAppName = (filePath) => {
+    const match = filePath.match(/[/\\](apps|packages)[/\\]([^/\\]+)[/\\]/);
+    return match ? match[2] : null;
+};
+/**
+ * Check if file matches exclusion pattern.
+ * Supports simple glob patterns starting with *.
+ */
+export const isExcludedByPattern = (filePath, patterns) => {
+    return patterns.some((pattern) => {
+        if (pattern.startsWith('*')) {
+            return filePath.endsWith(pattern.substring(1));
+        }
+        return filePath.endsWith(pattern);
+    });
+};
+/**
+ * Truncate source code to a maximum length.
+ * Useful for limiting response sizes.
+ */
+export const truncateSourceCode = (sourceCode, maxLength = 500) => {
+    if (!sourceCode)
+        return undefined;
+    return sourceCode.substring(0, maxLength);
+};
+/**
+ * Get shortened file path (last N segments).
+ * Useful for compact display.
+ * Cross-platform: uses path.sep for correct separator handling.
+ */
+export const getShortPath = (filePath, segments = 2) => {
+    const parts = filePath.split(path.sep);
+    return parts.slice(-segments).join(path.sep);
+};