@grafema/core 0.1.0-alpha.1

package/src/plugins/indexing/RustModuleIndexer.ts

@@ -0,0 +1,160 @@
+/**
+ * RustModuleIndexer - plugin for indexing Rust modules
+ * Discovers .rs files in rust-engine/src/ directory
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { resolve, relative, basename, join } from 'path';
+import { createHash } from 'crypto';
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { NodeRecord } from '@grafema/types';
+
+// Test file patterns for Rust
+const RUST_TEST_PATTERNS: RegExp[] = [
+  /[/\\]tests[/\\]/,           // /tests/
+  /_test\.rs$/,                // _test.rs
+  /[/\\]test\.rs$/,            // test.rs in subdirectory
+];
+
+export class RustModuleIndexer extends Plugin {
+  private testPatterns: RegExp[];
+
+  constructor() {
+    super();
+    this.testPatterns = RUST_TEST_PATTERNS;
+  }
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'RustModuleIndexer',
+      phase: 'INDEXING',
+      priority: 85,  // After JSModuleIndexer (90)
+      creates: {
+        nodes: ['RUST_MODULE'],
+        edges: ['CONTAINS']
+      }
+    };
+  }
+
+  /**
+   * Check if file is a test file based on path patterns
+   */
+  private isTestFile(filePath: string): boolean {
+    return this.testPatterns.some(pattern => pattern.test(filePath));
+  }
+
+  /**
+   * Recursively find all .rs files in a directory
+   */
+  private findRustFiles(dir: string, files: string[] = []): string[] {
+    try {
+      const entries = readdirSync(dir);
+      for (const entry of entries) {
+        // Skip target directory
+        if (entry === 'target') continue;
+
+        const fullPath = join(dir, entry);
+        try {
+          const stat = statSync(fullPath);
+          if (stat.isDirectory()) {
+            this.findRustFiles(fullPath, files);
+          } else if (entry.endsWith('.rs')) {
+            files.push(fullPath);
+          }
+        } catch {
+          // Skip files we can't stat
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+    return files;
+  }
+
+  /**
+   * Convert file path to Rust module name
+   * src/ffi/napi_bindings.rs -> ffi::napi_bindings
+   * src/lib.rs -> crate
+   * src/ffi/mod.rs -> ffi
+   */
+  private pathToModuleName(relativePath: string): string {
+    let name = relativePath
+      .replace(/\.rs$/, '')
+      .replace(/\//g, '::');
+
+    if (name.endsWith('::mod')) {
+      name = name.replace(/::mod$/, '');
+    }
+    if (name === 'lib') {
+      name = 'crate';
+    }
+    return name;
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { manifest, graph, onProgress } = context;
+    // Cast manifest to expected shape
+    const typedManifest = manifest as { projectPath: string } | undefined;
+    const { projectPath } = typedManifest!;
+
+    // Find rust-engine/src directory
+    const rustRoot = resolve(projectPath, 'rust-engine/src');
+
+    if (!existsSync(rustRoot)) {
+      console.log('[RustModuleIndexer] rust-engine/src not found, skipping');
+      return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
+    }
+
+    // Discover all .rs files recursively
+    const rsFiles = this.findRustFiles(rustRoot);
+
+    console.log(`[RustModuleIndexer] Found ${rsFiles.length} .rs files`);
+
+    let nodesCreated = 0;
+    const errors: Array<{ file: string; error: string }> = [];
+
+    for (const filePath of rsFiles) {
+      try {
+        const content = readFileSync(filePath, 'utf-8');
+        const hash = createHash('sha256').update(content).digest('hex');
+        const relativePath = relative(rustRoot, filePath);
+        const moduleName = this.pathToModuleName(relativePath);
+
+        const nodeId = `RUST_MODULE#${moduleName}#${filePath}`;
+
+        await graph.addNode({
+          id: nodeId,
+          type: 'RUST_MODULE',
+          name: moduleName,
+          file: filePath,
+          contentHash: hash,
+          isLib: basename(filePath) === 'lib.rs',
+          isMod: basename(filePath) === 'mod.rs',
+          isTest: this.isTestFile(filePath)
+        } as unknown as NodeRecord);
+
+        nodesCreated++;
+
+        if (onProgress && nodesCreated % 10 === 0) {
+          onProgress({
+            phase: 'indexing',
+            currentPlugin: 'RustModuleIndexer',
+            message: `Indexed ${nodesCreated}/${rsFiles.length} Rust modules`,
+            totalFiles: rsFiles.length,
+            processedFiles: nodesCreated
+          });
+        }
+      } catch (err) {
+        errors.push({ file: filePath, error: (err as Error).message });
+      }
+    }
+
+    if (errors.length > 0) {
+      console.warn(`[RustModuleIndexer] ${errors.length} errors during indexing`);
+    }
+
+    console.log(`[RustModuleIndexer] Indexed ${nodesCreated} Rust modules`);
+    return createSuccessResult({ nodes: nodesCreated, edges: 0 }, { errors: errors.length });
+  }
+}

package/src/plugins/indexing/ServiceDetector.ts

@@ -0,0 +1,230 @@
+/**
+ * ServiceDetector - обнаруживает сервисы в монорепозитории
+ *
+ * Паттерны детекции:
+ * 1. Директории с package.json в apps/, packages/, services/
+ * 2. Директории с Dockerfile
+ * 3. Директории с server.js/index.js entry points
+ */
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import type { NodeRecord } from '@grafema/types';
+
+/**
+ * Context for ServiceDetector
+ */
+interface DetectorContext {
+  projectPath: string;
+  graph: {
+    addNode(node: NodeRecord): Promise<void>;
+  };
+}
+
+/**
+ * Package.json structure (relevant fields)
+ */
+interface PackageJson {
+  name?: string;
+  main?: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Service info
+ */
+interface ServiceInfo {
+  id: string;
+  name: string;
+  path: string;
+  packageJson: PackageJson | null;
+  entryPoint: string | null;
+  hasDockerfile: boolean;
+}
+
+export class ServiceDetector {
+  name: string;
+  phase: string;
+  priority: number;
+
+  constructor() {
+    this.name = 'ServiceDetector';
+    this.phase = 'INDEXING';
+    this.priority = 90; // Запускается перед JSModuleIndexer
+  }
+
+  /**
+   * Анализирует проект и создаёт SERVICE ноды
+   */
+  async analyze(context: DetectorContext): Promise<DetectorContext> {
+    const { projectPath, graph } = context;
+    const services: ServiceInfo[] = [];
+
+    console.log(`[${this.name}] Detecting services in: ${projectPath}`);
+
+    // Паттерн 1: Монорепо структура (apps/, packages/, services/)
+    const monorepoPatterns = ['apps', 'packages', 'services'];
+
+    for (const pattern of monorepoPatterns) {
+      const monorepoDir = join(projectPath, pattern);
+
+      if (existsSync(monorepoDir)) {
+        const detected = this.detectServicesInDir(monorepoDir, projectPath);
+        services.push(...detected);
+      }
+    }
+
+    // Паттерн 2: Корневой проект (если нет монорепо)
+    if (services.length === 0) {
+      const rootService = this.detectRootService(projectPath);
+      if (rootService) {
+        services.push(rootService);
+      }
+    }
+
+    // Создаём SERVICE ноды в графе
+    for (const service of services) {
+      await graph.addNode({
+        id: service.id,
+        type: 'SERVICE',
+        name: service.name,
+        file: service.path,
+        metadata: {
+          packageJson: service.packageJson,
+          entryPoint: service.entryPoint,
+          hasDockerfile: service.hasDockerfile
+        }
+      } as unknown as NodeRecord);
+    }
+
+    console.log(`[${this.name}] Detected ${services.length} services`);
+    services.forEach(s => console.log(`  - ${s.name} (${s.path})`));
+
+    return context;
+  }
+
+  /**
+   * Обнаруживает сервисы в директории монорепо
+   */
+  private detectServicesInDir(dir: string, projectPath: string): ServiceInfo[] {
+    const services: ServiceInfo[] = [];
+
+    try {
+      const entries = readdirSync(dir);
+
+      for (const entry of entries) {
+        const fullPath = join(dir, entry);
+
+        // Пропускаем файлы и скрытые директории
+        if (!statSync(fullPath).isDirectory() || entry.startsWith('.')) {
+          continue;
+        }
+
+        // Проверяем признаки сервиса
+        const packageJsonPath = join(fullPath, 'package.json');
+        const hasPackageJson = existsSync(packageJsonPath);
+
+        if (hasPackageJson) {
+          const service = this.createServiceFromDir(fullPath, entry, projectPath);
+          if (service) {
+            services.push(service);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`[${this.name}] Error scanning ${dir}:`, (error as Error).message);
+    }
+
+    return services;
+  }
+
+  /**
+   * Обнаруживает корневой сервис (не монорепо)
+   */
+  private detectRootService(projectPath: string): ServiceInfo | null {
+    const packageJsonPath = join(projectPath, 'package.json');
+
+    if (!existsSync(packageJsonPath)) {
+      return null;
+    }
+
+    const projectName = basename(projectPath);
+    return this.createServiceFromDir(projectPath, projectName, projectPath);
+  }
+
+  /**
+   * Создаёт объект сервиса из директории
+   */
+  private createServiceFromDir(
+    servicePath: string,
+    serviceName: string,
+    projectPath: string
+  ): ServiceInfo | null {
+    try {
+      const packageJsonPath = join(servicePath, 'package.json');
+      let packageJson: PackageJson | null = null;
+
+      if (existsSync(packageJsonPath)) {
+        const content = readFileSync(packageJsonPath, 'utf-8');
+        packageJson = JSON.parse(content) as PackageJson;
+      }
+
+      // Определяем entry point
+      const entryPoint = this.findEntryPoint(servicePath, packageJson);
+
+      // Проверяем наличие Dockerfile
+      const hasDockerfile = existsSync(join(servicePath, 'Dockerfile')) ||
+                            existsSync(join(servicePath, 'dockerfile'));
+
+      // Генерируем ID сервиса
+      const relativePath = servicePath.replace(projectPath, '').replace(/^\//, '');
+      const serviceId = `SERVICE:${relativePath || serviceName}`;
+
+      return {
+        id: serviceId,
+        name: packageJson?.name || serviceName,
+        path: servicePath,
+        packageJson,
+        entryPoint,
+        hasDockerfile
+      };
+    } catch (error) {
+      console.warn(`[${this.name}] Error creating service from ${servicePath}:`, (error as Error).message);
+      return null;
+    }
+  }
+
+  /**
+   * Находит entry point сервиса
+   */
+  private findEntryPoint(servicePath: string, packageJson: PackageJson | null): string | null {
+    // 1. Из package.json main
+    if (packageJson?.main) {
+      return packageJson.main;
+    }
+
+    // 2. Стандартные entry points
+    const candidates = [
+      'src/index.js',
+      'src/index.ts',
+      'src/server.js',
+      'src/server.ts',
+      'src/main.js',
+      'src/main.ts',
+      'index.js',
+      'index.ts',
+      'server.js',
+      'server.ts',
+      'app.js',
+      'app.ts'
+    ];
+
+    for (const candidate of candidates) {
+      if (existsSync(join(servicePath, candidate))) {
+        return candidate;
+      }
+    }
+
+    return null;
+  }
+}

package/src/plugins/validation/CallResolverValidator.ts

@@ -0,0 +1,170 @@
+/**
+ * CallResolverValidator - проверяет что все вызовы функций ссылаются на определения
+ *
+ * Использует Datalog для декларативной проверки гарантии:
+ * "Все внутренние вызовы функций (CALL_SITE) должны иметь CALLS ребро к FUNCTION"
+ *
+ * ПРАВИЛО (Datalog):
+ * violation(X) :- node(X, "CALL"), \+ attr(X, "object", _), \+ edge(X, _, "CALLS").
+ *
+ * Это находит CALL узлы без "object" метаданных (т.е. CALL_SITE, не METHOD_CALL),
+ * которые не имеют CALLS ребра к определению функции.
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { NodeRecord } from '@grafema/types';
+
+/**
+ * Call resolver issue
+ */
+interface CallResolverIssue {
+  type: string;
+  severity: string;
+  message: string;
+  callName: string;
+  nodeId: string;
+  file?: string;
+  line?: number;
+}
+
+/**
+ * Method call statistics
+ */
+interface MethodCallStats {
+  total: number;
+  resolved: number;
+  external: number;
+}
+
+/**
+ * Validation summary
+ */
+interface ValidationSummary {
+  totalCalls: number;
+  resolvedInternalCalls: number;
+  unresolvedInternalCalls: number;
+  externalMethodCalls: number;
+  issues: number;
+}
+
+/**
+ * Datalog violation result
+ */
+interface DatalogViolation {
+  bindings: Array<{ name: string; value: string }>;
+}
+
+export class CallResolverValidator extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'CallResolverValidator',
+      phase: 'VALIDATION',
+      priority: 90,
+      creates: {
+        nodes: [],
+        edges: []
+      }
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph } = context;
+
+    console.log('[CallResolverValidator] Starting call resolution validation using Datalog...');
+
+    // Check if graph supports checkGuarantee
+    if (!graph.checkGuarantee) {
+      console.log('[CallResolverValidator] Graph does not support checkGuarantee, skipping validation');
+      return createSuccessResult({ nodes: 0, edges: 0 }, { skipped: true });
+    }
+
+    // Datalog гарантия:
+    // CALL без "object" (т.е. CALL_SITE) должен иметь CALLS ребро
+    const violations = await graph.checkGuarantee(`
+      violation(X) :- node(X, "CALL"), \\+ attr(X, "object", _), \\+ edge(X, _, "CALLS").
+    `) as DatalogViolation[];
+
+    const issues: CallResolverIssue[] = [];
+
+    if (violations.length > 0) {
+      console.log(`[CallResolverValidator] Found ${violations.length} unresolved function calls`);
+
+      for (const v of violations) {
+        const nodeId = v.bindings.find(b => b.name === 'X')?.value;
+        if (nodeId) {
+          const node = await graph.getNode(nodeId);
+          if (node) {
+            issues.push({
+              type: 'UNRESOLVED_FUNCTION_CALL',
+              severity: 'WARNING',
+              message: `Call to "${node.name}" at ${node.file}:${node.line || '?'} does not resolve to a function definition`,
+              callName: node.name as string,
+              nodeId: nodeId,
+              file: node.file,
+              line: node.line as number | undefined
+            });
+          }
+        }
+      }
+    }
+
+    // Также проверим METHOD_CALL на известные внешние методы
+    // (это информационно, не ошибка)
+    const methodCallStats = await this.countMethodCalls(graph);
+
+    const summary: ValidationSummary = {
+      totalCalls: methodCallStats.total,
+      resolvedInternalCalls: methodCallStats.resolved,
+      unresolvedInternalCalls: issues.length,
+      externalMethodCalls: methodCallStats.external,
+      issues: issues.length
+    };
+
+    console.log('[CallResolverValidator] Summary:', summary);
+
+    if (issues.length > 0) {
+      console.log(`[CallResolverValidator] Unresolved calls:`);
+      for (const issue of issues.slice(0, 10)) { // Show first 10
+        console.log(`  ⚠️ ${issue.message}`);
+      }
+      if (issues.length > 10) {
+        console.log(`  ... and ${issues.length - 10} more`);
+      }
+    }
+
+    return createSuccessResult(
+      { nodes: 0, edges: 0 },
+      { summary, issues }
+    );
+  }
+
+  /**
+   * Подсчитывает статистику по вызовам
+   */
+  private async countMethodCalls(graph: PluginContext['graph']): Promise<MethodCallStats> {
+    const stats: MethodCallStats = {
+      total: 0,
+      resolved: 0,
+      external: 0
+    };
+
+    // Подсчитываем все CALL узлы
+    for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+      stats.total++;
+
+      // Проверяем наличие "object" в метаданных (METHOD_CALL)
+      if ((node as NodeRecord & { object?: string }).object) {
+        stats.external++;
+      } else {
+        // CALL_SITE - проверяем есть ли CALLS ребро
+        const edges = await graph.getOutgoingEdges(node.id, ['CALLS']);
+        if (edges.length > 0) {
+          stats.resolved++;
+        }
+      }
+    }
+
+    return stats;
+  }
+}