@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/SystemDbAnalyzer.js

@@ -0,0 +1,211 @@
+/**
+ * SystemDbAnalyzer - специализированный плагин для анализа system_db API
+ *
+ * Понимает семантику system_db и добавляет ноды для сайд-эффектов:
+ * - system_db.use(view, server) -> регистрирует VIEW через get_view()
+ * - system_db.subscribe(servers) -> проверяет все зарегистрированные VIEW'ы
+ * - local.use(view) -> регистрирует VIEW в get_hosts()
+ *
+ * Добавляет специальные ноды:
+ * - SYSTEM_DB_VIEW_REGISTRATION - регистрация VIEW'а
+ * - SYSTEM_DB_SUBSCRIPTION - подписка на сервер
+ */
+import { readFileSync } from 'fs';
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const traverse = traverseModule.default || traverseModule;
+export class SystemDbAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'SystemDbAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 85, // Run after JSASTAnalyzer
+            creates: {
+                nodes: ['SYSTEM_DB_VIEW_REGISTRATION', 'SYSTEM_DB_SUBSCRIPTION'],
+                edges: ['REGISTERS_VIEW', 'CHECKS_VIEWS']
+            }
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            let nodesCreated = 0;
+            let edgesCreated = 0;
+            // Get all MODULE nodes
+            const modules = await this.getModules(graph);
+            console.log(`[SystemDbAnalyzer] Analyzing ${modules.length} modules for system_db patterns...\n`);
+            for (const module of modules) {
+                if (!module.file)
+                    continue;
+                try {
+                    const code = readFileSync(module.file, 'utf-8');
+                    const ast = parse(code, {
+                        sourceType: 'module',
+                        plugins: ['jsx', 'typescript'],
+                        errorRecovery: true
+                    });
+                    const registrations = [];
+                    const subscriptions = [];
+                    traverse(ast, {
+                        CallExpression: (path) => {
+                            const { node } = path;
+                            // system_db.use(...)
+                            if (node.callee.type === 'MemberExpression' &&
+                                node.callee.object.name === 'system_db' &&
+                                node.callee.property.name === 'use') {
+                                const viewName = this.extractLiteral(node.arguments[0]);
+                                const serverName = this.extractLiteral(node.arguments[1]);
+                                if (viewName) {
+                                    registrations.push({
+                                        type: 'system_db.use',
+                                        viewName,
+                                        serverName: serverName || 'default',
+                                        line: node.loc?.start.line || 0,
+                                        column: node.loc?.start.column || 0
+                                    });
+                                }
+                            }
+                            // system_db.subscribe(...)
+                            if (node.callee.type === 'MemberExpression' &&
+                                node.callee.object.name === 'system_db' &&
+                                node.callee.property.name === 'subscribe') {
+                                const servers = this.extractServerList(node.arguments[0]);
+                                subscriptions.push({
+                                    type: 'system_db.subscribe',
+                                    servers,
+                                    line: node.loc?.start.line || 0,
+                                    column: node.loc?.start.column || 0
+                                });
+                            }
+                            // local.use('view_name') - косвенная регистрация через get_hosts()
+                            if (node.callee.type === 'MemberExpression' &&
+                                node.callee.object.name === 'local' &&
+                                node.callee.property.name === 'use') {
+                                const viewName = this.extractLiteral(node.arguments[0]);
+                                if (viewName) {
+                                    registrations.push({
+                                        type: 'local.use',
+                                        viewName,
+                                        serverName: 'inferred_from_hosts',
+                                        line: node.loc?.start.line || 0,
+                                        column: node.loc?.start.column || 0
+                                    });
+                                }
+                            }
+                            // get_view(name, server) - внутренний API
+                            if (node.callee.type === 'Identifier' &&
+                                node.callee.name === 'get_view') {
+                                const viewName = this.extractLiteral(node.arguments[0]);
+                                const serverName = this.extractLiteral(node.arguments[1]);
+                                if (viewName) {
+                                    registrations.push({
+                                        type: 'get_view',
+                                        viewName,
+                                        serverName: serverName || 'default',
+                                        line: node.loc?.start.line || 0,
+                                        column: node.loc?.start.column || 0
+                                    });
+                                }
+                            }
+                        }
+                    });
+                    // Create SYSTEM_DB_VIEW_REGISTRATION nodes
+                    for (const reg of registrations) {
+                        const nodeId = `${module.file}:SYSTEM_DB_VIEW_REGISTRATION:${reg.viewName}:${reg.line}`;
+                        console.log(`   📌 Found: ${reg.type}('${reg.viewName}', '${reg.serverName}') at ${module.file.split('/').pop()}:${reg.line}`);
+                        await graph.addNode({
+                            id: nodeId,
+                            type: 'SYSTEM_DB_VIEW_REGISTRATION',
+                            name: `${reg.type}('${reg.viewName}', '${reg.serverName}')`,
+                            file: module.file,
+                            line: reg.line,
+                            column: reg.column,
+                            viewName: reg.viewName,
+                            serverName: reg.serverName,
+                            callType: reg.type
+                        });
+                        nodesCreated++;
+                        // Link MODULE -> REGISTERS_VIEW -> REGISTRATION
+                        await graph.addEdge({
+                            type: 'REGISTERS_VIEW',
+                            src: module.id,
+                            dst: nodeId
+                        });
+                        edgesCreated++;
+                    }
+                    // Create SYSTEM_DB_SUBSCRIPTION nodes
+                    for (const sub of subscriptions) {
+                        const nodeId = `${module.file}:SYSTEM_DB_SUBSCRIPTION:${sub.line}`;
+                        await graph.addNode({
+                            id: nodeId,
+                            type: 'SYSTEM_DB_SUBSCRIPTION',
+                            name: `subscribe([${sub.servers.join(', ')}])`,
+                            file: module.file,
+                            line: sub.line,
+                            column: sub.column,
+                            servers: sub.servers
+                        });
+                        nodesCreated++;
+                        // Link MODULE -> CHECKS_VIEWS -> SUBSCRIPTION
+                        await graph.addEdge({
+                            type: 'CHECKS_VIEWS',
+                            src: module.id,
+                            dst: nodeId
+                        });
+                        edgesCreated++;
+                    }
+                }
+                catch (err) {
+                    // Skip files that can't be parsed
+                    if (err.code !== 'ENOENT') {
+                        console.error(`   ⚠️  Failed to analyze ${module.file}: ${err.message}`);
+                    }
+                }
+            }
+            console.log(`[SystemDbAnalyzer] Created ${nodesCreated} system_db nodes, ${edgesCreated} edges\n`);
+            return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modules.length });
+        }
+        catch (error) {
+            console.error(`[SystemDbAnalyzer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    /**
+     * Extract literal value from AST node
+     */
+    extractLiteral(node) {
+        if (!node)
+            return null;
+        if (node.type === 'StringLiteral') {
+            return node.value;
+        }
+        if (node.type === 'TemplateLiteral') {
+            const tl = node;
+            if (tl.quasis.length === 1) {
+                return tl.quasis[0].value.cooked;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract server list from subscribe() argument
+     */
+    extractServerList(node) {
+        if (!node)
+            return ['default'];
+        // String literal: subscribe('lum-unblocker')
+        if (node.type === 'StringLiteral') {
+            return [node.value];
+        }
+        // Array: subscribe(['lum', 'lum-views'])
+        if (node.type === 'ArrayExpression') {
+            const arr = node;
+            return arr.elements
+                .map(el => (el ? this.extractLiteral(el) : null))
+                .filter((s) => s !== null);
+        }
+        return ['unknown'];
+    }
+}

package/dist/plugins/analysis/ast/ConditionParser.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ConditionParser - парсит условия if/switch и извлекает constraints
+ *
+ * Поддерживаемые паттерны:
+ * - x === "value"        → { variable: "x", operator: "===", value: "value" }
+ * - x !== "value"        → { variable: "x", operator: "!==", value: "value", excludes: true }
+ * - x === "a" || x === "b" → { variable: "x", operator: "in", values: ["a", "b"] }
+ * - x === "a" && y === "b" → [{ variable: "x", ... }, { variable: "y", ... }]
+ */
+import type * as t from '@babel/types';
+/**
+ * Constraint operator types
+ */
+type ConstraintOperator = '===' | '!==' | 'in' | 'not_in' | 'truthy' | 'falsy';
+/**
+ * Simple constraint
+ */
+export interface SimpleConstraint {
+    variable: string;
+    operator: ConstraintOperator;
+    value?: unknown;
+    values?: unknown[];
+    excludes?: boolean;
+    negated?: boolean;
+}
+/**
+ * Compound constraint (OR/AND groups)
+ */
+export interface CompoundConstraint {
+    type: 'or' | 'and';
+    constraints: Constraint[];
+}
+/**
+ * Combined constraint type
+ */
+export type Constraint = SimpleConstraint | CompoundConstraint;
+export declare class ConditionParser {
+    /**
+     * Парсит AST условия и возвращает массив constraints
+     * @param testNode - AST нода условия (ifNode.test)
+     * @returns constraints
+     */
+    static parse(testNode: t.Node | null | undefined): Constraint[];
+    /**
+     * Рекурсивно парсит ноду условия
+     * @param node - AST нода
+     * @param constraints - массив для накопления constraints
+     * @param negated - инвертировано ли условие (для else)
+     */
+    private static _parseNode;
+    /**
+     * Парсит BinaryExpression (===, !==, ==, !=)
+     */
+    private static _parseBinaryExpression;
+    /**
+     * Парсит LogicalExpression (&&, ||)
+     */
+    private static _parseLogicalExpression;
+    /**
+     * Пытается объединить OR constraints для одной переменной
+     * x === "a" || x === "b" → { variable: x, operator: "in", values: ["a", "b"] }
+     */
+    private static _tryMergeOrConstraints;
+    /**
+     * Проверяет является ли нода литеральным значением
+     */
+    private static _isLiteralValue;
+    /**
+     * Извлекает значение из литеральной ноды
+     */
+    private static _getLiteralValue;
+    /**
+     * Получает имя MemberExpression как строку
+     * obj.prop → "obj.prop"
+     */
+    private static _getMemberExpressionName;
+    /**
+     * Создаёт negated версию constraints для else-блока
+     * @param constraints - оригинальные constraints
+     * @returns negated constraints
+     */
+    static negate(constraints: Constraint[]): Constraint[];
+}
+export default ConditionParser;
+//# sourceMappingURL=ConditionParser.d.ts.map

package/dist/plugins/analysis/ast/ConditionParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionParser.d.ts","sourceRoot":"","sources":["../../../../src/plugins/analysis/ast/ConditionParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAC;AAEvC;;GAEG;AACH,KAAK,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,IAAI,GAAG,KAAK,CAAC;IACnB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;AAS/D,qBAAa,eAAe;IAC1B;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,EAAE;IAQ/D;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IA+CzB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IA6CrC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA8BtC;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAoBrC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAY9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAqB/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,wBAAwB;IA4BvC;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE;CAiCvD;AAED,eAAe,eAAe,CAAC"}

package/dist/plugins/analysis/ast/ConditionParser.js

@@ -0,0 +1,277 @@
+/**
+ * ConditionParser - парсит условия if/switch и извлекает constraints
+ *
+ * Поддерживаемые паттерны:
+ * - x === "value"        → { variable: "x", operator: "===", value: "value" }
+ * - x !== "value"        → { variable: "x", operator: "!==", value: "value", excludes: true }
+ * - x === "a" || x === "b" → { variable: "x", operator: "in", values: ["a", "b"] }
+ * - x === "a" && y === "b" → [{ variable: "x", ... }, { variable: "y", ... }]
+ */
+/**
+ * Type guard for compound constraints
+ */
+function isCompoundConstraint(c) {
+    return 'type' in c && (c.type === 'or' || c.type === 'and');
+}
+export class ConditionParser {
+    /**
+     * Парсит AST условия и возвращает массив constraints
+     * @param testNode - AST нода условия (ifNode.test)
+     * @returns constraints
+     */
+    static parse(testNode) {
+        if (!testNode)
+            return [];
+        const constraints = [];
+        this._parseNode(testNode, constraints, false);
+        return constraints;
+    }
+    /**
+     * Рекурсивно парсит ноду условия
+     * @param node - AST нода
+     * @param constraints - массив для накопления constraints
+     * @param negated - инвертировано ли условие (для else)
+     */
+    static _parseNode(node, constraints, negated) {
+        if (!node)
+            return;
+        switch (node.type) {
+            case 'BinaryExpression':
+                this._parseBinaryExpression(node, constraints, negated);
+                break;
+            case 'LogicalExpression':
+                this._parseLogicalExpression(node, constraints, negated);
+                break;
+            case 'UnaryExpression': {
+                const unaryNode = node;
+                if (unaryNode.operator === '!') {
+                    // !condition → инвертируем
+                    this._parseNode(unaryNode.argument, constraints, !negated);
+                }
+                break;
+            }
+            case 'Identifier': {
+                const identNode = node;
+                // if (x) → x is truthy
+                constraints.push({
+                    variable: identNode.name,
+                    operator: 'truthy',
+                    negated
+                });
+                break;
+            }
+            case 'MemberExpression': {
+                // if (obj.prop) → obj.prop is truthy
+                const memberName = this._getMemberExpressionName(node);
+                if (memberName) {
+                    constraints.push({
+                        variable: memberName,
+                        operator: 'truthy',
+                        negated
+                    });
+                }
+                break;
+            }
+        }
+    }
+    /**
+     * Парсит BinaryExpression (===, !==, ==, !=)
+     */
+    static _parseBinaryExpression(node, constraints, negated) {
+        const { operator, left, right } = node;
+        // Поддерживаемые операторы
+        if (!['===', '!==', '==', '!='].includes(operator)) {
+            return;
+        }
+        // Определяем переменную и значение
+        let variable = null;
+        let value = null;
+        // x === "value" или "value" === x
+        if (left.type === 'Identifier' && this._isLiteralValue(right)) {
+            variable = left.name;
+            value = this._getLiteralValue(right);
+        }
+        else if (right.type === 'Identifier' && this._isLiteralValue(left)) {
+            variable = right.name;
+            value = this._getLiteralValue(left);
+        }
+        // obj.prop === "value"
+        else if (left.type === 'MemberExpression' && this._isLiteralValue(right)) {
+            variable = this._getMemberExpressionName(left);
+            value = this._getLiteralValue(right);
+        }
+        else if (right.type === 'MemberExpression' && this._isLiteralValue(left)) {
+            variable = this._getMemberExpressionName(right);
+            value = this._getLiteralValue(left);
+        }
+        if (variable === null || value === null) {
+            return;
+        }
+        // Определяем тип constraint
+        const isNegation = operator === '!==' || operator === '!=';
+        const effectiveNegated = negated ? !isNegation : isNegation;
+        constraints.push({
+            variable,
+            operator: effectiveNegated ? '!==' : '===',
+            value,
+            excludes: effectiveNegated
+        });
+    }
+    /**
+     * Парсит LogicalExpression (&&, ||)
+     */
+    static _parseLogicalExpression(node, constraints, negated) {
+        const { operator, left, right } = node;
+        if (operator === '||') {
+            // OR: проверяем можно ли объединить в одну constraint
+            // x === "a" || x === "b" → { variable: x, values: ["a", "b"] }
+            const leftConstraints = [];
+            const rightConstraints = [];
+            this._parseNode(left, leftConstraints, negated);
+            this._parseNode(right, rightConstraints, negated);
+            // Пытаемся объединить constraints для одной переменной
+            const merged = this._tryMergeOrConstraints(leftConstraints, rightConstraints);
+            if (merged) {
+                constraints.push(merged);
+            }
+            else {
+                // Не удалось объединить - добавляем как OR группу
+                constraints.push({
+                    type: 'or',
+                    constraints: [...leftConstraints, ...rightConstraints]
+                });
+            }
+        }
+        else if (operator === '&&') {
+            // AND: обе части должны быть true
+            this._parseNode(left, constraints, negated);
+            this._parseNode(right, constraints, negated);
+        }
+    }
+    /**
+     * Пытается объединить OR constraints для одной переменной
+     * x === "a" || x === "b" → { variable: x, operator: "in", values: ["a", "b"] }
+     */
+    static _tryMergeOrConstraints(left, right) {
+        // Проверяем что обе части - простые equality constraints для одной переменной
+        if (left.length !== 1 || right.length !== 1)
+            return null;
+        const l = left[0];
+        const r = right[0];
+        // Type guards for simple constraints
+        if (isCompoundConstraint(l) || isCompoundConstraint(r))
+            return null;
+        if (l.variable !== r.variable)
+            return null;
+        if (l.operator !== '===' || r.operator !== '===')
+            return null;
+        return {
+            variable: l.variable,
+            operator: 'in',
+            values: [l.value, r.value]
+        };
+    }
+    /**
+     * Проверяет является ли нода литеральным значением
+     */
+    static _isLiteralValue(node) {
+        if (!node)
+            return false;
+        return (node.type === 'StringLiteral' ||
+            node.type === 'NumericLiteral' ||
+            node.type === 'BooleanLiteral' ||
+            node.type === 'NullLiteral' ||
+            node.type === 'Literal' // для некоторых парсеров (ESTree)
+        );
+    }
+    /**
+     * Извлекает значение из литеральной ноды
+     */
+    static _getLiteralValue(node) {
+        if (!node)
+            return null;
+        switch (node.type) {
+            case 'StringLiteral':
+                return node.value;
+            case 'NumericLiteral':
+                return node.value;
+            case 'BooleanLiteral':
+                return node.value;
+            case 'NullLiteral':
+                return null;
+            default:
+                // Handle ESTree 'Literal' type
+                if (node.type === 'Literal') {
+                    return node.value;
+                }
+                return null;
+        }
+    }
+    /**
+     * Получает имя MemberExpression как строку
+     * obj.prop → "obj.prop"
+     */
+    static _getMemberExpressionName(node) {
+        if (node.type !== 'MemberExpression')
+            return null;
+        const parts = [];
+        let current = node;
+        while (current.type === 'MemberExpression') {
+            const memberNode = current;
+            if (memberNode.computed) {
+                // obj[x] - не можем статически определить
+                return null;
+            }
+            if (memberNode.property.type === 'Identifier') {
+                parts.unshift(memberNode.property.name);
+            }
+            else {
+                return null;
+            }
+            current = memberNode.object;
+        }
+        if (current.type === 'Identifier') {
+            parts.unshift(current.name);
+            return parts.join('.');
+        }
+        return null;
+    }
+    /**
+     * Создаёт negated версию constraints для else-блока
+     * @param constraints - оригинальные constraints
+     * @returns negated constraints
+     */
+    static negate(constraints) {
+        return constraints.map(c => {
+            if (isCompoundConstraint(c)) {
+                if (c.type === 'or') {
+                    // De Morgan: !(A || B) = !A && !B
+                    return {
+                        type: 'and',
+                        constraints: this.negate(c.constraints)
+                    };
+                }
+                else {
+                    // De Morgan: !(A && B) = !A || !B
+                    return {
+                        type: 'or',
+                        constraints: this.negate(c.constraints)
+                    };
+                }
+            }
+            // Инвертируем operator
+            const negatedOp = c.operator === '===' ? '!==' :
+                c.operator === '!==' ? '===' :
+                    c.operator === 'in' ? 'not_in' :
+                        c.operator === 'truthy' ? 'falsy' :
+                            c.operator;
+            return {
+                ...c,
+                operator: negatedOp,
+                excludes: !c.excludes,
+                negated: !c.negated
+            };
+        });
+    }
+}
+export default ConditionParser;

package/dist/plugins/analysis/ast/ExpressionEvaluator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ExpressionEvaluator - utilities for evaluating AST expressions
+ */
+import type { Node } from '@babel/types';
+export type LiteralValue = string | number | boolean | null | undefined | LiteralValue[] | {
+    [key: string]: LiteralValue;
+};
+export declare class ExpressionEvaluator {
+    /**
+     * Extract literal value from AST node
+     * Returns null if not a literal
+     */
+    static extractLiteralValue(node: Node | null | undefined): LiteralValue | null;
+}
+//# sourceMappingURL=ExpressionEvaluator.d.ts.map

package/dist/plugins/analysis/ast/ExpressionEvaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionEvaluator.d.ts","sourceRoot":"","sources":["../../../../src/plugins/analysis/ast/ExpressionEvaluator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EACV,IAAI,EAUL,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAE3H,qBAAa,mBAAmB;IAC9B;;;OAGG;IACH,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI;CA6F/E"}