@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

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;AAyChF,qBAAa,0BAA2B,SAAQ,MAAM;IACpD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAwI7D"}

package/dist/plugins/validation/GraphConnectivityValidator.js

@@ -17,27 +17,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]
@@ -73,13 +74,10 @@ export class GraphConnectivityValidator extends Plugin {
         // Находим недостижимые узлы
         const unreachable = allNodes.filter(n => !reachable.has(n.id));
         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 +86,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 = {};
@@ -122,14 +118,14 @@ export class GraphConnectivityValidator extends Plugin {
             manifestWithValidation.validation.unreachableByType = Object.fromEntries(Object.entries(byType).map(([type, nodes]) => [type, nodes.length]));
         }
         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`);
+        logger.info('Validation complete', { reachable: reachable.size, total: allNodes.length });
         return createSuccessResult({ nodes: 0, edges: 0 }, { totalNodes: allNodes.length, reachableNodes: reachable.size });
     }
 }

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"}