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

package/src/plugins/discovery/workspaces/globResolver.ts

@@ -0,0 +1,229 @@
+/**
+ * Glob Resolver for Workspace Packages
+ *
+ * Resolves workspace glob patterns to actual directories containing package.json.
+ * Uses minimatch for pattern matching.
+ */
+
+import { readdirSync, statSync, existsSync, readFileSync, lstatSync } from 'fs';
+import { join, relative } from 'path';
+import { minimatch } from 'minimatch';
+import type { WorkspaceConfig } from './parsers.js';
+
+export interface WorkspacePackage {
+  path: string;
+  name: string;
+  relativePath: string;
+  packageJson: PackageJson;
+}
+
+interface PackageJson {
+  name?: string;
+  version?: string;
+  main?: string;
+  source?: string;
+  description?: string;
+  private?: boolean;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+/**
+ * Resolve workspace glob patterns to actual packages.
+ * Only directories with package.json are considered valid packages.
+ *
+ * @param projectPath - Root directory of the project
+ * @param config - Parsed workspace config with patterns and negativePatterns
+ * @returns Array of resolved workspace packages
+ */
+export function resolveWorkspacePackages(
+  projectPath: string,
+  config: WorkspaceConfig
+): WorkspacePackage[] {
+  const packages: WorkspacePackage[] = [];
+  const seen = new Set<string>();
+
+  // Expand all positive patterns
+  for (const pattern of config.patterns) {
+    const matches = expandGlob(projectPath, pattern);
+
+    for (const dir of matches) {
+      // Check for package.json
+      const pkgJsonPath = join(dir, 'package.json');
+      if (!existsSync(pkgJsonPath)) continue;
+
+      // Check negative patterns
+      const relPath = relative(projectPath, dir);
+      if (config.negativePatterns.some(neg => matchesPattern(relPath, neg))) continue;
+
+      // Avoid duplicates
+      if (seen.has(dir)) continue;
+      seen.add(dir);
+
+      // Parse package.json
+      let pkgJson: PackageJson;
+      try {
+        pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+      } catch {
+        // Skip malformed package.json
+        continue;
+      }
+
+      packages.push({
+        path: dir,
+        name: pkgJson.name || relPath.split('/').pop() || relPath,
+        relativePath: relPath,
+        packageJson: pkgJson
+      });
+    }
+  }
+
+  return packages;
+}
+
+/**
+ * Check if path matches pattern using minimatch.
+ * Normalizes path separators for cross-platform compatibility.
+ */
+function matchesPattern(path: string, pattern: string): boolean {
+  // Normalize path separators
+  const normalizedPath = path.replace(/\\/g, '/');
+  const normalizedPattern = pattern.replace(/\\/g, '/');
+  return minimatch(normalizedPath, normalizedPattern);
+}
+
+/**
+ * Expand glob pattern to actual directories.
+ */
+function expandGlob(basePath: string, pattern: string): string[] {
+  // Handle literal path (no wildcards)
+  if (!pattern.includes('*')) {
+    const fullPath = join(basePath, pattern);
+    if (existsSync(fullPath) && isDirectory(fullPath)) {
+      return [fullPath];
+    }
+    return [];
+  }
+
+  // Handle recursive glob (**)
+  if (pattern.includes('**')) {
+    return expandRecursiveGlob(basePath, pattern);
+  }
+
+  // Handle simple glob (packages/*)
+  return expandSimpleGlob(basePath, pattern);
+}
+
+/**
+ * Expand simple glob like "packages/*" or "apps/*".
+ */
+function expandSimpleGlob(basePath: string, pattern: string): string[] {
+  const parts = pattern.split('/');
+  const results: string[] = [];
+
+  // Find the first part with a wildcard
+  let currentPath = basePath;
+  let patternIndex = 0;
+
+  // Navigate to the parent directory of the glob
+  while (patternIndex < parts.length - 1) {
+    currentPath = join(currentPath, parts[patternIndex]);
+    patternIndex++;
+  }
+
+  // The last part contains the wildcard
+  const globPart = parts[patternIndex];
+
+  if (!existsSync(currentPath)) {
+    return [];
+  }
+
+  try {
+    const entries = readdirSync(currentPath);
+    for (const entry of entries) {
+      if (minimatch(entry, globPart)) {
+        const fullPath = join(currentPath, entry);
+        if (isDirectory(fullPath)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {
+    // Ignore permission errors
+  }
+
+  return results;
+}
+
+/**
+ * Expand recursive glob like "apps/**" or "libs/**".
+ * Recursively walks directories and matches against pattern.
+ */
+function expandRecursiveGlob(basePath: string, pattern: string): string[] {
+  const results: string[] = [];
+  const maxDepth = 10; // Safety limit
+
+  function walk(dir: string, depth: number): void {
+    if (depth > maxDepth) return;
+
+    try {
+      const entries = readdirSync(dir);
+
+      for (const entry of entries) {
+        // Skip hidden directories and node_modules
+        if (entry.startsWith('.') || entry === 'node_modules') continue;
+
+        const fullPath = join(dir, entry);
+
+        // Skip symlinks to avoid infinite loops
+        if (!isDirectory(fullPath)) continue;
+
+        const relPath = relative(basePath, fullPath);
+
+        // Check if this directory matches the pattern
+        if (minimatch(relPath, pattern, { dot: false })) {
+          results.push(fullPath);
+        }
+
+        // Continue walking regardless of match (** can match at any depth)
+        walk(fullPath, depth + 1);
+      }
+    } catch {
+      // Ignore permission errors
+    }
+  }
+
+  // Start walking from pattern prefix or base
+  const parts = pattern.split('**');
+  const prefix = parts[0].replace(/\/$/, ''); // Remove trailing slash
+
+  if (prefix) {
+    const startPath = join(basePath, prefix);
+    if (existsSync(startPath) && isDirectory(startPath)) {
+      // Check if the start path itself matches
+      const relPath = relative(basePath, startPath);
+      if (minimatch(relPath, pattern, { dot: false })) {
+        results.push(startPath);
+      }
+      walk(startPath, 0);
+    }
+  } else {
+    walk(basePath, 0);
+  }
+
+  return results;
+}
+
+/**
+ * Check if path is a directory (not following symlinks).
+ */
+function isDirectory(path: string): boolean {
+  try {
+    const stat = lstatSync(path);
+    // Return true for real directories, false for symlinks
+    return stat.isDirectory() && !stat.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}

package/src/plugins/discovery/workspaces/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Workspace Detection and Resolution
+ *
+ * Exports utilities for detecting workspace types and resolving workspace packages.
+ */
+
+export {
+  detectWorkspaceType,
+  type WorkspaceType,
+  type WorkspaceDetectionResult
+} from './detector.js';
+
+export {
+  parsePnpmWorkspace,
+  parseNpmWorkspace,
+  parseLernaConfig,
+  type WorkspaceConfig
+} from './parsers.js';
+
+export {
+  resolveWorkspacePackages,
+  type WorkspacePackage
+} from './globResolver.js';

package/src/plugins/discovery/workspaces/parsers.ts

@@ -0,0 +1,99 @@
+/**
+ * Workspace Config Parsers
+ *
+ * Parse workspace configuration files and extract glob patterns.
+ * Supports pnpm-workspace.yaml, package.json workspaces, and lerna.json.
+ */
+
+import { readFileSync } from 'fs';
+import { parse as parseYaml } from 'yaml';
+
+export interface WorkspaceConfig {
+  patterns: string[];
+  negativePatterns: string[];
+}
+
+/**
+ * Parse pnpm-workspace.yaml
+ *
+ * Format:
+ * packages:
+ *   - 'packages/*'
+ *   - 'apps/**'
+ *   - '!packages/internal'
+ */
+export function parsePnpmWorkspace(configPath: string): WorkspaceConfig {
+  const content = readFileSync(configPath, 'utf-8');
+  const config = parseYaml(content) as { packages?: string[] };
+
+  const patterns: string[] = [];
+  const negativePatterns: string[] = [];
+
+  for (const pattern of config.packages || []) {
+    if (pattern.startsWith('!')) {
+      negativePatterns.push(pattern.slice(1));
+    } else {
+      patterns.push(pattern);
+    }
+  }
+
+  return { patterns, negativePatterns };
+}
+
+/**
+ * Parse npm/yarn workspaces from package.json
+ *
+ * Formats:
+ * - Array: { "workspaces": ["packages/*", "apps/**"] }
+ * - Object (yarn): { "workspaces": { "packages": ["packages/*"], "nohoist": [...] } }
+ */
+export function parseNpmWorkspace(packageJsonPath: string): WorkspaceConfig {
+  const content = readFileSync(packageJsonPath, 'utf-8');
+  const pkg = JSON.parse(content) as {
+    workspaces?: string[] | { packages?: string[] };
+  };
+
+  let workspaces: string[] = [];
+
+  if (Array.isArray(pkg.workspaces)) {
+    workspaces = pkg.workspaces;
+  } else if (pkg.workspaces?.packages) {
+    workspaces = pkg.workspaces.packages;
+  }
+
+  const patterns: string[] = [];
+  const negativePatterns: string[] = [];
+
+  for (const pattern of workspaces) {
+    if (pattern.startsWith('!')) {
+      negativePatterns.push(pattern.slice(1));
+    } else {
+      patterns.push(pattern);
+    }
+  }
+
+  return { patterns, negativePatterns };
+}
+
+/**
+ * Parse lerna.json
+ *
+ * Format:
+ * { "packages": ["packages/*", "components/*"] }
+ *
+ * Default: ["packages/*"] if packages field is missing
+ */
+export function parseLernaConfig(lernaJsonPath: string): WorkspaceConfig {
+  const content = readFileSync(lernaJsonPath, 'utf-8');
+  const config = JSON.parse(content) as { packages?: string[] };
+
+  // Lerna defaults to packages/* if not specified
+  const packages = config.packages ?? ['packages/*'];
+
+  // Return empty if explicitly set to empty array
+  if (packages.length === 0) {
+    return { patterns: [], negativePatterns: [] };
+  }
+
+  return { patterns: packages, negativePatterns: [] };
+}

package/src/plugins/enrichment/AliasTracker.ts

@@ -80,8 +80,9 @@ export class AliasTracker extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const logger = this.log(context);
 
-    console.log('[AliasTracker] Starting alias resolution...');
+    logger.info('Starting alias resolution');
 
     let callsProcessed = 0;
     let aliasesFound = 0;
@@ -105,11 +106,11 @@ export class AliasTracker extends Plugin {
       unresolvedCalls.push(callNode);
     }
 
-    console.log(`[AliasTracker] Found ${unresolvedCalls.length} unresolved call sites`);
+    logger.info('Found unresolved call sites', { count: unresolvedCalls.length });
 
     // 2. Строим индекс алиасов: variableName -> EXPRESSION info
     const aliasIndex = await this.buildAliasIndex(graph);
-    console.log(`[AliasTracker] Found ${aliasIndex.size} potential aliases`);
+    logger.debug('Found potential aliases', { count: aliasIndex.size });
 
     // 3. Строим индекс методов для резолвинга
     const methodIndex = await this.buildMethodIndex(graph);
@@ -182,13 +183,18 @@ export class AliasTracker extends Plugin {
 
     // Алярм если были превышения глубины
     if (this.depthExceeded.length > 0) {
-      console.warn(`[AliasTracker] ⚠️  WARNING: ${this.depthExceeded.length} alias chain(s) exceeded max depth (${AliasTracker.MAX_DEPTH}):`);
-      for (const info of this.depthExceeded) {
-        console.warn(`  - ${info.file}:${info.name} (chain: ${info.chain.join(' → ')}...)`);
-      }
+      logger.warn('Alias chains exceeded max depth', {
+        count: this.depthExceeded.length,
+        maxDepth: AliasTracker.MAX_DEPTH,
+        examples: this.depthExceeded.slice(0, 5).map(info => ({
+          file: info.file,
+          name: info.name,
+          chain: info.chain.join(' → ')
+        }))
+      });
     }
 
-    console.log('[AliasTracker] Summary:', summary);
+    logger.info('Summary', summary);
 
     return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
   }

package/src/plugins/enrichment/HTTPConnectionEnricher.ts

@@ -56,6 +56,7 @@ export class HTTPConnectionEnricher extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph } = context;
+    const logger = this.log(context);
 
     try {
       // Собираем все http:route (backend endpoints)
@@ -70,13 +71,19 @@ export class HTTPConnectionEnricher extends Plugin {
         requests.push(node as HTTPRequestNode);
       }
 
-      console.log(`[HTTPConnectionEnricher] Found ${routes.length} routes, ${requests.length} requests`);
+      logger.debug('Found routes and requests', {
+        routes: routes.length,
+        requests: requests.length
+      });
 
       // Дедуплицируем по ID (из-за multi-service анализа)
       const uniqueRoutes = this.deduplicateById(routes);
       const uniqueRequests = this.deduplicateById(requests);
 
-      console.log(`[HTTPConnectionEnricher] Unique: ${uniqueRoutes.length} routes, ${uniqueRequests.length} requests`);
+      logger.info('Unique routes and requests', {
+        routes: uniqueRoutes.length,
+        requests: uniqueRequests.length
+      });
 
       let edgesCreated = 0;
       const connections: ConnectionInfo[] = [];
@@ -120,10 +127,10 @@ export class HTTPConnectionEnricher extends Plugin {
 
       // Логируем найденные связи
       if (connections.length > 0) {
-        console.log(`[HTTPConnectionEnricher] Connections found:`);
-        for (const conn of connections) {
-          console.log(`  ${conn.request} → ${conn.route}`);
-        }
+        logger.info('Connections found', {
+          count: connections.length,
+          examples: connections.slice(0, 5).map(c => `${c.request} → ${c.route}`)
+        });
       }
 
       return createSuccessResult(
@@ -136,7 +143,7 @@ export class HTTPConnectionEnricher extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[HTTPConnectionEnricher] Error:`, error);
+      logger.error('Error in HTTPConnectionEnricher', { error });
       return createErrorResult(error instanceof Error ? error : new Error(String(error)));
     }
   }

package/src/plugins/enrichment/ImportExportLinker.ts

@@ -42,7 +42,7 @@ export class ImportExportLinker extends Plugin {
       priority: 90, // Run early in enrichment, after analysis
       creates: {
         nodes: [],
-        edges: ['IMPORTS_FROM']
+        edges: ['IMPORTS', 'IMPORTS_FROM']
       },
       dependencies: ['JSASTAnalyzer'] // Requires IMPORT and EXPORT nodes
     };
@@ -50,26 +50,27 @@ export class ImportExportLinker extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const logger = this.log(context);
 
-    console.log('[ImportExportLinker] Starting import-export linking...');
+    logger.info('Starting import-export linking');
 
     const startTime = Date.now();
 
     // Step 1: Build EXPORT index - Map<file, Map<exportKey, exportNode>>
     const exportIndex = await this.buildExportIndex(graph);
     const indexTime = Date.now() - startTime;
-    console.log(`[ImportExportLinker] Indexed exports from ${exportIndex.size} files in ${indexTime}ms`);
+    logger.debug('Indexed exports', { files: exportIndex.size, time: `${indexTime}ms` });
 
     // Step 2: Build MODULE lookup - Map<file, moduleNode>
     const modulesByFile = await this.buildModuleLookup(graph);
-    console.log(`[ImportExportLinker] Indexed ${modulesByFile.size} modules`);
+    logger.debug('Indexed modules', { count: modulesByFile.size });
 
     // Step 3: Process all IMPORT nodes
     const imports: ImportNode[] = [];
     for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
       imports.push(node as ImportNode);
     }
-    console.log(`[ImportExportLinker] Found ${imports.length} imports to link`);
+    logger.info('Found imports to link', { count: imports.length });
 
     let edgesCreated = 0;
     let skipped = 0;
@@ -125,6 +126,18 @@ export class ImportExportLinker extends Plugin {
         continue;
       }
 
+      // Create MODULE -> IMPORTS -> MODULE edge for relative imports
+      const sourceModule = modulesByFile.get(imp.file!);
+      const targetModule = modulesByFile.get(targetFile);
+      if (sourceModule && targetModule) {
+        await graph.addEdge({
+          type: 'IMPORTS',
+          src: sourceModule.id,
+          dst: targetModule.id
+        });
+        edgesCreated++;
+      }
+
       // Find matching export based on import type
       const importType = imp.importType; // 'default', 'named', or 'namespace'
       let targetExport: ExportNode | undefined;
@@ -155,7 +168,12 @@ export class ImportExportLinker extends Plugin {
     }
 
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-    console.log(`[ImportExportLinker] Complete: ${edgesCreated} edges created, ${skipped} skipped, ${notFound} not found (${totalTime}s)`);
+    logger.info('Complete', {
+      edgesCreated,
+      skipped,
+      notFound,
+      time: `${totalTime}s`
+    });
 
     return createSuccessResult(
       { nodes: 0, edges: edgesCreated },

package/src/plugins/enrichment/MethodCallResolver.ts

@@ -48,8 +48,9 @@ export class MethodCallResolver extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const logger = this.log(context);
 
-    console.log('[MethodCallResolver] Starting method call resolution...');
+    logger.info('Starting method call resolution');
 
     let methodCallsProcessed = 0;
     let edgesCreated = 0;
@@ -64,14 +65,14 @@ export class MethodCallResolver extends Plugin {
       }
     }
 
-    console.log(`[MethodCallResolver] Found ${methodCalls.length} method calls to resolve`);
+    logger.info('Found method calls to resolve', { count: methodCalls.length });
 
     // Собираем все классы и их методы для быстрого поиска
-    const classMethodIndex = await this.buildClassMethodIndex(graph);
-    console.log(`[MethodCallResolver] Indexed ${classMethodIndex.size} classes`);
+    const classMethodIndex = await this.buildClassMethodIndex(graph, logger);
+    logger.info('Indexed classes', { count: classMethodIndex.size });
 
     // Собираем переменные и их типы (если известны)
-    const variableTypes = await this.buildVariableTypeIndex(graph);
+    const variableTypes = await this.buildVariableTypeIndex(graph, logger);
 
     const startTime = Date.now();
 
@@ -94,7 +95,12 @@ export class MethodCallResolver extends Plugin {
       if (methodCallsProcessed % 10 === 0) {
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         const avgTime = ((Date.now() - startTime) / methodCallsProcessed).toFixed(0);
-        console.log(`[MethodCallResolver] Progress: ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s, avg ${avgTime}ms/call)`);
+        logger.debug('Progress', {
+          processed: methodCallsProcessed,
+          total: methodCalls.length,
+          elapsed: `${elapsed}s`,
+          avgTime: `${avgTime}ms/call`
+        });
       }
 
       // Пропускаем внешние методы (console, Array.prototype, etc.)
@@ -135,7 +141,7 @@ export class MethodCallResolver extends Plugin {
       classesIndexed: classMethodIndex.size
     };
 
-    console.log('[MethodCallResolver] Summary:', summary);
+    logger.info('Summary', summary);
 
     return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
   }
@@ -143,7 +149,7 @@ export class MethodCallResolver extends Plugin {
   /**
    * Строит индекс классов и их методов
    */
-  private async buildClassMethodIndex(graph: PluginContext['graph']): Promise<Map<string, ClassEntry>> {
+  private async buildClassMethodIndex(graph: PluginContext['graph'], logger: ReturnType<typeof this.log>): Promise<Map<string, ClassEntry>> {
     const index = new Map<string, ClassEntry>();
     const startTime = Date.now();
     let classCount = 0;
@@ -151,7 +157,7 @@ export class MethodCallResolver extends Plugin {
     for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
       classCount++;
       if (classCount % 50 === 0) {
-        console.log(`[MethodCallResolver] Indexing classes: ${classCount}...`);
+        logger.debug('Indexing classes', { count: classCount });
       }
 
       const className = classNode.name as string;
@@ -180,7 +186,7 @@ export class MethodCallResolver extends Plugin {
     }
 
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
-    console.log(`[MethodCallResolver] Indexed ${index.size} class entries in ${totalTime}s`);
+    logger.debug('Indexed class entries', { count: index.size, time: `${totalTime}s` });
 
     return index;
   }
@@ -188,7 +194,7 @@ export class MethodCallResolver extends Plugin {
   /**
    * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
    */
-  private async buildVariableTypeIndex(graph: PluginContext['graph']): Promise<Map<string, string>> {
+  private async buildVariableTypeIndex(graph: PluginContext['graph'], logger: ReturnType<typeof this.log>): Promise<Map<string, string>> {
     const startTime = Date.now();
     const index = new Map<string, string>();
 
@@ -202,7 +208,7 @@ export class MethodCallResolver extends Plugin {
     }
 
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-    console.log(`[MethodCallResolver] Built variable type index: ${index.size} entries in ${elapsed}s`);
+    logger.debug('Built variable type index', { entries: index.size, time: `${elapsed}s` });
     return index;
   }
 

package/src/plugins/enrichment/MountPointResolver.ts

@@ -52,6 +52,7 @@ export class MountPointResolver extends Plugin {
   async execute(context: PluginContext): Promise<PluginResult> {
     try {
       const { graph } = context;
+      const logger = this.log(context);
 
       let endpointsUpdated = 0;
       let mountPointsProcessed = 0;
@@ -60,7 +61,7 @@ export class MountPointResolver extends Plugin {
       const allNodes = await graph.getAllNodes();
       const mountPoints = allNodes.filter(node => node.type === 'MOUNT_POINT') as MountPointNode[];
 
-      console.log(`[MountPointResolver] Found ${mountPoints.length} mount points`);
+      logger.info('Found mount points', { count: mountPoints.length });
 
       // For each top-level mount point (from app.use in index.js)
       // apply recursive resolver
@@ -129,7 +130,10 @@ export class MountPointResolver extends Plugin {
         mountPointsProcessed++;
       }
 
-      console.log(`[MountPointResolver] Updated ${endpointsUpdated} endpoints from ${mountPointsProcessed} mount points`);
+      logger.info('Updated endpoints', {
+        endpoints: endpointsUpdated,
+        mountPoints: mountPointsProcessed
+      });
 
       return createSuccessResult(
         { nodes: 0, edges: 0 },
@@ -137,7 +141,8 @@ export class MountPointResolver extends Plugin {
       );
 
     } catch (error) {
-      console.error(`[MountPointResolver] Error:`, error);
+      const logger = this.log(context);
+      logger.error('Error in MountPointResolver', { error });
       return createErrorResult(error as Error);
     }
   }