code-auditor-mcp 3.1.0 → 3.4.0

package/dist/analyzers/universal/UniversalSchemaAnalyzer.js

@@ -10,6 +10,8 @@
  */
 import { UniversalAnalyzer } from '../../languages/UniversalAnalyzer.js';
 import picomatch from 'picomatch';
+import { buildProvenanceContext, isDBProvenanced, DB_CALL_METHODS, } from '../provenance.js';
+import { OrmAdapterRegistry } from '../orm/index.js';
 export const DEFAULT_SCHEMA_CONFIG = {
     enableTableUsageTracking: true,
     checkMissingReferences: true,
@@ -34,6 +36,7 @@ export const DEFAULT_SCHEMA_CONFIG = {
     fileGateGlobs: ['**/*.sql', '**/migrations/**'],
 };
 import { promises as fs } from 'fs';
+import { CodeIndexDB } from '../../codeIndexDB.js';
 export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
     name = 'schema';
     description = 'Analyzes code against database schemas and validates JSON schemas';
@@ -61,8 +64,20 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
     async analyzeAST(ast, adapter, config, sourceCode) {
         const violations = [];
         const finalConfig = { ...DEFAULT_SCHEMA_CONFIG, ...config };
-        // R2.2 — File gate: only analyze files with DB context
-        if (!this.passesFileGate(ast.filePath, sourceCode, finalConfig)) {
+        // Spec 21: Build provenance context for this file (R1 — provenance-primary detection)
+        const detectionMode = config.detection?.mode ?? 'hybrid';
+        const p0 = performance.now();
+        const provenanceContext = buildProvenanceContext(ast, adapter, sourceCode, {
+            mode: detectionMode,
+            dbReceiverNames: finalConfig.dbReceiverNames ?? DEFAULT_SCHEMA_CONFIG.dbReceiverNames,
+            dbBindingNames: finalConfig.dbBindingNames ?? DEFAULT_SCHEMA_CONFIG.dbBindingNames,
+            dbCallMethods: finalConfig.dbCallMethods ?? DEFAULT_SCHEMA_CONFIG.dbCallMethods,
+        });
+        const timingAcc = config._provenanceTiming;
+        if (timingAcc)
+            timingAcc.totalMs += performance.now() - p0;
+        // R2.2 — File gate: only analyze files with DB context (Spec 21: provenance-based)
+        if (!this.passesFileGate(ast.filePath, sourceCode, finalConfig, provenanceContext)) {
             return violations;
         }
         // Get available schemas
@@ -77,12 +92,18 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
             }
         }
         if (finalConfig.requiredSchemas && finalConfig.requiredSchemas.length > 0 && schemas.length === 0) {
-            violations.push(this.createViolation(ast.filePath, { line: 1, column: 1 }, 'No database schemas loaded for analysis', 'warning', 'missing-schemas'));
+            violations.push(this.createViolation(ast.filePath, { line: 1, column: 1 }, 'No database schemas loaded for analysis', 'warning', 'missing-schemas', undefined, 'top-level:missing-schemas'));
             return violations;
         }
         // R2.1 — AST-based table reference extraction (replaces legacy regex scan-all-strings)
-        const tableRefs = this.findTableReferences(ast, adapter, sourceCode, finalConfig);
+        // Spec 21: Uses provenance context for DB-call pattern detection
+        const tableRefs = this.findTableReferences(ast, adapter, sourceCode, finalConfig, provenanceContext);
         const columnRefs = this.findColumnReferences(ast, adapter, sourceCode);
+        // Spec 15 R1 — Record schema usage for cross-domain lifecycle analysis.
+        // Idempotent per-file: clear stale entries before inserting fresh references.
+        if (finalConfig.enableTableUsageTracking) {
+            this.recordTableUsage(ast, adapter, ast.filePath, tableRefs);
+        }
         // Check for missing table references — R2.4: Levenshtein suggestions
         if (finalConfig.checkMissingReferences) {
             for (const ref of tableRefs) {
@@ -92,13 +113,13 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
                         ? `Reference to unknown table '${ref.table}' (${ref.type}). Did you mean: ${suggestions.join(', ')}?`
                         : `Reference to unknown table '${ref.table}' (${ref.type})`;
                     violations.push(this.createViolation(ast.filePath, ref.location, msg, 'suggestion', // R7
-                    'unknown-table'));
+                    'unknown-table', undefined, ref.table));
                 }
             }
             for (const ref of columnRefs) {
                 const columnSet = tableColumns.get(ref.table);
                 if (columnSet && !columnSet.has(ref.column)) {
-                    violations.push(this.createViolation(ast.filePath, ref.location, `Reference to unknown column '${ref.column}' in table '${ref.table}'`, 'warning', 'unknown-column'));
+                    violations.push(this.createViolation(ast.filePath, ref.location, `Reference to unknown column '${ref.column}' in table '${ref.table}'`, 'warning', 'unknown-column', undefined, `${ref.table}.${ref.column}`));
                 }
             }
         }
@@ -121,7 +142,7 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
      * Pre-filter: only analyze files that show DB usage.
      * Checks: .sql/migration glob, D1/SQL imports, env-binding patterns, DB calls.
      */
-    passesFileGate(filePath, sourceCode, config) {
+    passesFileGate(filePath, sourceCode, config, provenanceContext) {
         // Always pass .sql files and migration directories
         const gateGlobs = config.fileGateGlobs ?? ['**/*.sql', '**/migrations/**'];
         for (const glob of gateGlobs) {
@@ -129,38 +150,49 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
                 return true;
             }
         }
-        // Check for D1 or SQL API imports
-        const importPatterns = [
-            /import\s+.*\b(D1Database|D1PreparedStatement|D1Result)\b/,
-            /import\s+.*from\s+['"].*d1['"]/,
-            /import\s+.*from\s+['"].*pg['"]/,
-            /import\s+.*from\s+['"].*mysql['"]/,
-            /import\s+.*from\s+['"].*sqlite['"]/,
-            /import\s+.*from\s+['"].*knex['"]/,
-            /import\s+.*from\s+['"].*drizzle['"]/,
-            /import\s+.*from\s+['"].*prisma['"]/,
-        ];
-        for (const pat of importPatterns) {
-            if (pat.test(sourceCode))
-                return true;
-        }
-        // Check for env-binding patterns (e.g., env.DB in Cloudflare Workers)
-        const bindingNames = config.dbBindingNames ?? ['env.DB'];
-        for (const binding of bindingNames) {
-            if (sourceCode.includes(binding))
+        // Spec 21: Provenance-first DB detection — if any identifier is DB-provenanced,
+        // this file passes the gate. This replaces the regex patterns for import/environment/
+        // receiver.method checks in hybrid and provenance modes.
+        if (provenanceContext && provenanceContext.mode !== 'names') {
+            if (provenanceContext.dbProvenanced.size > 0) {
                 return true;
+            }
         }
-        // Check for DB call patterns (receiver.method)
-        const receivers = config.dbReceiverNames ?? ['db', 'database', 'sql', 'stmt'];
-        const methods = config.dbCallMethods ?? ['exec', 'prepare', 'batch', 'run', 'all', 'first'];
-        for (const receiver of receivers) {
-            for (const method of methods) {
-                const pattern = new RegExp(`\\b${escapeRegex(receiver)}\\.${escapeRegex(method)}\\s*\\(`);
-                if (pattern.test(sourceCode))
+        // Legacy name-based detection — used in 'names' mode or when no provenance context
+        if (!provenanceContext || provenanceContext.mode === 'names') {
+            // Check for D1 or SQL API imports
+            const importPatterns = [
+                /import\s+.*\b(D1Database|D1PreparedStatement|D1Result)\b/,
+                /import\s+.*from\s+['"].*d1['"]/,
+                /import\s+.*from\s+['"].*pg['"]/,
+                /import\s+.*from\s+['"].*mysql['"]/,
+                /import\s+.*from\s+['"].*sqlite['"]/,
+                /import\s+.*from\s+['"].*knex['"]/,
+                /import\s+.*from\s+['"].*drizzle['"]/,
+                /import\s+.*from\s+['"].*prisma['"]/,
+            ];
+            for (const pat of importPatterns) {
+                if (pat.test(sourceCode))
                     return true;
             }
+            // Check for env-binding patterns (e.g., env.DB in Cloudflare Workers)
+            const bindingNames = config.dbBindingNames ?? ['env.DB'];
+            for (const binding of bindingNames) {
+                if (sourceCode.includes(binding))
+                    return true;
+            }
+            // Check for DB call patterns (receiver.method)
+            const receivers = config.dbReceiverNames ?? ['db', 'database', 'sql', 'stmt'];
+            const methods = config.dbCallMethods ?? ['exec', 'prepare', 'batch', 'run', 'all', 'first'];
+            for (const receiver of receivers) {
+                for (const method of methods) {
+                    const pattern = new RegExp(`\\b${escapeRegex(receiver)}\\.${escapeRegex(method)}\\s*\\(`);
+                    if (pattern.test(sourceCode))
+                        return true;
+                }
+            }
         }
-        // Check for SQL tagged template literals
+        // Check for SQL tagged template literals (syntax feature, not naming convention)
         const sqlTags = config.sqlTagNames ?? ['sql', 'db'];
         for (const tag of sqlTags) {
             const pattern = new RegExp(`\\b${escapeRegex(tag)}\`\\s*SELECT|\\b${escapeRegex(tag)}\`\\s*INSERT|\\b${escapeRegex(tag)}\`\\s*UPDATE|\\b${escapeRegex(tag)}\`\\s*DELETE|\\b${escapeRegex(tag)}\`\\s*CREATE`, 'i');
@@ -177,12 +209,11 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
      * R2.1: Only tagged template SQL and DB-call patterns produce candidates.
      * R2.3: Template expressions (${var}) resolved to wildcards.
      */
-    findTableReferences(ast, adapter, sourceCode, config) {
+    findTableReferences(ast, adapter, sourceCode, config, provenanceContext) {
         const references = [];
         const sqlTags = config.sqlTagNames ?? ['sql', 'db'];
-        const dbMethods = config.dbCallMethods ?? ['exec', 'prepare', 'batch', 'run', 'all', 'first', 'query'];
-        const dbReceivers = config.dbReceiverNames ?? ['db', 'database', 'sql', 'stmt'];
         // (1) Tagged template SQL — e.g. sql`SELECT * FROM heroes`
+        // This is a syntax feature, not a naming convention — keep the sqlTagNames gate.
         const taggedTemplates = adapter.findNodes(ast, {
             custom: (node) => {
                 if (node.type !== 'call_expression')
@@ -204,14 +235,21 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
             references.push(...tableRefs);
         }
         // (2) DB-call patterns — e.g. db.exec("SELECT * FROM heroes")
+        // Spec 21: Replace name-based isDbMemberCall with provenance-based isDBProvenanced.
         const dbCalls = adapter.findNodes(ast, {
             custom: (node) => {
                 if (node.type !== 'call_expression')
                     return false;
+                // Spec 21: Use provenance when available, fall back to name-based check
+                if (provenanceContext && provenanceContext.mode !== 'names') {
+                    return isDBProvenanced(node, adapter, sourceCode, provenanceContext, DB_CALL_METHODS);
+                }
+                // Legacy name-based check for names mode / no context
                 const callee = this.getCallee(node, adapter, sourceCode);
                 if (!callee)
                     return false;
-                // Check if callee is a member expression like db.exec or db.prepare
+                const dbMethods = config.dbCallMethods ?? ['exec', 'prepare', 'batch', 'run', 'all', 'first', 'query'];
+                const dbReceivers = config.dbReceiverNames ?? ['db', 'database', 'sql', 'stmt'];
                 return this.isDbMemberCall(node, callee, dbMethods, dbReceivers, adapter, sourceCode);
             },
         });
@@ -230,8 +268,67 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
             const fileRefs = this.parseSqlTables(sourceCode, { line: 1, column: 1 }, sourceCode);
             references.push(...fileRefs);
         }
+        // (4) Spec 15 R2 — ORM-aware extraction (Drizzle + Prisma)
+        // Run ORM adapter extraction for files that match a registered adapter.
+        // This complements raw-SQL extraction by picking up ORM-specific patterns
+        // like db.select().from(users) and prisma.user.findMany().
+        const ormRegistry = OrmAdapterRegistry.getInstance();
+        const ormAdapter = ormRegistry.getAdapterForFile(ast.filePath);
+        if (ormAdapter) {
+            try {
+                const ormRefs = ormAdapter.extractTableReferences(ast, adapter, sourceCode);
+                for (const ormRef of ormRefs) {
+                    references.push({
+                        table: ormRef.table,
+                        type: ormRef.type,
+                        location: ormRef.location,
+                        context: ormRef.context,
+                    });
+                }
+            }
+            catch {
+                // ORM extraction is best-effort — failures don't block raw-SQL extraction.
+            }
+        }
         return references;
     }
+    /**
+     * Spec 15 R1 — Record extracted table references to schema_usage for
+     * cross-domain lifecycle analysis (written-never-read, read-never-written,
+     * transaction-boundary risk).
+     *
+     * Idempotent per-file: stale entries are cleared before fresh references
+     * are inserted. For .sql/migration files, uses "schema-file" as the
+     * function name since there's no AST function context.
+     */
+    recordTableUsage(ast, adapter, filePath, references) {
+        try {
+            const db = CodeIndexDB.getInstance();
+            db.clearSchemaUsageForFile(filePath);
+            for (const ref of references) {
+                // Find enclosing function from the AST position
+                const node = this.findClosestNodeAt(ast.root, ref.location, adapter);
+                const functionName = node
+                    ? this.findEnclosingFunctionName(node, adapter)
+                    : ast.filePath.endsWith('.sql') || ast.filePath.includes('/migrations/')
+                        ? 'schema-file'
+                        : 'top-level';
+                const usage = {
+                    tableName: ref.table,
+                    filePath,
+                    functionName,
+                    usageType: ref.type,
+                    line: ref.location.line,
+                    column: ref.location.column,
+                    rawQuery: ref.context,
+                };
+                db.recordSchemaUsage(usage);
+            }
+        }
+        catch {
+            // Schema recording is best-effort — failures don't block analysis.
+        }
+    }
     /**
      * Parse SQL table names from a SQL text string.
      * R2.3: Template expressions (${...}) resolve portions to wildcards.
@@ -241,14 +338,16 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
         // R2.3: Strip template expressions — `${prefix}_builds` → `_builds`
         // (the prefix is replaced with empty, the suffix remains for matching)
         const cleaned = this.resolveTemplateExpressions(sqlText);
-        // SQL patterns anchored to SQL keywords (not arbitrary substrings)
+        // SQL patterns anchored to SQL keywords (not arbitrary substrings).
+        // Uses Unicode-aware \p{L} so non-Latin table names (日, 注文, пользователи)
+        // are correctly matched — \w is ASCII-only. Spec 21 R5.
         const sqlPatterns = [
-            { regex: /\bFROM\s+([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'select' },
-            { regex: /\bJOIN\s+([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'select' },
-            { regex: /\bINSERT\s+INTO\s+([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'insert' },
-            { regex: /\bUPDATE\s+([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'update' },
-            { regex: /\bDELETE\s+FROM\s+([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'delete' },
-            { regex: /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"']?)([a-zA-Z_]\w*)\1\b/gi, type: 'create' },
+            { regex: /\bFROM\s+([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'select' },
+            { regex: /\bJOIN\s+([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'select' },
+            { regex: /\bINSERT\s+INTO\s+([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'insert' },
+            { regex: /\bUPDATE\s+([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'update' },
+            { regex: /\bDELETE\s+FROM\s+([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'delete' },
+            { regex: /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"']?)([\p{L}_][\p{L}\p{N}_]*)\1\b/giu, type: 'create' },
         ];
         for (const { regex, type } of sqlPatterns) {
             let match;
@@ -334,9 +433,9 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
     findColumnReferences(ast, adapter, sourceCode) {
         const references = [];
         const patterns = [
-            /(\w+)\.(\w+)\s*[=<>]/gi,
-            /SELECT\s+.*?(\w+)\.(\w+)/gi,
-            /WHERE\s+.*?(\w+)\.(\w+)/gi,
+            /([\p{L}\p{N}_]+)\.([\p{L}\p{N}_]+)\s*[=<>]/giu,
+            /SELECT\s+.*?([\p{L}\p{N}_]+)\.([\p{L}\p{N}_]+)/giu,
+            /WHERE\s+.*?([\p{L}\p{N}_]+)\.([\p{L}\p{N}_]+)/giu,
         ];
         for (const pattern of patterns) {
             let match;
@@ -363,11 +462,11 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
         const violations = [];
         for (const ref of references) {
             if (/[A-Z]/.test(ref.table) && !ref.table.endsWith('Table')) {
-                violations.push(this.createViolation(filePath, ref.location, `Table name '${ref.table}' should use snake_case convention`, 'suggestion', 'naming-convention'));
+                violations.push(this.createViolation(filePath, ref.location, `Table name '${ref.table}' should use snake_case convention`, 'suggestion', 'naming-convention', undefined, ref.table));
             }
             const reserved = ['user', 'order', 'group', 'table', 'column', 'index'];
             if (reserved.includes(ref.table.toLowerCase())) {
-                violations.push(this.createViolation(filePath, ref.location, `Table name '${ref.table}' is a reserved word. Consider using a different name.`, 'warning', 'reserved-word'));
+                violations.push(this.createViolation(filePath, ref.location, `Table name '${ref.table}' is a reserved word. Consider using a different name.`, 'warning', 'reserved-word', undefined, ref.table));
             }
         }
         return violations;
@@ -385,30 +484,43 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
             const funcText = adapter.getNodeText(funcNode, sourceCode);
             const queryCount = this.countQueries(funcText);
             if (queryCount > (config.maxQueriesPerFunction || 5)) {
-                violations.push(this.createViolation(ast.filePath, func.location.start, `Function '${func.name}' has ${queryCount} queries, exceeding the maximum of ${config.maxQueriesPerFunction}`, 'warning', 'too-many-queries'));
+                violations.push(this.createViolation(ast.filePath, func.location.start, `Function '${func.name}' has ${queryCount} queries, exceeding the maximum of ${config.maxQueriesPerFunction}`, 'warning', 'too-many-queries', undefined, func.name));
             }
         }
-        // N+1 query check — only flag if we have actual DB calls, not grep
-        if (sourceCode.includes('.map') && (sourceCode.includes('.query') || sourceCode.includes('SELECT'))) {
-            violations.push(this.createViolation(ast.filePath, { line: 1, column: 1 }, 'Potential N+1 query pattern detected. Consider using a join or batch query.', 'warning', 'n-plus-one'));
-        }
+        // N+1 query detection is handled by the data-access analyzer (loop-query rule).
+        // The two were consolidated in Spec-19 Corrective Batch Item 3 — see CHANGELOG.
         return violations;
     }
     // ---------------------------------------------------------------------------
     // SQL injection — R7: severity changed from critical to warning
     // ---------------------------------------------------------------------------
+    // ---------------------------------------------------------------------------
+    // SQL injection — per-call-site with enclosing-function + ordinal symbols
+    // ---------------------------------------------------------------------------
     checkSQLInjection(ast, adapter, sourceCode) {
         const violations = [];
+        const symbolOrdinals = new Map();
+        // Use regex with global flag to find individual call sites
         const dangerousPatterns = [
             /query\s*\(\s*`[^`]*\$\{[^}]+\}[^`]*`/g,
             /query\s*\(\s*['"][^'"]*['"]?\s*\+/g,
             /execute\s*\(\s*['"][^'"]*['"]?\s*\+/g,
         ];
         for (const pattern of dangerousPatterns) {
-            if (pattern.test(sourceCode)) {
-                violations.push(this.createViolation(ast.filePath, { line: 1, column: 1 }, 'Potential SQL injection vulnerability. Use parameterized queries.', 'warning', // R7: was 'critical'
-                'sql-injection'));
-                break;
+            // Clone regex to reset state (global regexes track lastIndex)
+            const re = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = re.exec(sourceCode)) !== null) {
+                const location = this.offsetToLocation(sourceCode, match.index, { line: 1, column: 1 });
+                // Find enclosing function from the AST at this position
+                const node = this.findClosestNodeAt(ast.root, location, adapter);
+                const enclosingFn = node ? this.findEnclosingFunctionName(node, adapter) : 'top-level';
+                const baseSymbol = `${enclosingFn}:sql-injection`;
+                const ordinal = (symbolOrdinals.get(baseSymbol) ?? 0) + 1;
+                symbolOrdinals.set(baseSymbol, ordinal);
+                const symbol = ordinal > 1 ? `${baseSymbol}:${ordinal}` : baseSymbol;
+                violations.push(this.createViolation(ast.filePath, location, 'Potential SQL injection vulnerability. Use parameterized queries.', 'suggestion', // Spec 11 R4 blanket demotion: all survivors → suggestion
+                'sql-injection', undefined, symbol));
             }
         }
         return violations;
@@ -599,6 +711,85 @@ export class UniversalSchemaAnalyzer extends UniversalAnalyzer {
         }
         return null;
     }
+    /**
+     * Find the nearest AST node at a source location — walks the tree looking
+     * for the deepest node that contains the given line/column.
+     */
+    findClosestNodeAt(root, location, adapter) {
+        let best = null;
+        let bestDepth = -1;
+        const walk = (node, depth) => {
+            const start = node.location.start;
+            const end = node.location.end;
+            // Check if node contains the location
+            if ((start.line < location.line ||
+                (start.line === location.line && start.column <= location.column)) &&
+                (end.line > location.line ||
+                    (end.line === location.line && end.column >= location.column))) {
+                if (depth > bestDepth) {
+                    best = node;
+                    bestDepth = depth;
+                }
+                if (node.children) {
+                    for (const child of node.children) {
+                        walk(child, depth + 1);
+                    }
+                }
+            }
+        };
+        walk(root, 0);
+        return best;
+    }
+    /**
+     * Walk up the AST from a node to find the enclosing function or method name.
+     * Matches the same scheme as UniversalDataAccessAnalyzer.findEnclosingFunctionName.
+     */
+    findEnclosingFunctionName(node, adapter) {
+        let current = node;
+        while (current) {
+            const type = adapter.getNodeType(current);
+            if (type === 'arrow_function' ||
+                type === 'function_declaration' ||
+                type === 'function_expression' ||
+                type === 'generator_function_declaration' ||
+                type === 'generator_function_expression' ||
+                type === 'method_definition') {
+                const name = this.getNodeName(current, adapter);
+                if (name)
+                    return name;
+            }
+            if (adapter.isMethod(current)) {
+                const name = this.getNodeName(current, adapter);
+                if (name)
+                    return name;
+            }
+            current = adapter.getParent(current);
+        }
+        return 'top-level';
+    }
+    /**
+     * Extract a human-readable name from an AST node.
+     * Matches the same scheme as UniversalDataAccessAnalyzer.getNodeName.
+     */
+    getNodeName(node, adapter) {
+        if (node.name && typeof node.name === 'string') {
+            return node.name;
+        }
+        if (node.text && typeof node.text === 'string') {
+            return node.text;
+        }
+        if (node.children) {
+            for (const child of node.children) {
+                const childType = adapter.getNodeType(child);
+                if (childType === 'identifier' || childType === 'property_identifier') {
+                    const name = this.getNodeName(child, adapter);
+                    if (name)
+                        return name;
+                }
+            }
+        }
+        return '';
+    }
     // ---------------------------------------------------------------------------
     // JSON Schema validation (unchanged from original)
     // ---------------------------------------------------------------------------