@grafema/core 0.1.0-alpha.1

package/src/plugins/analysis/ast/visitors/VariableVisitor.ts

@@ -0,0 +1,268 @@
+/**
+ * VariableVisitor - handles module-level variable declarations
+ *
+ * Handles:
+ * - VariableDeclaration (const, let, var at module level)
+ * - NewExpression tracking for class instantiation
+ * - Destructuring patterns
+ */
+
+import type {
+  VariableDeclaration,
+  VariableDeclarator,
+  NewExpression,
+  Identifier,
+  Node
+} from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+
+/**
+ * Variable info extracted from pattern
+ */
+export interface VariableInfo {
+  name: string;
+  loc: { start: { line: number; column: number } };
+  propertyPath?: string[];
+  arrayIndex?: number;
+}
+
+/**
+ * Callback type for extracting variable names from patterns
+ */
+export type ExtractVariableNamesCallback = (pattern: Node) => VariableInfo[];
+
+/**
+ * Callback type for tracking variable assignments
+ */
+export type TrackVariableAssignmentCallback = (
+  initNode: Node,
+  variableId: string,
+  variableName: string,
+  module: VisitorModule,
+  line: number,
+  literals: unknown[],
+  variableAssignments: unknown[],
+  literalCounterRef: CounterRef
+) => void;
+
+/**
+ * Variable declaration info
+ */
+interface VariableDeclarationInfo {
+  id: string;
+  type: 'VARIABLE' | 'CONSTANT';
+  name: string;
+  file: string;
+  line: number;
+  parentScopeId: string;
+  value?: unknown;
+}
+
+/**
+ * Class instantiation info
+ */
+interface ClassInstantiationInfo {
+  variableId: string;
+  variableName: string;
+  className: string;
+  line: number;
+  parentScopeId: string;
+}
+
+/**
+ * Literal/expression info for data flow
+ */
+interface LiteralExpressionInfo {
+  id: string;
+  type: 'EXPRESSION';
+  expressionType: string;
+  path: string;
+  baseName: string;
+  propertyPath: string[] | null;
+  arrayIndex?: number;
+  file: string;
+  line: number;
+}
+
+/**
+ * Variable assignment info for data flow
+ */
+interface VariableAssignmentInfo {
+  variableId: string;
+  sourceId: string | null;
+  sourceName?: string;
+  sourceType: string;
+  file?: string;
+}
+
+export class VariableVisitor extends ASTVisitor {
+  private extractVariableNamesFromPattern: ExtractVariableNamesCallback;
+  private trackVariableAssignment: TrackVariableAssignmentCallback;
+
+  /**
+   * @param module - Current module being analyzed
+   * @param collections - Must contain arrays and counter refs
+   * @param extractVariableNamesFromPattern - Helper for destructuring
+   * @param trackVariableAssignment - Helper for data flow tracking
+   */
+  constructor(
+    module: VisitorModule,
+    collections: VisitorCollections,
+    extractVariableNamesFromPattern: ExtractVariableNamesCallback,
+    trackVariableAssignment: TrackVariableAssignmentCallback
+  ) {
+    super(module, collections);
+    this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
+    this.trackVariableAssignment = trackVariableAssignment;
+  }
+
+  getHandlers(): VisitorHandlers {
+    const { module } = this;
+    const variableDeclarations = this.collections.variableDeclarations ?? [];
+    const classInstantiations = this.collections.classInstantiations ?? [];
+    const literals = (this.collections.literals ?? []) as unknown[];
+    const variableAssignments = this.collections.variableAssignments ?? [];
+    const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
+    const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 }) as CounterRef;
+
+    const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
+    const trackVariableAssignment = this.trackVariableAssignment;
+
+    return {
+      VariableDeclaration: (path: NodePath) => {
+        // Only module-level variables
+        const functionParent = path.getFunctionParent();
+        if (!functionParent) {
+          const varNode = path.node as VariableDeclaration;
+          const isConst = varNode.kind === 'const';
+
+          varNode.declarations.forEach((declarator: VariableDeclarator) => {
+            // Extract all variable names from the pattern (handles destructuring)
+            const variables = extractVariableNamesFromPattern(declarator.id);
+
+            variables.forEach((varInfo: VariableInfo) => {
+              const literalValue = ExpressionEvaluator.extractLiteralValue(declarator.init);
+              const isLiteral = literalValue !== null;
+              const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+
+              // For const with literal or NewExpression create CONSTANT
+              // For everything else - VARIABLE
+              const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+
+              const varId = shouldBeConstant
+                ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${(varDeclCounterRef as CounterRef).value++}`
+                : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${(varDeclCounterRef as CounterRef).value++}`;
+
+              if (shouldBeConstant) {
+                // CONSTANT node
+                const constantData: VariableDeclarationInfo = {
+                  id: varId,
+                  type: 'CONSTANT',
+                  name: varInfo.name,
+                  file: module.file,
+                  line: varInfo.loc.start.line,
+                  parentScopeId: module.id
+                };
+
+                if (isLiteral) {
+                  constantData.value = literalValue;
+                }
+
+                (variableDeclarations as VariableDeclarationInfo[]).push(constantData);
+
+                // If NewExpression, track for CLASS and INSTANCE_OF
+                if (isNewExpression) {
+                  const newExpr = declarator.init as NewExpression;
+                  if (newExpr.callee.type === 'Identifier') {
+                    const className = (newExpr.callee as Identifier).name;
+                    (classInstantiations as ClassInstantiationInfo[]).push({
+                      variableId: varId,
+                      variableName: varInfo.name,
+                      className: className,
+                      line: varInfo.loc.start.line,
+                      parentScopeId: module.id
+                    });
+                  }
+                }
+              } else {
+                (variableDeclarations as VariableDeclarationInfo[]).push({
+                  id: varId,
+                  type: 'VARIABLE',
+                  name: varInfo.name,
+                  file: module.file,
+                  line: varInfo.loc.start.line,
+                  parentScopeId: module.id
+                });
+              }
+
+              // Track assignment for data flow analysis
+              if (declarator.init) {
+                // Handle destructuring - create EXPRESSION for property path
+                if (varInfo.propertyPath || varInfo.arrayIndex !== undefined) {
+                  // Create EXPRESSION node for the property access
+                  const initName = declarator.init.type === 'Identifier'
+                    ? (declarator.init as Identifier).name
+                    : 'expr';
+                  let expressionPath = initName;
+
+                  if (varInfo.propertyPath) {
+                    expressionPath = `${initName}.${varInfo.propertyPath.join('.')}`;
+                  } else if (varInfo.arrayIndex !== undefined) {
+                    expressionPath = `${initName}[${varInfo.arrayIndex}]`;
+                  }
+
+                  const expressionId = `EXPRESSION#${expressionPath}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}`;
+
+                  // Create EXPRESSION node representing the property access
+                  (literals as LiteralExpressionInfo[]).push({
+                    id: expressionId,
+                    type: 'EXPRESSION',
+                    expressionType: varInfo.propertyPath ? 'MemberExpression' : 'ArrayAccess',
+                    path: expressionPath,
+                    baseName: initName,
+                    propertyPath: varInfo.propertyPath || null,
+                    arrayIndex: varInfo.arrayIndex,
+                    file: module.file,
+                    line: varInfo.loc.start.line
+                  });
+
+                  // Create ASSIGNED_FROM edge: VARIABLE -> EXPRESSION
+                  (variableAssignments as VariableAssignmentInfo[]).push({
+                    variableId: varId,
+                    sourceId: expressionId,
+                    sourceType: 'EXPRESSION'
+                  });
+
+                  // Also create DERIVES_FROM edge: EXPRESSION -> base variable (if identifier)
+                  if (declarator.init.type === 'Identifier') {
+                    (variableAssignments as VariableAssignmentInfo[]).push({
+                      variableId: expressionId,
+                      sourceId: null, // Will be resolved by name
+                      sourceName: (declarator.init as Identifier).name,
+                      sourceType: 'DERIVES_FROM_VARIABLE',
+                      file: module.file
+                    });
+                  }
+                } else {
+                  // Normal assignment tracking
+                  trackVariableAssignment(
+                    declarator.init,
+                    varId,
+                    varInfo.name,
+                    module,
+                    varInfo.loc.start.line,
+                    literals,
+                    variableAssignments,
+                    literalCounterRef as CounterRef
+                  );
+                }
+              }
+            });
+          });
+        }
+      }
+    };
+  }
+}

package/src/plugins/analysis/ast/visitors/index.ts

@@ -0,0 +1,36 @@
+/**
+ * AST Visitors for JSASTAnalyzer
+ *
+ * Each visitor handles specific AST node types and extracts relevant data
+ * into shared collections.
+ */
+
+export { ASTVisitor } from './ASTVisitor.js';
+export type {
+  VisitorModule,
+  VisitorCollections,
+  VisitorHandlers,
+  VisitorHandler,
+  CounterRef,
+  ProcessedNodes,
+  VariableAssignment,
+  LocationInfo
+} from './ASTVisitor.js';
+
+export { ImportExportVisitor } from './ImportExportVisitor.js';
+
+export { VariableVisitor } from './VariableVisitor.js';
+export type {
+  VariableInfo,
+  ExtractVariableNamesCallback,
+  TrackVariableAssignmentCallback
+} from './VariableVisitor.js';
+
+export { FunctionVisitor } from './FunctionVisitor.js';
+export type { AnalyzeFunctionBodyCallback } from './FunctionVisitor.js';
+
+export { ClassVisitor } from './ClassVisitor.js';
+
+export { CallExpressionVisitor } from './CallExpressionVisitor.js';
+
+export { TypeScriptVisitor } from './TypeScriptVisitor.js';

package/src/plugins/discovery/DiscoveryPlugin.ts

@@ -0,0 +1,50 @@
+/**
+ * Базовый класс для плагинов DISCOVERY фазы
+ *
+ * DISCOVERY фаза отвечает за:
+ * 1. Поиск сервисов/компонентов в проекте
+ * 2. Создание SERVICE нод
+ * 3. Возврат манифеста для последующих фаз
+ */
+
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+
+export abstract class DiscoveryPlugin extends Plugin {
+  constructor(config: Record<string, unknown> = {}) {
+    super(config);
+  }
+
+  get metadata(): PluginMetadata {
+    return {
+      name: this.constructor.name,
+      phase: 'DISCOVERY',
+      priority: 100,
+      creates: {
+        nodes: ['SERVICE'],
+        edges: []
+      },
+      dependencies: []
+    };
+  }
+
+  /**
+   * Выполнить discovery
+   *
+   * @param context - PluginContext
+   * context.projectPath - корневая директория проекта
+   *
+   * @returns Promise<PluginResult>
+   * result.metadata.services - массив найденных сервисов
+   * [
+   *   {
+   *     id: string,
+   *     name: string,
+   *     path: string,
+   *     type: string,
+   *     metadata: Object
+   *   }
+   * ]
+   */
+  abstract execute(context: PluginContext): Promise<PluginResult>;
+}

package/src/plugins/discovery/MonorepoServiceDiscovery.ts

@@ -0,0 +1,117 @@
+/**
+ * MonorepoServiceDiscovery - плагин для поиска сервисов в монорепозитории
+ *
+ * Стратегия discovery:
+ * 1. Ищет директорию pkg/ в корне проекта
+ * 2. Каждая поддиректория в pkg/ считается сервисом
+ * 3. Создаёт SERVICE ноды для каждого найденного сервиса
+ */
+
+import { DiscoveryPlugin } from './DiscoveryPlugin.js';
+import { createSuccessResult, createErrorResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { NodeRecord } from '@grafema/types';
+import { readdirSync, statSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Service info returned in metadata
+ */
+interface ServiceInfo {
+  id: string;
+  name: string;
+  path: string;
+  type: string;
+}
+
+/**
+ * Configuration options
+ */
+interface MonorepoConfig extends Record<string, unknown> {
+  servicesDir?: string;
+  excludeDirs?: string[];
+}
+
+export class MonorepoServiceDiscovery extends DiscoveryPlugin {
+  private servicesDir: string;
+  private excludeDirs: string[];
+
+  constructor(config: MonorepoConfig = {}) {
+    super(config);
+    // Настройки по умолчанию
+    this.servicesDir = config.servicesDir || 'pkg';
+    this.excludeDirs = config.excludeDirs || ['.git', 'node_modules', 'build', 'dist'];
+  }
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'MonorepoServiceDiscovery',
+      phase: 'DISCOVERY',
+      priority: 100,
+      creates: {
+        nodes: ['SERVICE'],
+        edges: []
+      },
+      dependencies: []
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { projectPath, graph } = context;
+    const servicesPath = join(projectPath!, this.servicesDir);
+
+    console.log(`[MonorepoServiceDiscovery] Looking for services in: ${servicesPath}`);
+
+    if (!existsSync(servicesPath)) {
+      return createErrorResult(
+        new Error(`Services directory not found: ${servicesPath}`)
+      );
+    }
+
+    try {
+      const services: ServiceInfo[] = [];
+      const entries = readdirSync(servicesPath);
+      console.log(`[MonorepoServiceDiscovery] Found ${entries.length} entries`);
+
+      for (const entry of entries) {
+        const fullPath = join(servicesPath, entry);
+        const stat = statSync(fullPath);
+
+        // Пропускаем файлы и исключённые директории
+        if (!stat.isDirectory() || this.excludeDirs.includes(entry)) {
+          continue;
+        }
+
+        // Создаём SERVICE ноду
+        const serviceId = `service:${entry}`;
+        // Cast through unknown since we're creating a dynamic service node
+        const serviceNode = {
+          id: serviceId,
+          type: 'SERVICE',
+          name: entry,
+          path: fullPath,
+          metadata: {
+            discoveryMethod: 'monorepo',
+            servicePath: fullPath
+          }
+        } as unknown as NodeRecord;
+
+        await graph.addNode(serviceNode);
+
+        services.push({
+          id: serviceId,
+          name: entry,
+          path: fullPath,
+          type: 'monorepo-service'
+        });
+      }
+
+      return createSuccessResult(
+        { nodes: services.length, edges: 0 },
+        { services }
+      );
+    } catch (error) {
+      return createErrorResult(error as Error);
+    }
+  }
+}

package/src/plugins/discovery/SimpleProjectDiscovery.ts

@@ -0,0 +1,102 @@
+/**
+ * SimpleProjectDiscovery - универсальный discovery плагин
+ *
+ * Находит сервис по package.json в корне проекта.
+ * Работает для любого JS/TS проекта.
+ * Используется как дефолтный discovery когда нет специфичных плагинов.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { NodeFactory } from '../../core/NodeFactory.js';
+import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+
+/**
+ * Service info returned in metadata
+ */
+interface ServiceInfo {
+  id: string;
+  name: string;
+  path: string;
+  type: string;
+  metadata: {
+    entrypoint: string;
+    packageJson: PackageJson;
+  };
+}
+
+/**
+ * Package.json structure (relevant fields)
+ */
+interface PackageJson {
+  name?: string;
+  version?: string;
+  main?: string;
+  description?: string;
+  dependencies?: Record<string, string>;
+}
+
+export class SimpleProjectDiscovery extends Plugin {
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'SimpleProjectDiscovery',
+      phase: 'DISCOVERY',
+      priority: 50, // Lower priority than specialized discovery plugins
+      creates: {
+        nodes: ['SERVICE'],
+        edges: []
+      },
+      dependencies: []
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph } = context;
+    // projectPath can be at top level (DISCOVERY phase) or in manifest/config
+    const projectPath = context.projectPath || (context.manifest as { projectPath?: string })?.projectPath || context.config?.projectPath;
+
+    if (!projectPath) {
+      return createErrorResult(new Error('projectPath not found in context'));
+    }
+
+    const packageJsonPath = join(projectPath, 'package.json');
+
+    if (!existsSync(packageJsonPath)) {
+      return createErrorResult(new Error(`package.json not found: ${packageJsonPath}`));
+    }
+
+    try {
+      const packageJson: PackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+      const serviceName = packageJson.name || 'unnamed-service';
+      const entrypoint = packageJson.main || 'index.js';
+
+      // Используем NodeFactory для создания SERVICE ноды
+      const serviceNode = NodeFactory.createService(serviceName, projectPath, {
+        discoveryMethod: 'simple',
+        entrypoint,
+        version: packageJson.version,
+        description: packageJson.description,
+        dependencies: Object.keys(packageJson.dependencies || {})
+      });
+
+      await graph.addNode(serviceNode);
+
+      const service: ServiceInfo = {
+        id: serviceNode.id,
+        name: serviceName,
+        path: join(projectPath, entrypoint),
+        type: 'simple-project',
+        metadata: {
+          entrypoint: join(projectPath, entrypoint),
+          packageJson
+        }
+      };
+
+      return createSuccessResult({ nodes: 1, edges: 0 }, { services: [service] });
+    } catch (error) {
+      return createErrorResult(error as Error);
+    }
+  }
+}