@grafema/core 0.1.0-alpha.1

package/dist/plugins/analysis/RustAnalyzer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * RustAnalyzer - plugin for analyzing Rust source files
+ * Uses syn parser via NAPI to extract functions, structs, impl blocks, traits
+ * Detects #[napi] attributes for FFI linking
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class RustAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private processParseResult;
+}
+//# sourceMappingURL=RustAnalyzer.d.ts.map

package/dist/plugins/analysis/RustAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RustAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/RustAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAsJhF,qBAAa,YAAa,SAAQ,MAAM;IACtC,IAAI,QAAQ,IAAI,cAAc,CAkB7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA4E9C,kBAAkB;CAsLjC"}

package/dist/plugins/analysis/RustAnalyzer.js

@@ -0,0 +1,259 @@
+/**
+ * RustAnalyzer - plugin for analyzing Rust source files
+ * Uses syn parser via NAPI to extract functions, structs, impl blocks, traits
+ * Detects #[napi] attributes for FFI linking
+ */
+import { readFileSync } from 'fs';
+import { Plugin, createSuccessResult } from '../Plugin.js';
+// NAPI binding - will be exported from rust-engine after build
+let parseRustFile;
+// Try to load the native binding
+try {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const nativeBinding = await import('../../../../rust-engine/grafema-graph-engine.node');
+    parseRustFile = nativeBinding.parseRustFile;
+}
+catch {
+    // Fallback: try require
+    try {
+        const { createRequire } = await import('module');
+        const require = createRequire(import.meta.url);
+        const nativeBinding = require('../../../../rust-engine/grafema-graph-engine.node');
+        parseRustFile = nativeBinding.parseRustFile;
+    }
+    catch (e2) {
+        console.warn('[RustAnalyzer] Native binding not available:', e2.message);
+    }
+}
+export class RustAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'RustAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // Lower than JSASTAnalyzer (80)
+            creates: {
+                nodes: [
+                    'RUST_FUNCTION',
+                    'RUST_STRUCT',
+                    'RUST_IMPL',
+                    'RUST_METHOD',
+                    'RUST_TRAIT',
+                    'RUST_CALL'
+                ],
+                edges: ['CONTAINS', 'IMPLEMENTS']
+            },
+            dependencies: ['RustModuleIndexer']
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        if (!parseRustFile) {
+            console.log('[RustAnalyzer] Skipping - native binding not available');
+            return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'Native binding not available' });
+        }
+        // Get all RUST_MODULE nodes
+        const modules = [];
+        for await (const node of graph.queryNodes({ nodeType: 'RUST_MODULE' })) {
+            modules.push(node);
+        }
+        if (modules.length === 0) {
+            console.log('[RustAnalyzer] No RUST_MODULE nodes found, skipping');
+            return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true, reason: 'No modules' });
+        }
+        console.log(`[RustAnalyzer] Analyzing ${modules.length} Rust modules...`);
+        const stats = {
+            functions: 0,
+            structs: 0,
+            impls: 0,
+            methods: 0,
+            traits: 0,
+            calls: 0,
+            edges: 0
+        };
+        const errors = [];
+        for (let i = 0; i < modules.length; i++) {
+            const module = modules[i];
+            try {
+                const code = readFileSync(module.file, 'utf-8');
+                const parseResult = parseRustFile(code);
+                const result = await this.processParseResult(parseResult, module, graph);
+                stats.functions += result.functions;
+                stats.structs += result.structs;
+                stats.impls += result.impls;
+                stats.methods += result.methods;
+                stats.traits += result.traits;
+                stats.calls += result.calls;
+                stats.edges += result.edges;
+                if (onProgress && (i + 1) % 5 === 0) {
+                    onProgress({
+                        phase: 'analysis',
+                        currentPlugin: 'RustAnalyzer',
+                        message: `Analyzed ${i + 1}/${modules.length} Rust modules`,
+                        totalFiles: modules.length,
+                        processedFiles: i + 1
+                    });
+                }
+            }
+            catch (err) {
+                errors.push({ file: module.file, error: err.message });
+                console.error(`[RustAnalyzer] Error parsing ${module.file}:`, err.message);
+            }
+        }
+        if (errors.length > 0) {
+            console.warn(`[RustAnalyzer] ${errors.length} errors during analysis`);
+        }
+        console.log(`[RustAnalyzer] Created: ${JSON.stringify(stats)}`);
+        return createSuccessResult({ nodes: stats.functions + stats.structs + stats.impls + stats.methods + stats.traits + stats.calls, edges: stats.edges }, { ...stats, errors: errors.length });
+    }
+    async processParseResult(parseResult, module, graph) {
+        const edges = [];
+        let methodCount = 0;
+        let callCount = 0;
+        // Helper to process calls within a function/method
+        const processCalls = async (calls, parentId, parentName) => {
+            for (const call of calls || []) {
+                const callId = `RUST_CALL#${parentName}#${call.line}#${call.column}#${module.file}`;
+                await graph.addNode({
+                    id: callId,
+                    type: 'RUST_CALL',
+                    file: module.file,
+                    line: call.line,
+                    column: call.column,
+                    callType: call.callType, // "function" | "method" | "macro"
+                    name: call.name || null,
+                    receiver: call.receiver || null,
+                    method: call.method || null,
+                    argsCount: call.argsCount,
+                    sideEffect: call.sideEffect || null // "fs:write", "panic", "io:print", etc.
+                });
+                edges.push({ src: parentId, dst: callId, type: 'CONTAINS' });
+                callCount++;
+            }
+        };
+        // 1. Process top-level functions
+        for (const fn of parseResult.functions) {
+            const nodeId = `RUST_FUNCTION#${fn.name}#${module.file}#${fn.line}`;
+            await graph.addNode({
+                id: nodeId,
+                type: 'RUST_FUNCTION',
+                name: fn.name,
+                file: module.file,
+                line: fn.line,
+                column: fn.column,
+                pub: fn.isPub,
+                async: fn.isAsync,
+                unsafe: fn.isUnsafe,
+                const: fn.isConst,
+                napi: fn.isNapi,
+                napiJsName: fn.napiJsName || null,
+                napiConstructor: fn.napiConstructor || false,
+                napiGetter: fn.napiGetter || null,
+                napiSetter: fn.napiSetter || null,
+                params: fn.params || [],
+                returnType: fn.returnType || null,
+                unsafeBlocks: fn.unsafeBlocks?.length || 0 // Count of unsafe blocks in body
+            });
+            edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+            // Process calls within this function
+            await processCalls(fn.calls, nodeId, fn.name);
+        }
+        // 2. Process structs
+        for (const s of parseResult.structs) {
+            const nodeId = `RUST_STRUCT#${s.name}#${module.file}#${s.line}`;
+            await graph.addNode({
+                id: nodeId,
+                type: 'RUST_STRUCT',
+                name: s.name,
+                file: module.file,
+                line: s.line,
+                pub: s.isPub,
+                napi: s.isNapi,
+                fields: s.fields || []
+            });
+            edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+        }
+        // 3. Process impl blocks and their methods
+        for (const impl of parseResult.impls) {
+            const implId = `RUST_IMPL#${impl.targetType}${impl.traitName ? ':' + impl.traitName : ''}#${module.file}#${impl.line}`;
+            await graph.addNode({
+                id: implId,
+                type: 'RUST_IMPL',
+                name: impl.targetType,
+                traitName: impl.traitName || null,
+                file: module.file,
+                line: impl.line
+            });
+            edges.push({ src: module.id, dst: implId, type: 'CONTAINS' });
+            // IMPLEMENTS edge if trait impl
+            if (impl.traitName) {
+                edges.push({
+                    src: implId,
+                    dst: `RUST_TRAIT#${impl.traitName}`,
+                    type: 'IMPLEMENTS'
+                });
+            }
+            // Process methods inside impl
+            for (const method of impl.methods) {
+                const methodId = `RUST_METHOD#${method.name}#${module.file}#${method.line}`;
+                await graph.addNode({
+                    id: methodId,
+                    type: 'RUST_METHOD',
+                    name: method.name,
+                    file: module.file,
+                    line: method.line,
+                    column: method.column,
+                    pub: method.isPub,
+                    async: method.isAsync,
+                    unsafe: method.isUnsafe,
+                    const: method.isConst,
+                    napi: method.isNapi,
+                    napiJsName: method.napiJsName || null,
+                    napiConstructor: method.napiConstructor || false,
+                    napiGetter: method.napiGetter || null,
+                    napiSetter: method.napiSetter || null,
+                    params: method.params || [],
+                    returnType: method.returnType || null,
+                    selfType: method.selfType || null,
+                    implId: implId,
+                    implType: impl.targetType,
+                    unsafeBlocks: method.unsafeBlocks?.length || 0 // Count of unsafe blocks in body
+                });
+                edges.push({ src: implId, dst: methodId, type: 'CONTAINS' });
+                methodCount++;
+                // Process calls within this method
+                await processCalls(method.calls, methodId, `${impl.targetType}::${method.name}`);
+            }
+        }
+        // 4. Process traits
+        for (const t of parseResult.traits) {
+            const nodeId = `RUST_TRAIT#${t.name}#${module.file}#${t.line}`;
+            await graph.addNode({
+                id: nodeId,
+                type: 'RUST_TRAIT',
+                name: t.name,
+                file: module.file,
+                line: t.line,
+                pub: t.isPub,
+                methods: (t.methods || []).map(m => ({
+                    name: m.name,
+                    params: m.params,
+                    returnType: m.returnType
+                }))
+            });
+            edges.push({ src: module.id, dst: nodeId, type: 'CONTAINS' });
+        }
+        // 5. Write all edges
+        for (const edge of edges) {
+            await graph.addEdge(edge);
+        }
+        return {
+            functions: parseResult.functions.length,
+            structs: parseResult.structs.length,
+            impls: parseResult.impls.length,
+            methods: methodCount,
+            traits: parseResult.traits.length,
+            calls: callCount,
+            edges: edges.length
+        };
+    }
+}

package/dist/plugins/analysis/SQLiteAnalyzer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SQLiteAnalyzer - детектит SQLite database operations
+ *
+ * Паттерны:
+ * - database.getDb().all(query, params, callback)
+ * - database.getDb().get(query, params, callback)
+ * - database.getDb().run(query, params, callback)
+ * - Promise-wrapped: new Promise((resolve, reject) => { db.all(...) })
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class SQLiteAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private analyzeModule;
+    private getObjectName;
+    private extractTemplateLiteral;
+    private detectOperationType;
+    private extractTableName;
+}
+//# sourceMappingURL=SQLiteAnalyzer.d.ts.map

package/dist/plugins/analysis/SQLiteAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQLiteAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/SQLiteAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAiChF,qBAAa,cAAe,SAAQ,MAAM;IACxC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA+B9C,aAAa;IAiO3B,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,sBAAsB;IAY9B,OAAO,CAAC,mBAAmB;IAY3B,OAAO,CAAC,gBAAgB;CAiCzB"}

package/dist/plugins/analysis/SQLiteAnalyzer.js

@@ -0,0 +1,317 @@
+/**
+ * SQLiteAnalyzer - детектит SQLite database operations
+ *
+ * Паттерны:
+ * - database.getDb().all(query, params, callback)
+ * - database.getDb().get(query, params, callback)
+ * - database.getDb().run(query, params, callback)
+ * - Promise-wrapped: new Promise((resolve, reject) => { db.all(...) })
+ */
+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;
+const SQLITE_METHODS = ['all', 'get', 'run', 'exec', 'prepare', 'query', 'execute'];
+export class SQLiteAnalyzer extends Plugin {
+    get metadata() {
+        return {
+            name: 'SQLiteAnalyzer',
+            phase: 'ANALYSIS',
+            priority: 75, // После JSASTAnalyzer (80)
+            creates: {
+                nodes: ['db:query'],
+                edges: ['CONTAINS', 'EXECUTES_QUERY']
+            },
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+        };
+    }
+    async execute(context) {
+        try {
+            const { graph } = context;
+            // Получаем все MODULE ноды
+            const modules = await this.getModules(graph);
+            let queriesCreated = 0;
+            let operationsCreated = 0;
+            let edgesCreated = 0;
+            // Анализируем каждый модуль
+            for (const module of modules) {
+                const result = await this.analyzeModule(module, graph);
+                queriesCreated += result.queries;
+                operationsCreated += result.operations;
+                edgesCreated += result.edges;
+            }
+            console.log(`[SQLiteAnalyzer] Found ${queriesCreated} queries, ${operationsCreated} operations`);
+            return createSuccessResult({ nodes: queriesCreated + operationsCreated, edges: edgesCreated }, { modulesAnalyzed: modules.length, queries: queriesCreated, operations: operationsCreated });
+        }
+        catch (error) {
+            console.error(`[SQLiteAnalyzer] Error:`, error);
+            return createErrorResult(error);
+        }
+    }
+    async analyzeModule(module, graph) {
+        let queriesCreated = 0;
+        let operationsCreated = 0;
+        let edgesCreated = 0;
+        try {
+            // Читаем файл
+            const code = readFileSync(module.file, 'utf-8');
+            // Парсим AST
+            const ast = parse(code, {
+                sourceType: 'module',
+                plugins: ['jsx', 'typescript']
+            });
+            const queries = [];
+            traverse(ast, {
+                CallExpression: (path) => {
+                    const node = path.node;
+                    const callee = node.callee;
+                    // Паттерн 1: database.getDb().METHOD(query, params, callback)
+                    // или db.METHOD(query, params, callback)
+                    if (callee.type === 'MemberExpression' &&
+                        callee.property.type === 'Identifier' &&
+                        SQLITE_METHODS.includes(callee.property.name)) {
+                        const method = callee.property.name;
+                        const args = node.arguments;
+                        // Проверяем что это database/db объект, а не router/app
+                        const objectName = this.getObjectName(callee.object);
+                        if (objectName === 'router' || objectName === 'app') {
+                            // Это Express router, а не database
+                            return;
+                        }
+                        if (args.length >= 1) {
+                            let query = null;
+                            let params = null;
+                            // Первый аргумент - SQL query
+                            const queryArg = args[0];
+                            if (queryArg.type === 'StringLiteral') {
+                                query = queryArg.value;
+                            }
+                            else if (queryArg.type === 'TemplateLiteral') {
+                                // Template literal SQL: `SELECT * FROM ${table}`
+                                query = this.extractTemplateLiteral(queryArg);
+                            }
+                            // Второй аргумент - параметры (если есть)
+                            if (args.length >= 2 && args[1].type === 'ArrayExpression') {
+                                params = args[1].elements
+                                    .map(el => {
+                                    if (!el)
+                                        return '?';
+                                    if (el.type === 'StringLiteral' || el.type === 'NumericLiteral') {
+                                        return String(el.value);
+                                    }
+                                    else if (el.type === 'Identifier') {
+                                        return `$${el.name}`;
+                                    }
+                                    return '?';
+                                })
+                                    .join(', ');
+                            }
+                            if (query) {
+                                // Определяем тип операции из SQL
+                                const operationType = this.detectOperationType(query);
+                                const tableName = this.extractTableName(query, operationType);
+                                const queryId = `${module.file}:DATABASE_QUERY:${method}:${node.loc.start.line}`;
+                                queries.push({
+                                    id: queryId,
+                                    type: 'db:query',
+                                    method: method.toUpperCase(),
+                                    query: query,
+                                    params: params,
+                                    operationType: operationType,
+                                    tableName: tableName,
+                                    file: module.file,
+                                    line: node.loc.start.line
+                                });
+                            }
+                        }
+                    }
+                    // Паттерн 2: Promise-wrapped pattern
+                    // new Promise((resolve, reject) => { db.all(...) })
+                    if (callee.type === 'Identifier' && callee.name === 'Promise') {
+                        // Ищем внутри Promise executor function
+                        const executorArg = node.arguments[0];
+                        if (executorArg &&
+                            (executorArg.type === 'ArrowFunctionExpression' ||
+                                executorArg.type === 'FunctionExpression')) {
+                            // Обходим тело executor function для поиска db calls
+                            const executorPath = path.get('arguments.0');
+                            executorPath.traverse({
+                                CallExpression: (innerPath) => {
+                                    const innerNode = innerPath.node;
+                                    const innerCallee = innerNode.callee;
+                                    if (innerCallee.type === 'MemberExpression' &&
+                                        innerCallee.property.type === 'Identifier' &&
+                                        SQLITE_METHODS.includes(innerCallee.property.name)) {
+                                        const method = innerCallee.property.name;
+                                        const innerArgs = innerNode.arguments;
+                                        if (innerArgs.length >= 1) {
+                                            let query = null;
+                                            let params = null;
+                                            const queryArg = innerArgs[0];
+                                            if (queryArg.type === 'StringLiteral') {
+                                                query = queryArg.value;
+                                            }
+                                            else if (queryArg.type === 'TemplateLiteral') {
+                                                query = this.extractTemplateLiteral(queryArg);
+                                            }
+                                            if (innerArgs.length >= 2 && innerArgs[1].type === 'ArrayExpression') {
+                                                params = innerArgs[1].elements
+                                                    .map(el => {
+                                                    if (!el)
+                                                        return '?';
+                                                    if (el.type === 'StringLiteral' || el.type === 'NumericLiteral') {
+                                                        return String(el.value);
+                                                    }
+                                                    else if (el.type === 'Identifier') {
+                                                        return `$${el.name}`;
+                                                    }
+                                                    return '?';
+                                                })
+                                                    .join(', ');
+                                            }
+                                            if (query) {
+                                                const operationType = this.detectOperationType(query);
+                                                const tableName = this.extractTableName(query, operationType);
+                                                const queryId = `${module.file}:DATABASE_QUERY:${method}:${innerNode.loc.start.line}`;
+                                                queries.push({
+                                                    id: queryId,
+                                                    type: 'db:query',
+                                                    method: method.toUpperCase(),
+                                                    query: query,
+                                                    params: params,
+                                                    operationType: operationType,
+                                                    tableName: tableName,
+                                                    file: module.file,
+                                                    line: innerNode.loc.start.line,
+                                                    promiseWrapped: true
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            });
+            // Создаём DATABASE_QUERY ноды
+            for (const query of queries) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { promiseWrapped, ...queryData } = query;
+                await graph.addNode(queryData);
+                queriesCreated++;
+                // MODULE -> CONTAINS -> DATABASE_QUERY
+                await graph.addEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: query.id
+                });
+                edgesCreated++;
+                // Ищем FUNCTION ноду которая содержит этот query
+                const containingFunctions = [];
+                for await (const n of graph.queryNodes({ type: 'FUNCTION' })) {
+                    if (n.file === module.file &&
+                        (n.line ?? 0) <= query.line &&
+                        query.line - (n.line ?? 0) < 100) {
+                        containingFunctions.push(n);
+                    }
+                }
+                if (containingFunctions.length > 0) {
+                    // Берём ближайшую функцию
+                    const closestFunction = containingFunctions.reduce((prev, curr) => query.line - (curr.line ?? 0) < query.line - (prev.line ?? 0) ? curr : prev);
+                    // FUNCTION -> EXECUTES_QUERY -> DATABASE_QUERY
+                    await graph.addEdge({
+                        type: 'EXECUTES_QUERY',
+                        src: closestFunction.id,
+                        dst: query.id
+                    });
+                    edgesCreated++;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[SQLiteAnalyzer] Error analyzing ${module.file}:`, error.message);
+        }
+        return {
+            queries: queriesCreated,
+            operations: operationsCreated,
+            edges: edgesCreated
+        };
+    }
+    getObjectName(node) {
+        // Извлекаем имя объекта из call expression
+        if (node.type === 'Identifier') {
+            return node.name;
+        }
+        else if (node.type === 'MemberExpression') {
+            // database.getDb() → 'database'
+            return this.getObjectName(node.object);
+        }
+        return null;
+    }
+    extractTemplateLiteral(node) {
+        // Извлекаем SQL из template literal
+        const parts = [];
+        for (let i = 0; i < node.quasis.length; i++) {
+            parts.push(node.quasis[i].value.raw);
+            if (i < node.expressions.length) {
+                parts.push('${...}');
+            }
+        }
+        return parts.join('');
+    }
+    detectOperationType(query) {
+        const upperQuery = query.toUpperCase().trim();
+        if (upperQuery.startsWith('SELECT'))
+            return 'SELECT';
+        if (upperQuery.startsWith('INSERT'))
+            return 'INSERT';
+        if (upperQuery.startsWith('UPDATE'))
+            return 'UPDATE';
+        if (upperQuery.startsWith('DELETE'))
+            return 'DELETE';
+        if (upperQuery.startsWith('CREATE'))
+            return 'CREATE';
+        if (upperQuery.startsWith('DROP'))
+            return 'DROP';
+        if (upperQuery.startsWith('ALTER'))
+            return 'ALTER';
+        return 'UNKNOWN';
+    }
+    extractTableName(query, operationType) {
+        const upperQuery = query.toUpperCase();
+        try {
+            if (operationType === 'SELECT') {
+                // SELECT ... FROM table_name
+                const match = upperQuery.match(/FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                return match ? match[1].toLowerCase() : null;
+            }
+            else if (operationType === 'INSERT') {
+                // INSERT INTO table_name
+                const match = upperQuery.match(/INSERT\s+INTO\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                return match ? match[1].toLowerCase() : null;
+            }
+            else if (operationType === 'UPDATE') {
+                // UPDATE table_name
+                const match = upperQuery.match(/UPDATE\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                return match ? match[1].toLowerCase() : null;
+            }
+            else if (operationType === 'DELETE') {
+                // DELETE FROM table_name
+                const match = upperQuery.match(/DELETE\s+FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/);
+                return match ? match[1].toLowerCase() : null;
+            }
+            else if (operationType === 'CREATE') {
+                // CREATE TABLE table_name
+                const match = upperQuery.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-zA-Z_][a-zA-Z0-9_]*)/);
+                return match ? match[1].toLowerCase() : null;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
+}

package/dist/plugins/analysis/ServiceLayerAnalyzer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ServiceLayerAnalyzer - детектит Service Layer Pattern
+ *
+ * Паттерны:
+ * - class XxxService { ... } - Service classes
+ * - new XxxService() - Service instantiation
+ * - app.set('service', instance) - DI registration
+ * - req.app.get('service') - Service usage
+ * - export class XxxService - Service exports
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ServiceLayerAnalyzer extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    private analyzeModule;
+    /**
+     * Проверяет является ли класс Service классом
+     * (заканчивается на Service или содержит Service в имени)
+     */
+    private isServiceClass;
+    /**
+     * Извлекает имя объекта из MemberExpression
+     */
+    private getObjectName;
+    /**
+     * Извлекает цепочку объектов (для req.app.get)
+     */
+    private getObjectChain;
+    /**
+     * Извлекает строковое значение из аргумента
+     */
+    private extractStringArg;
+}
+//# sourceMappingURL=ServiceLayerAnalyzer.d.ts.map

package/dist/plugins/analysis/ServiceLayerAnalyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceLayerAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/ServiceLayerAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAcH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8DhF,qBAAa,oBAAqB,SAAQ,MAAM;IAC9C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YAsD9C,aAAa;IAsN3B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,aAAa;IAWrB;;OAEG;IACH,OAAO,CAAC,cAAc;IAatB;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAczB"}