@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/validation/DataFlowValidator.js

@@ -12,6 +12,7 @@
  * - EVENT_LISTENER: события
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { ValidationError } from '../../errors/GrafemaError.js';
 export class DataFlowValidator extends Plugin {
     get metadata() {
         return {
@@ -26,25 +27,26 @@ export class DataFlowValidator extends Plugin {
     }
     async execute(context) {
         const { graph } = context;
-        console.log('[DataFlowValidator] Starting data flow validation...');
+        const logger = this.log(context);
+        logger.info('Starting data flow validation');
         // Check if graph supports getAllEdges
         if (!graph.getAllEdges) {
-            console.log('[DataFlowValidator] Graph does not support getAllEdges, skipping validation');
+            logger.debug('Graph does not support getAllEdges, skipping validation');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
         }
         // Получаем все переменные
         const allNodes = await graph.getAllNodes();
         const allEdges = await graph.getAllEdges();
         const variables = allNodes.filter(n => n.type === 'VARIABLE_DECLARATION' || n.type === 'CONSTANT');
-        console.log(`[DataFlowValidator] Found ${variables.length} variables to validate`);
-        const issues = [];
+        logger.debug('Variables collected', { count: variables.length });
+        const errors = [];
         const leafTypes = new Set([
             'LITERAL',
-            'EXTERNAL_STDIO',
-            'EXTERNAL_DATABASE',
-            'EXTERNAL_NETWORK',
-            'EXTERNAL_FILESYSTEM',
-            'EVENT_LISTENER',
+            'net:stdio',
+            'db:query',
+            'net:request',
+            'fs:operation',
+            'event:listener',
             'CLASS', // NewExpression - конструкторы классов
             'FUNCTION', // Arrow functions и function expressions
             'METHOD_CALL', // Вызовы методов (промежуточные узлы)
@@ -54,66 +56,69 @@ export class DataFlowValidator extends Plugin {
             // Проверяем наличие ASSIGNED_FROM ребра
             const assignment = allEdges.find(e => e.type === 'ASSIGNED_FROM' && e.src === variable.id);
             if (!assignment) {
-                issues.push({
-                    type: 'MISSING_ASSIGNMENT',
-                    severity: 'WARNING',
-                    message: `Variable "${variable.name}" (${variable.file}:${variable.line}) has no ASSIGNED_FROM edge`,
+                errors.push(new ValidationError(`Variable "${variable.name}" (${variable.file}:${variable.line}) has no ASSIGNED_FROM edge`, 'ERR_MISSING_ASSIGNMENT', {
+                    filePath: variable.file,
+                    lineNumber: variable.line,
+                    phase: 'VALIDATION',
+                    plugin: 'DataFlowValidator',
                     variable: variable.name,
-                    file: variable.file,
-                    line: variable.line
-                });
+                }, undefined, 'warning'));
                 continue;
             }
             // Проверяем что источник существует
             const source = allNodes.find(n => n.id === assignment.dst);
             if (!source) {
-                issues.push({
-                    type: 'BROKEN_REFERENCE',
-                    severity: 'ERROR',
-                    message: `Variable "${variable.name}" references non-existent node ${assignment.dst}`,
+                errors.push(new ValidationError(`Variable "${variable.name}" references non-existent node ${assignment.dst}`, 'ERR_BROKEN_REFERENCE', {
+                    filePath: variable.file,
+                    lineNumber: variable.line,
+                    phase: 'VALIDATION',
+                    plugin: 'DataFlowValidator',
                     variable: variable.name,
-                    file: variable.file,
-                    line: variable.line
-                });
+                    targetNodeId: assignment.dst,
+                }, undefined, 'error'));
                 continue;
             }
             // Проверяем путь до листового узла
             const path = this.findPathToLeaf(variable, allNodes, allEdges, leafTypes);
             if (!path.found) {
-                issues.push({
-                    type: 'NO_LEAF_NODE',
-                    severity: 'WARNING',
-                    message: `Variable "${variable.name}" (${variable.file}:${variable.line}) does not trace to a leaf node. Chain: ${path.chain.join(' -> ')}`,
+                errors.push(new ValidationError(`Variable "${variable.name}" (${variable.file}:${variable.line}) does not trace to a leaf node. Chain: ${path.chain.join(' -> ')}`, 'ERR_NO_LEAF_NODE', {
+                    filePath: variable.file,
+                    lineNumber: variable.line,
+                    phase: 'VALIDATION',
+                    plugin: 'DataFlowValidator',
                     variable: variable.name,
-                    file: variable.file,
-                    line: variable.line,
-                    chain: path.chain
-                });
+                    chain: path.chain,
+                }, undefined, 'warning'));
             }
         }
-        // Группируем issues по типу
+        // Группируем errors по коду
+        const byCode = {};
+        for (const error of errors) {
+            if (!byCode[error.code]) {
+                byCode[error.code] = 0;
+            }
+            byCode[error.code]++;
+        }
         const summary = {
             total: variables.length,
-            validated: variables.length - issues.length,
-            issues: issues.length,
-            byType: {}
+            validated: variables.length - errors.length,
+            issues: errors.length,
+            byType: byCode
         };
-        for (const issue of issues) {
-            if (!summary.byType[issue.type]) {
-                summary.byType[issue.type] = 0;
+        logger.info('Validation complete', { ...summary });
+        // Выводим errors
+        if (errors.length > 0) {
+            logger.warn('Data flow issues found', { count: errors.length });
+            for (const error of errors) {
+                if (error.severity === 'error') {
+                    logger.error(`[${error.code}] ${error.message}`);
+                }
+                else {
+                    logger.warn(`[${error.code}] ${error.message}`);
+                }
             }
-            summary.byType[issue.type]++;
         }
-        console.log('[DataFlowValidator] Summary:', summary);
-        // Выводим issues
-        if (issues.length > 0) {
-            console.log(`[DataFlowValidator] Found ${issues.length} issues:`);
-            for (const issue of issues) {
-                const level = issue.severity === 'ERROR' ? '❌' : '⚠️';
-                console.log(`  ${level} [${issue.type}] ${issue.message}`);
-            }
-        }
-        return createSuccessResult({ nodes: 0, edges: 0 }, { summary, issues });
+        return createSuccessResult({ nodes: 0, edges: 0 }, { summary }, errors);
     }
     /**
      * Находит путь от переменной до листового узла
@@ -129,6 +134,14 @@ export class DataFlowValidator extends Plugin {
         if (leafTypes.has(startNode.type)) {
             return { found: true, chain };
         }
+        // REG-262: Check if variable is used by a method call (incoming USES edge)
+        // If something USES this variable, the variable is not dead
+        const usedByCall = allEdges.find(e => e.type === 'USES' && e.dst === startNode.id);
+        if (usedByCall) {
+            const callNode = allNodes.find(n => n.id === usedByCall.src);
+            const callName = callNode?.name ?? usedByCall.src;
+            return { found: true, chain: [...chain, `(used by ${callName})`] };
+        }
         // Ищем ASSIGNED_FROM ребро
         const assignment = allEdges.find(e => e.type === 'ASSIGNED_FROM' && e.src === startNode.id);
         if (!assignment) {

package/dist/plugins/validation/EvalBanValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EvalBanValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/EvalBanValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoChF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAyG7D"}
+{"version":3,"file":"EvalBanValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/EvalBanValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoChF,qBAAa,gBAAiB,SAAQ,MAAM;IAC1C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA0G7D"}

package/dist/plugins/validation/EvalBanValidator.js

@@ -31,13 +31,14 @@ export class EvalBanValidator extends Plugin {
     }
     async execute(context) {
         const { graph } = context;
-        console.log('[EvalBanValidator] Checking for eval/Function usage...');
+        const logger = this.log(context);
+        logger.info('Starting eval/Function usage validation');
         const startTime = Date.now();
         const issues = [];
-        // ОПТИМИЗАЦИЯ: вместо Datalog (медленный full scan), используем прямые graph queries
-        // Datalog зависает на больших графах из-за отсутствия индексов
-        // 1. Прямой вызов eval("code") - ищем все CALL ноды с name="eval"
-        console.log('[EvalBanValidator] Searching for eval() calls...');
+        // OPTIMIZATION: use direct graph queries instead of Datalog (slow full scan)
+        // Datalog hangs on large graphs due to lack of indexes
+        // 1. Direct eval("code") call - find all CALL nodes with name="eval"
+        logger.debug('Searching for eval() calls');
         const evalStart = Date.now();
         let evalCount = 0;
         for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
@@ -53,9 +54,9 @@ export class EvalBanValidator extends Plugin {
                 });
             }
         }
-        console.log(`[EvalBanValidator] eval() search took ${Date.now() - evalStart}ms, found ${evalCount} violations`);
-        // 2. Вызов Function("code") или new Function("code")
-        console.log('[EvalBanValidator] Searching for Function() calls...');
+        logger.debug('eval() search complete', { timeMs: Date.now() - evalStart, count: evalCount });
+        // 2. Function("code") or new Function("code") call
+        logger.debug('Searching for Function() calls');
         const funcStart = Date.now();
         let funcCount = 0;
         for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
@@ -71,10 +72,10 @@ export class EvalBanValidator extends Plugin {
                 });
             }
         }
-        console.log(`[EvalBanValidator] Function() search took ${Date.now() - funcStart}ms, found ${funcCount} violations`);
+        logger.debug('Function() search complete', { timeMs: Date.now() - funcStart, count: funcCount });
         // 3. Method call: window.eval, globalThis.eval, this.eval
         // Note: METHOD_CALL was merged into CALL - method calls have 'method' attribute
-        console.log('[EvalBanValidator] Searching for method eval() calls...');
+        logger.debug('Searching for method eval() calls');
         const methodStart = Date.now();
         let methodCount = 0;
         for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
@@ -94,9 +95,9 @@ export class EvalBanValidator extends Plugin {
                 });
             }
         }
-        console.log(`[EvalBanValidator] method eval() search took ${Date.now() - methodStart}ms, found ${methodCount} violations`);
+        logger.debug('Method eval() search complete', { timeMs: Date.now() - methodStart, count: methodCount });
         // 4. Aliased eval - SKIP for now (complex Datalog query causes OOM)
-        console.log('[EvalBanValidator] Skipping aliased eval detection (requires optimized implementation)');
+        logger.debug('Skipping aliased eval detection', { reason: 'requires optimized implementation' });
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
         const summary = {
             evalCalls: evalCount,
@@ -106,15 +107,15 @@ export class EvalBanValidator extends Plugin {
             totalViolations: issues.length,
             timeSeconds: totalTime
         };
-        console.log('[EvalBanValidator] Summary:', summary);
+        logger.info('Validation summary', { ...summary });
         if (issues.length > 0) {
-            console.log('[EvalBanValidator] ❌ Security violations found:');
+            logger.info('Security violations found', { count: issues.length });
             for (const issue of issues) {
-                console.log(`  🚫 ${issue.message}`);
+                logger.warn('Violation', { message: issue.message, type: issue.type, file: issue.file, line: issue.line });
             }
         }
         else {
-            console.log('[EvalBanValidator] ✅ No eval/Function usage detected');
+            logger.info('Validation passed: no eval/Function usage detected');
         }
         return createSuccessResult({ nodes: 0, edges: 0 }, // created - validator doesn't create nodes/edges
         { summary, issues } // metadata

package/dist/plugins/validation/GraphConnectivityValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphConnectivityValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/GraphConnectivityValidator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAyChF,qBAAa,0BAA2B,SAAQ,MAAM;IACpD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA4I7D"}
+{"version":3,"file":"GraphConnectivityValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/GraphConnectivityValidator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AA0ChF,qBAAa,0BAA2B,SAAQ,MAAM;IACpD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CA6K7D"}

package/dist/plugins/validation/GraphConnectivityValidator.js

@@ -3,6 +3,7 @@
  * Находит "островки" - узлы которые не имеют путей до SERVICE/MODULE
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { ValidationError } from '../../errors/GrafemaError.js';
 export class GraphConnectivityValidator extends Plugin {
     get metadata() {
         return {
@@ -17,27 +18,28 @@ export class GraphConnectivityValidator extends Plugin {
     }
     async execute(context) {
         const { graph, manifest } = context;
+        const logger = this.log(context);
         const manifestWithValidation = manifest;
-        console.log('[GraphConnectivityValidator] Starting connectivity validation...');
+        logger.info('Starting connectivity validation');
         // Получаем все узлы
         const allNodes = await graph.getAllNodes();
-        console.log(`[GraphConnectivityValidator] Total nodes: ${allNodes.length}`);
+        logger.debug('Nodes collected', { totalNodes: allNodes.length });
         // Находим корневые узлы (SERVICE, MODULE)
         const rootTypes = ['SERVICE', 'MODULE', 'PROJECT'];
         const rootNodes = allNodes.filter(n => rootTypes.includes(n.type));
-        console.log(`[GraphConnectivityValidator] Root nodes: ${rootNodes.length}`);
+        logger.debug('Root nodes found', { rootCount: rootNodes.length });
         if (rootNodes.length === 0) {
-            console.warn('[GraphConnectivityValidator] No root nodes found!');
+            logger.warn('No root nodes found');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No root nodes' });
         }
         // Check if graph supports getAllEdges
         if (!graph.getAllEdges) {
-            console.log('[GraphConnectivityValidator] Graph does not support getAllEdges, skipping validation');
+            logger.debug('Graph does not support getAllEdges, skipping validation');
             return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No getAllEdges support' });
         }
         // Собираем все ребра
         const allEdges = await graph.getAllEdges();
-        console.log(`[GraphConnectivityValidator] Total edges: ${allEdges.length}`);
+        logger.debug('Edges collected', { totalEdges: allEdges.length });
         // Строим карты смежности (обе направления)
         const adjacencyOut = new Map(); // nodeId -> [targetIds]
         const adjacencyIn = new Map(); // nodeId -> [sourceIds]
@@ -72,14 +74,12 @@ export class GraphConnectivityValidator extends Plugin {
         }
         // Находим недостижимые узлы
         const unreachable = allNodes.filter(n => !reachable.has(n.id));
+        const errors = [];
         if (unreachable.length > 0) {
-            // ЯРКОЕ ПРЕДУПРЕЖДЕНИЕ В КОНСОЛИ
-            console.error('\n' + '='.repeat(80));
-            console.error('⚠️  GRAPH VALIDATION ERROR: DISCONNECTED NODES FOUND');
-            console.error('='.repeat(80));
-            console.error(`Found ${unreachable.length} unreachable nodes (${((unreachable.length / allNodes.length) * 100).toFixed(1)}% of total)`);
-            console.error(`These nodes are not connected to the main graph (SERVICE/MODULE/PROJECT level)`);
-            console.error('');
+            const percentage = ((unreachable.length / allNodes.length) * 100).toFixed(1);
+            logger.error('GRAPH VALIDATION ERROR: DISCONNECTED NODES FOUND');
+            logger.error(`Found ${unreachable.length} unreachable nodes (${percentage}% of total)`);
+            logger.error('These nodes are not connected to the main graph (SERVICE/MODULE/PROJECT level)');
             // Группируем по типам для читаемости
             const byType = {};
             for (const node of unreachable) {
@@ -88,25 +88,23 @@ export class GraphConnectivityValidator extends Plugin {
                 byType[node.type].push(node);
             }
             for (const [type, nodes] of Object.entries(byType)) {
-                console.error(`  ${type}: ${nodes.length} nodes`);
+                logger.error(`${type}: ${nodes.length} nodes`);
                 // Показываем первые 5 для каждого типа
                 for (const node of nodes.slice(0, 5)) {
-                    console.error(`    - ${node.name || node.id}`);
+                    logger.debug(`  - ${node.name || node.id}`);
                     // Показываем связи этого узла
                     const out = adjacencyOut.get(node.id) || [];
                     const incoming = adjacencyIn.get(node.id) || [];
                     if (out.length > 0 || incoming.length > 0) {
-                        console.error(`      Edges: ${incoming.length} incoming, ${out.length} outgoing`);
+                        logger.debug(`    Edges: ${incoming.length} incoming, ${out.length} outgoing`);
                     }
                 }
                 if (nodes.length > 5) {
-                    console.error(`    ... and ${nodes.length - 5} more`);
+                    logger.debug(`  ... and ${nodes.length - 5} more`);
                 }
             }
-            console.error('');
-            console.error('💡 ACTION REQUIRED: Fix analysis plugins to ensure all nodes are connected');
-            console.error('   Anonymous functions, callbacks, and method calls should be linked to parent nodes');
-            console.error('='.repeat(80) + '\n');
+            logger.error('ACTION REQUIRED: Fix analysis plugins to ensure all nodes are connected');
+            logger.error('Anonymous functions, callbacks, and method calls should be linked to parent nodes');
             // Сохраняем информацию в manifest для дальнейшего использования
             if (!manifestWithValidation.validation)
                 manifestWithValidation.validation = {};
@@ -120,16 +118,38 @@ export class GraphConnectivityValidator extends Plugin {
             manifestWithValidation.validation.reachableNodes = reachable.size;
             manifestWithValidation.validation.unreachableCount = unreachable.length;
             manifestWithValidation.validation.unreachableByType = Object.fromEntries(Object.entries(byType).map(([type, nodes]) => [type, nodes.length]));
+            // Create summary error for disconnected nodes
+            errors.push(new ValidationError(`Found ${unreachable.length} unreachable nodes (${percentage}% of total)`, 'ERR_DISCONNECTED_NODES', {
+                phase: 'VALIDATION',
+                plugin: 'GraphConnectivityValidator',
+                totalNodes: allNodes.length,
+                reachableNodes: reachable.size,
+                unreachableCount: unreachable.length,
+                unreachableByType: Object.fromEntries(Object.entries(byType).map(([type, nodes]) => [type, nodes.length])),
+            }, 'Fix analysis plugins to ensure all nodes are connected'));
+            // Create individual errors for each disconnected node (limit to 50)
+            const maxIndividualErrors = 50;
+            for (const node of unreachable.slice(0, maxIndividualErrors)) {
+                errors.push(new ValidationError(`Node "${node.name || node.id}" (type: ${node.type}) is not connected to the main graph`, 'ERR_DISCONNECTED_NODE', {
+                    filePath: node.file,
+                    lineNumber: node.line,
+                    phase: 'VALIDATION',
+                    plugin: 'GraphConnectivityValidator',
+                    nodeId: node.id,
+                    nodeType: node.type,
+                    nodeName: node.name,
+                }));
+            }
         }
         else {
-            console.log('[GraphConnectivityValidator] ✅ All nodes are reachable from root nodes');
+            logger.info('All nodes are reachable from root nodes');
             if (!manifestWithValidation.validation)
                 manifestWithValidation.validation = {};
             manifestWithValidation.validation.hasErrors = false;
             manifestWithValidation.validation.totalNodes = allNodes.length;
             manifestWithValidation.validation.reachableNodes = reachable.size;
         }
-        console.log(`[GraphConnectivityValidator] Validation complete: ${reachable.size}/${allNodes.length} nodes reachable`);
-        return createSuccessResult({ nodes: 0, edges: 0 }, { totalNodes: allNodes.length, reachableNodes: reachable.size });
+        logger.info('Validation complete', { reachable: reachable.size, total: allNodes.length });
+        return createSuccessResult({ nodes: 0, edges: 0 }, { totalNodes: allNodes.length, reachableNodes: reachable.size }, errors);
     }
 }

package/dist/plugins/validation/NodeCreationValidator.d.ts

@@ -0,0 +1,85 @@
+/**
+ * NodeCreationValidator - validates that nodes are created through NodeFactory
+ *
+ * GUARANTEE: All nodes passed to graph.addNode() or graph.addNodes() must be
+ * created through NodeFactory methods, not constructed inline.
+ *
+ * This validator uses the data flow tracking (HAS_PROPERTY, HAS_ELEMENT, FLOWS_INTO edges)
+ * to trace object literals back to their source and verify they come from
+ * NodeFactory calls.
+ *
+ * FLOWS_INTO traversal: When an array variable is passed to addNodes(), we check:
+ * 1. Static array contents via HAS_ELEMENT edges
+ * 2. Dynamic array contents via FLOWS_INTO edges (from push, unshift, splice, indexed assignment)
+ *
+ * DATALOG RULES (conceptual):
+ *
+ * % Find all calls to addNodes (batch)
+ * add_nodes_call(Call) :-
+ *     node(Call, "CALL"),
+ *     attr(Call, "name", "addNodes").
+ *
+ * % Find array argument passed to addNodes (arg 0)
+ * add_nodes_array(Call, Arr) :-
+ *     add_nodes_call(Call),
+ *     edge(Call, Arr, "PASSES_ARGUMENT"),
+ *     node(Arr, "ARRAY_LITERAL").
+ *
+ * % Find objects inside the array (static elements)
+ * add_nodes_object(Call, Obj) :-
+ *     add_nodes_array(Call, Arr),
+ *     edge(Arr, Obj, "HAS_ELEMENT"),
+ *     node(Obj, "OBJECT_LITERAL").
+ *
+ * % Find objects pushed/unshifted/spliced into array (dynamic elements)
+ * add_nodes_object(Call, Obj) :-
+ *     add_nodes_call(Call),
+ *     edge(Call, ArrVar, "PASSES_ARGUMENT"),
+ *     node(ArrVar, "VARIABLE"),
+ *     incoming(ArrVar, Obj, "FLOWS_INTO"),  % value --FLOWS_INTO--> array
+ *     node(Obj, "OBJECT_LITERAL").
+ *
+ * % Object created via NodeFactory
+ * from_node_factory(Obj) :-
+ *     incoming(Obj, Creator, "ASSIGNED_FROM"),
+ *     node(Creator, "CALL"),
+ *     attr(Creator, "object", "NodeFactory").
+ *
+ * % Violation: object in addNodes not from NodeFactory
+ * violation_batch(Call, Obj) :-
+ *     add_nodes_object(Call, Obj),
+ *     \+ from_node_factory(Obj).
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class NodeCreationValidator extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Validate a single addNode(node) call
+     */
+    private validateAddNodeCall;
+    /**
+     * Validate addNodes([...]) call
+     * Also checks for objects that flow into arrays via FLOWS_INTO edges
+     */
+    private validateAddNodesCall;
+    /**
+     * Get all nodes that flow INTO an array variable via FLOWS_INTO edges
+     * These are objects/values that were pushed, unshifted, spliced, or assigned to the array
+     *
+     * Edge direction: value --FLOWS_INTO--> array
+     * So we look for INCOMING edges where dst === arrayNodeId
+     */
+    private getArrayContents;
+    /**
+     * Check if a node is created from NodeFactory
+     * Traces ASSIGNED_FROM edges to find the source call
+     */
+    private isFromNodeFactory;
+    /**
+     * Trace a variable back to its source node (through ASSIGNED_FROM edges)
+     */
+    private traceVariableSource;
+}
+//# sourceMappingURL=NodeCreationValidator.d.ts.map

package/dist/plugins/validation/NodeCreationValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeCreationValidator.d.ts","sourceRoot":"","sources":["../../../src/plugins/validation/NodeCreationValidator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAiDhF,qBAAa,qBAAsB,SAAQ,MAAM;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAgH5D;;OAEG;YACW,mBAAmB;IA0DjC;;;OAGG;YACW,oBAAoB;IAqJlC;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAwCzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAmC5B"}