@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/src/logging/Logger.ts

@@ -0,0 +1,152 @@
+/**
+ * Logger - Lightweight logging for Grafema
+ *
+ * Features:
+ * - 5 log levels: silent, errors, warnings, info, debug
+ * - Context support for structured logging
+ * - No external dependencies
+ * - Safe handling of circular references
+ *
+ * Usage:
+ *   const logger = createLogger('info');
+ *   logger.info('Processing files', { count: 150 });
+ */
+
+/**
+ * Log level type
+ */
+export type LogLevel = 'silent' | 'errors' | 'warnings' | 'info' | 'debug';
+
+/**
+ * Logger interface
+ */
+export interface Logger {
+  error(message: string, context?: Record<string, unknown>): void;
+  warn(message: string, context?: Record<string, unknown>): void;
+  info(message: string, context?: Record<string, unknown>): void;
+  debug(message: string, context?: Record<string, unknown>): void;
+  trace(message: string, context?: Record<string, unknown>): void;
+}
+
+/**
+ * Log level priorities (higher = more verbose)
+ */
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  silent: 0,
+  errors: 1,
+  warnings: 2,
+  info: 3,
+  debug: 4,
+};
+
+/**
+ * Minimum level required for each method
+ */
+const METHOD_LEVELS = {
+  error: LOG_LEVEL_PRIORITY.errors,
+  warn: LOG_LEVEL_PRIORITY.warnings,
+  info: LOG_LEVEL_PRIORITY.info,
+  debug: LOG_LEVEL_PRIORITY.debug,
+  trace: LOG_LEVEL_PRIORITY.debug,
+};
+
+/**
+ * Safe JSON stringify that handles circular references
+ */
+function safeStringify(obj: unknown): string {
+  const seen = new WeakSet();
+  return JSON.stringify(obj, (_key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+    return value;
+  });
+}
+
+/**
+ * Format log message with optional context
+ */
+function formatMessage(message: string, context?: Record<string, unknown>): string {
+  if (!context || Object.keys(context).length === 0) {
+    return message;
+  }
+  try {
+    return `${message} ${safeStringify(context)}`;
+  } catch {
+    return `${message} [context serialization failed]`;
+  }
+}
+
+/**
+ * Console-based Logger implementation
+ *
+ * Respects log level threshold - methods below threshold are no-ops.
+ */
+export class ConsoleLogger implements Logger {
+  private readonly level: LogLevel;
+  private readonly priority: number;
+
+  constructor(logLevel: LogLevel = 'info') {
+    this.level = logLevel;
+    this.priority = LOG_LEVEL_PRIORITY[logLevel];
+  }
+
+  private shouldLog(methodLevel: number): boolean {
+    return this.priority >= methodLevel;
+  }
+
+  error(message: string, context?: Record<string, unknown>): void {
+    if (!this.shouldLog(METHOD_LEVELS.error)) return;
+    try {
+      console.error(formatMessage(`[ERROR] ${message}`, context));
+    } catch {
+      console.log(`[ERROR] ${message} [logging failed]`);
+    }
+  }
+
+  warn(message: string, context?: Record<string, unknown>): void {
+    if (!this.shouldLog(METHOD_LEVELS.warn)) return;
+    try {
+      console.warn(formatMessage(`[WARN] ${message}`, context));
+    } catch {
+      console.log(`[WARN] ${message} [logging failed]`);
+    }
+  }
+
+  info(message: string, context?: Record<string, unknown>): void {
+    if (!this.shouldLog(METHOD_LEVELS.info)) return;
+    try {
+      console.info(formatMessage(`[INFO] ${message}`, context));
+    } catch {
+      console.log(`[INFO] ${message} [logging failed]`);
+    }
+  }
+
+  debug(message: string, context?: Record<string, unknown>): void {
+    if (!this.shouldLog(METHOD_LEVELS.debug)) return;
+    try {
+      console.debug(formatMessage(`[DEBUG] ${message}`, context));
+    } catch {
+      console.log(`[DEBUG] ${message} [logging failed]`);
+    }
+  }
+
+  trace(message: string, context?: Record<string, unknown>): void {
+    if (!this.shouldLog(METHOD_LEVELS.trace)) return;
+    try {
+      console.debug(formatMessage(`[TRACE] ${message}`, context));
+    } catch {
+      console.log(`[TRACE] ${message} [logging failed]`);
+    }
+  }
+}
+
+/**
+ * Create a Logger instance with the specified log level
+ */
+export function createLogger(level: LogLevel): Logger {
+  return new ConsoleLogger(level);
+}

package/src/plugins/Plugin.ts

@@ -14,6 +14,7 @@ import type {
   PluginResult,
   IPlugin,
   NodeFilter,
+  Logger,
 } from '@grafema/types';
 import type { NodeRecord } from '@grafema/types';
 
@@ -71,4 +72,45 @@ export abstract class Plugin implements IPlugin {
     }
     return modules;
   }
+
+  /**
+   * Get a logger from context with console fallback for backward compatibility.
+   */
+  protected log(context: PluginContext): Logger {
+    if (context.logger) {
+      return context.logger;
+    }
+
+    // Fallback to console for backward compatibility
+    const safeStringify = (obj: Record<string, unknown>): string => {
+      try {
+        const seen = new WeakSet();
+        return JSON.stringify(obj, (_key, value) => {
+          if (typeof value === 'object' && value !== null) {
+            if (seen.has(value)) return '[Circular]';
+            seen.add(value);
+          }
+          return value;
+        });
+      } catch {
+        return '[serialization failed]';
+      }
+    };
+
+    const format = (msg: string, ctx?: Record<string, unknown>) =>
+      ctx ? `${msg} ${safeStringify(ctx)}` : msg;
+
+    return {
+      error: (msg: string, ctx?: Record<string, unknown>) =>
+        console.error(`[ERROR] ${format(msg, ctx)}`),
+      warn: (msg: string, ctx?: Record<string, unknown>) =>
+        console.warn(`[WARN] ${format(msg, ctx)}`),
+      info: (msg: string, ctx?: Record<string, unknown>) =>
+        console.log(`[INFO] ${format(msg, ctx)}`),
+      debug: (msg: string, ctx?: Record<string, unknown>) =>
+        console.debug(`[DEBUG] ${format(msg, ctx)}`),
+      trace: (msg: string, ctx?: Record<string, unknown>) =>
+        console.debug(`[TRACE] ${format(msg, ctx)}`),
+    };
+  }
 }

package/src/plugins/analysis/DatabaseAnalyzer.ts

@@ -11,6 +11,7 @@ import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { getLine, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -29,6 +30,7 @@ interface DatabaseQueryNode {
   method: string;
   file: string;
   line: number;
+  column: number;
 }
 
 /**
@@ -55,12 +57,14 @@ export class DatabaseAnalyzer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
-      console.log(`[DatabaseAnalyzer] Processing ${modules.length} modules...`);
+      logger.info('Processing modules', { count: modules.length });
 
       // Получаем все FUNCTION ноды для связывания
       const functions = await this.getFunctions(graph);
@@ -82,13 +86,16 @@ export class DatabaseAnalyzer extends Plugin {
         if ((i + 1) % 20 === 0 || i === modules.length - 1) {
           const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
           const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-          console.log(
-            `[DatabaseAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`
-          );
+          logger.debug('Progress', {
+            current: i + 1,
+            total: modules.length,
+            elapsed: `${elapsed}s`,
+            avgTime: `${avgTime}ms/module`
+          });
         }
       }
 
-      console.log(`[DatabaseAnalyzer] Created ${queriesCreated} queries, ${tablesCreated} tables`);
+      logger.info('Analysis complete', { queriesCreated, tablesCreated });
 
       return createSuccessResult(
         {
@@ -101,7 +108,7 @@ export class DatabaseAnalyzer extends Plugin {
         }
       );
     } catch (error) {
-      console.error(`[DatabaseAnalyzer] Error:`, error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }
@@ -218,7 +225,8 @@ export class DatabaseAnalyzer extends Plugin {
                   object: objectName,
                   method: methodName,
                   file: module.file!,
-                  line: node.loc!.start.line
+                  line: getLine(node),
+                  column: getColumn(node)
                 });
               }
             }
@@ -292,7 +300,7 @@ export class DatabaseAnalyzer extends Plugin {
         }
       }
     } catch (error) {
-      console.error(`[DatabaseAnalyzer] Error analyzing ${module.file}:`, (error as Error).message);
+      // Silent - per-module errors shouldn't spam logs
     }
 
     return {

package/src/plugins/analysis/ExpressAnalyzer.ts

@@ -6,12 +6,14 @@
 import { readFileSync } from 'fs';
 import { parse, ParserPlugin } from '@babel/parser';
 import traverseModule from '@babel/traverse';
-import { dirname, resolve } from 'path';
+import { dirname, resolve, relative } from 'path';
 import type { CallExpression, ImportDeclaration, StringLiteral, TemplateLiteral, Identifier, MemberExpression } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { NetworkRequestNode } from '../../core/nodes/NetworkRequestNode.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = (traverseModule as any).default || traverseModule;
@@ -27,6 +29,7 @@ interface EndpointNode {
   localPath: string;
   file: string;
   line: number;
+  column: number;
   mountedOn: string;
 }
 
@@ -41,6 +44,7 @@ interface MountPointNode {
   targetVariable: string | null;
   file: string;
   line: number;
+  column: number;
   mountedOn: string;
 }
 
@@ -77,17 +81,14 @@ export class ExpressAnalyzer extends Plugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+
     try {
       const { graph } = context;
 
-      // Создаём net:request ноду (дедупликация в GraphBackend)
-      const networkId = 'net:request#__network__';
-      await graph.addNode({
-        id: networkId,
-        type: 'net:request',
-        name: '__network__',
-        description: 'External HTTP network'
-      });
+      // Create net:request singleton (GraphBackend handles deduplication)
+      const networkNode = NetworkRequestNode.create();
+      await graph.addNode(networkNode);
 
       // Получаем все MODULE ноды
       const modules = await this.getModules(graph);
@@ -98,13 +99,13 @@ export class ExpressAnalyzer extends Plugin {
 
       // Анализируем каждый модуль
       for (const module of modules) {
-        const result = await this.analyzeModule(module, graph, networkId);
+        const result = await this.analyzeModule(module, graph, networkNode.id);
         endpointsCreated += result.endpoints;
         mountPointsCreated += result.mountPoints;
         edgesCreated += result.edges;
       }
 
-      console.log(`[ExpressAnalyzer] Created ${endpointsCreated} endpoints, ${mountPointsCreated} mount points`);
+      logger.info('Analysis complete', { endpointsCreated, mountPointsCreated });
 
       return createSuccessResult(
         {
@@ -117,7 +118,7 @@ export class ExpressAnalyzer extends Plugin {
         }
       );
     } catch (error) {
-      console.error(`[ExpressAnalyzer] Error:`, error);
+      logger.error('Analysis failed', { error });
       return createErrorResult(error as Error);
     }
   }
@@ -169,7 +170,7 @@ export class ExpressAnalyzer extends Plugin {
           imports.push({
             source,
             specifiers,
-            line: importNode.loc!.start.line
+            line: getLine(importNode)
           });
         }
       });
@@ -204,13 +205,14 @@ export class ExpressAnalyzer extends Plugin {
               if (routePath) {
                 const method = methodName.toUpperCase();
                 endpoints.push({
-                  id: `http:route#${method}:${routePath}#${module.file}#${node.loc!.start.line}`,
+                  id: `http:route#${method}:${routePath}#${module.file}#${getLine(node)}`,
                   type: 'http:route',
                   method: method,
                   path: routePath,
                   localPath: routePath,
                   file: module.file!,
-                  line: node.loc!.start.line,
+                  line: getLine(node),
+                  column: getColumn(node),
                   mountedOn: objectName
                 });
               }
@@ -281,13 +283,14 @@ export class ExpressAnalyzer extends Plugin {
               // Создаём mount point
               if ((targetFunction || targetVariable) && prefix) {
                 mountPoints.push({
-                  id: `express:mount#${prefix}#${module.file}#${node.loc!.start.line}`,
+                  id: `express:mount#${prefix}#${module.file}#${getLine(node)}`,
                   type: 'express:mount',
                   prefix: prefix,
                   targetFunction: targetFunction,
                   targetVariable: targetVariable,
                   file: module.file!,
-                  line: node.loc!.start.line,
+                  line: getLine(node),
+                  column: getColumn(node),
                   mountedOn: objectName
                 });
               }
@@ -336,7 +339,7 @@ export class ExpressAnalyzer extends Plugin {
         edgesCreated += mountEdges;
       }
     } catch (error) {
-      console.error(`[ExpressAnalyzer] Error analyzing ${module.file}:`, (error as Error).message);
+      // Silent - per-module errors shouldn't spam logs
     }
 
     return {
@@ -382,7 +385,18 @@ export class ExpressAnalyzer extends Plugin {
 
     // Если нашли целевой модуль, создаем MOUNTS ребро
     if (targetModulePath) {
-      const targetModuleId = `${targetModulePath}:MODULE:${targetModulePath}:0`;
+      // Derive project root from module's absolute and relative paths
+      // module.file is absolute path, module.name is relative path
+      const moduleAbsPath = module.file!;
+      const moduleRelPath = module.name!;
+      // projectRoot = absolute path minus relative path suffix
+      const projectRoot = moduleAbsPath.endsWith(moduleRelPath)
+        ? moduleAbsPath.slice(0, moduleAbsPath.length - moduleRelPath.length)
+        : dirname(moduleAbsPath); // fallback
+
+      // Convert target absolute path to relative path for semantic ID
+      const targetRelativePath = relative(projectRoot, targetModulePath);
+      const targetModuleId = `${targetRelativePath}->global->MODULE->module`;
 
       // Проверяем что модуль существует в графе
       const targetModule = await graph.getNode(targetModuleId);