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

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

@@ -17,6 +17,9 @@ import type {
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import { IdGenerator } from '../IdGenerator.js';
+import { NodeFactory } from '../../../../core/NodeFactory.js';
 
 /**
  * Variable info extracted from pattern
@@ -100,22 +103,26 @@ interface VariableAssignmentInfo {
 export class VariableVisitor extends ASTVisitor {
   private extractVariableNamesFromPattern: ExtractVariableNamesCallback;
   private trackVariableAssignment: TrackVariableAssignmentCallback;
+  private scopeTracker?: ScopeTracker;
 
   /**
    * @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
+   * @param scopeTracker - Optional ScopeTracker for semantic ID generation
    */
   constructor(
     module: VisitorModule,
     collections: VisitorCollections,
     extractVariableNamesFromPattern: ExtractVariableNamesCallback,
-    trackVariableAssignment: TrackVariableAssignmentCallback
+    trackVariableAssignment: TrackVariableAssignmentCallback,
+    scopeTracker?: ScopeTracker
   ) {
     super(module, collections);
     this.extractVariableNamesFromPattern = extractVariableNamesFromPattern;
     this.trackVariableAssignment = trackVariableAssignment;
+    this.scopeTracker = scopeTracker;
   }
 
   getHandlers(): VisitorHandlers {
@@ -126,6 +133,7 @@ export class VariableVisitor extends ASTVisitor {
     const variableAssignments = this.collections.variableAssignments ?? [];
     const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 }) as CounterRef;
+    const scopeTracker = this.scopeTracker;
 
     const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
     const trackVariableAssignment = this.trackVariableAssignment;
@@ -151,9 +159,18 @@ export class VariableVisitor extends ASTVisitor {
               // 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++}`;
+              const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+
+              // Generate ID using centralized IdGenerator
+              const idGenerator = new IdGenerator(scopeTracker);
+              const varId = idGenerator.generate(
+                nodeType,
+                varInfo.name,
+                module.file,
+                varInfo.loc.start.line,
+                varInfo.loc.start.column,
+                varDeclCounterRef as CounterRef
+              );
 
               if (shouldBeConstant) {
                 // CONSTANT node
@@ -213,20 +230,23 @@ export class VariableVisitor extends ASTVisitor {
                     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
-                  });
+                  const expressionType = varInfo.propertyPath ? 'MemberExpression' : 'ArrayAccess';
+                  const expressionNode = NodeFactory.createExpression(
+                    expressionType,
+                    module.file,
+                    varInfo.loc.start.line,
+                    varInfo.loc.start.column,
+                    {
+                      path: expressionPath,
+                      baseName: initName,
+                      propertyPath: varInfo.propertyPath || undefined,
+                      arrayIndex: varInfo.arrayIndex
+                    }
+                  );
+
+                  const expressionId = expressionNode.id;
+                  (literals as LiteralExpressionInfo[]).push(expressionNode as LiteralExpressionInfo);
 
                   // Create ASSIGNED_FROM edge: VARIABLE -> EXPRESSION
                   (variableAssignments as VariableAssignmentInfo[]).push({

package/src/plugins/discovery/MonorepoServiceDiscovery.ts

@@ -57,10 +57,11 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
     const { projectPath, graph } = context;
     const servicesPath = join(projectPath!, this.servicesDir);
 
-    console.log(`[MonorepoServiceDiscovery] Looking for services in: ${servicesPath}`);
+    logger.debug('Looking for services', { servicesPath });
 
     if (!existsSync(servicesPath)) {
       return createErrorResult(
@@ -71,7 +72,7 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
     try {
       const services: ServiceInfo[] = [];
       const entries = readdirSync(servicesPath);
-      console.log(`[MonorepoServiceDiscovery] Found ${entries.length} entries`);
+      logger.debug('Found entries', { count: entries.length });
 
       for (const entry of entries) {
         const fullPath = join(servicesPath, entry);

package/src/plugins/discovery/SimpleProjectDiscovery.ts

@@ -11,6 +11,7 @@ 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';
+import { resolveSourceEntrypoint } from './resolveSourceEntrypoint.js';
 
 /**
  * Service info returned in metadata
@@ -33,6 +34,7 @@ interface PackageJson {
   name?: string;
   version?: string;
   main?: string;
+  source?: string;
   description?: string;
   dependencies?: Record<string, string>;
 }
@@ -70,7 +72,10 @@ export class SimpleProjectDiscovery extends Plugin {
     try {
       const packageJson: PackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
       const serviceName = packageJson.name || 'unnamed-service';
-      const entrypoint = packageJson.main || 'index.js';
+      // Prefer TypeScript source over compiled output
+      const entrypoint = resolveSourceEntrypoint(projectPath, packageJson)
+        ?? packageJson.main
+        ?? 'index.js';
 
       // Используем NodeFactory для создания SERVICE ноды
       const serviceNode = NodeFactory.createService(serviceName, projectPath, {

package/src/plugins/discovery/WorkspaceDiscovery.ts

@@ -0,0 +1,177 @@
+/**
+ * WorkspaceDiscovery - Discovery plugin for npm/pnpm/yarn/lerna workspaces
+ *
+ * Detects workspace configuration and creates SERVICE nodes for each package.
+ * Priority: 110 (higher than MonorepoServiceDiscovery at 100)
+ *
+ * Supports:
+ * - pnpm-workspace.yaml
+ * - package.json workspaces (npm/yarn)
+ * - lerna.json
+ */
+
+import { DiscoveryPlugin } from './DiscoveryPlugin.js';
+import { createSuccessResult, createErrorResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import { detectWorkspaceType } from './workspaces/detector.js';
+import { parsePnpmWorkspace, parseNpmWorkspace, parseLernaConfig } from './workspaces/parsers.js';
+import { resolveWorkspacePackages, type WorkspacePackage } from './workspaces/globResolver.js';
+import { NodeFactory } from '../../core/NodeFactory.js';
+import { resolveSourceEntrypoint } from './resolveSourceEntrypoint.js';
+
+/**
+ * Service info returned in result metadata
+ */
+interface ServiceInfo {
+  id: string;
+  name: string;
+  path: string;
+  type: string;
+  metadata: {
+    workspaceType: string;
+    relativePath: string;
+    entrypoint: string | null;
+    packageJson: Record<string, unknown>;
+  };
+}
+
+export class WorkspaceDiscovery extends DiscoveryPlugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'WorkspaceDiscovery',
+      phase: 'DISCOVERY',
+      priority: 110, // Higher than MonorepoServiceDiscovery (100)
+      creates: {
+        nodes: ['SERVICE'],
+        edges: []
+      },
+      dependencies: []
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const logger = this.log(context);
+    const { projectPath, graph } = context;
+
+    // Validate projectPath
+    if (!projectPath) {
+      return createErrorResult(new Error('projectPath is required'));
+    }
+
+    logger.debug('Detecting workspace type', { projectPath });
+
+    // Step 1: Detect workspace type
+    const detection = detectWorkspaceType(projectPath);
+
+    if (!detection.type) {
+      logger.debug('Not a workspace project, skipping');
+      return createSuccessResult({ nodes: 0, edges: 0 }, {
+        services: [],
+        skipped: true,
+        reason: 'No workspace configuration found'
+      });
+    }
+
+    logger.info('Workspace detected', {
+      type: detection.type,
+      configPath: detection.configPath
+    });
+
+    // Step 2: Parse workspace configuration
+    let config;
+    try {
+      switch (detection.type) {
+        case 'pnpm':
+          config = parsePnpmWorkspace(detection.configPath!);
+          break;
+        case 'npm':
+        case 'yarn':
+          config = parseNpmWorkspace(detection.configPath!);
+          break;
+        case 'lerna':
+          config = parseLernaConfig(detection.configPath!);
+          break;
+        default:
+          throw new Error(`Unknown workspace type: ${detection.type}`);
+      }
+    } catch (error) {
+      return createErrorResult(error as Error);
+    }
+
+    logger.debug('Workspace config parsed', {
+      patterns: config.patterns,
+      negativePatterns: config.negativePatterns
+    });
+
+    // Step 3: Resolve patterns to packages
+    const packages = resolveWorkspacePackages(projectPath, config);
+
+    logger.info('Workspace packages resolved', { count: packages.length });
+
+    // Step 4: Create SERVICE nodes
+    const services: ServiceInfo[] = [];
+
+    for (const pkg of packages) {
+      const serviceNode = this.createServiceNode(pkg, detection.type!, projectPath);
+
+      await graph.addNode(serviceNode);
+
+      services.push({
+        id: serviceNode.id,
+        name: pkg.name,
+        path: pkg.path,
+        type: 'workspace-package',
+        metadata: {
+          workspaceType: detection.type!,
+          relativePath: pkg.relativePath,
+          entrypoint: serviceNode.entrypoint,
+          packageJson: pkg.packageJson as Record<string, unknown>
+        }
+      });
+    }
+
+    logger.info('Services created from workspace', {
+      count: services.length,
+      workspaceType: detection.type
+    });
+
+    return createSuccessResult(
+      { nodes: services.length, edges: 0 },
+      { services, workspaceType: detection.type }
+    );
+  }
+
+  /**
+   * Create SERVICE node from workspace package.
+   */
+  private createServiceNode(pkg: WorkspacePackage, workspaceType: string, _projectPath: string) {
+    // Resolve entrypoint (prefer TypeScript source)
+    const entrypoint = resolveSourceEntrypoint(pkg.path, pkg.packageJson)
+      ?? (pkg.packageJson.main as string | undefined)
+      ?? null;
+
+    const serviceNode = NodeFactory.createService(pkg.name, pkg.path, {
+      discoveryMethod: 'workspace',
+      entrypoint: entrypoint ?? undefined,
+      version: pkg.packageJson.version as string | undefined,
+      description: pkg.packageJson.description as string | undefined,
+      dependencies: Object.keys(pkg.packageJson.dependencies || {})
+    });
+
+    // Add metadata for workspace-specific information
+    // BaseNodeRecord supports optional metadata field
+    const nodeWithMetadata = serviceNode as typeof serviceNode & { metadata: Record<string, unknown> };
+    nodeWithMetadata.metadata = {
+      workspaceType,
+      discoveryMethod: 'workspace',
+      relativePath: pkg.relativePath,
+      version: pkg.packageJson.version as string | undefined,
+      description: pkg.packageJson.description as string | undefined,
+      private: pkg.packageJson.private as boolean | undefined,
+      dependencies: Object.keys(pkg.packageJson.dependencies || {}),
+      entrypoint: entrypoint
+    };
+
+    return nodeWithMetadata;
+  }
+}

package/src/plugins/discovery/resolveSourceEntrypoint.ts

@@ -0,0 +1,103 @@
+/**
+ * Resolves TypeScript source entrypoints for projects.
+ *
+ * This utility prefers TypeScript source files (src/index.ts) over compiled
+ * output (dist/index.js) when analyzing TypeScript projects.
+ *
+ * Resolution order:
+ * 1. If no tsconfig.json exists -> return null (not a TypeScript project)
+ * 2. Check package.json "source" field (explicit source declaration)
+ * 3. Try standard TypeScript source candidates
+ * 4. Return null if no source found (caller should fallback to main)
+ *
+ * @module resolveSourceEntrypoint
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Package.json fields relevant for source resolution
+ */
+export interface PackageJsonForResolution {
+  main?: string;
+  source?: string;  // Used by bundlers like Parcel
+}
+
+/**
+ * Standard TypeScript source candidates in priority order.
+ *
+ * Order rationale:
+ * - src/ is the most common convention
+ * - lib/ is used by some projects
+ * - root-level is fallback
+ * - index is more common than main
+ * - .ts preferred over .tsx over .mts
+ */
+const TS_SOURCE_CANDIDATES = [
+  'src/index.ts',
+  'src/index.tsx',
+  'src/index.mts',
+  'src/main.ts',
+  'src/main.tsx',
+  'lib/index.ts',
+  'lib/index.tsx',
+  'index.ts',
+  'index.tsx',
+  'index.mts',
+  'main.ts',
+  'main.tsx',
+] as const;
+
+/**
+ * Resolves the source entrypoint for a project, preferring TypeScript source
+ * over compiled output.
+ *
+ * @param projectPath - Absolute path to the project/service directory
+ * @param packageJson - Parsed package.json content (only relevant fields needed)
+ * @returns Source entrypoint relative to projectPath, or null if not found
+ *
+ * @example
+ * // TypeScript project with src/index.ts
+ * resolveSourceEntrypoint('/path/to/project', { main: 'dist/index.js' })
+ * // Returns: 'src/index.ts'
+ *
+ * @example
+ * // JavaScript project (no tsconfig.json)
+ * resolveSourceEntrypoint('/path/to/project', { main: 'index.js' })
+ * // Returns: null
+ *
+ * @example
+ * // TypeScript project with explicit source field
+ * resolveSourceEntrypoint('/path/to/project', { main: 'dist/index.js', source: 'lib/entry.ts' })
+ * // Returns: 'lib/entry.ts' (if file exists)
+ */
+export function resolveSourceEntrypoint(
+  projectPath: string,
+  packageJson: PackageJsonForResolution
+): string | null {
+  // Step 1: Check for TypeScript project indicator
+  const tsconfigPath = join(projectPath, 'tsconfig.json');
+  if (!existsSync(tsconfigPath)) {
+    return null; // Not a TypeScript project
+  }
+
+  // Step 2: Check package.json "source" field (explicit source declaration)
+  if (packageJson.source) {
+    const sourcePath = join(projectPath, packageJson.source);
+    if (existsSync(sourcePath)) {
+      return packageJson.source;
+    }
+  }
+
+  // Step 3: Try standard TypeScript source candidates
+  for (const candidate of TS_SOURCE_CANDIDATES) {
+    const candidatePath = join(projectPath, candidate);
+    if (existsSync(candidatePath)) {
+      return candidate;
+    }
+  }
+
+  // Step 4: Not found - caller should fallback to main
+  return null;
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Workspace Type Detector
+ *
+ * Detects which workspace system is used in a project by checking
+ * for configuration files in priority order: pnpm > npm/yarn > lerna.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export type WorkspaceType = 'pnpm' | 'npm' | 'yarn' | 'lerna' | null;
+
+export interface WorkspaceDetectionResult {
+  type: WorkspaceType;
+  configPath: string | null;
+  rootPath: string;
+}
+
+/**
+ * Detect workspace type by checking for configuration files.
+ * Priority: pnpm > npm/yarn > lerna (most specific first)
+ *
+ * @param projectPath - Root directory of the project
+ * @returns Detection result with type, config path, and root path
+ */
+export function detectWorkspaceType(projectPath: string): WorkspaceDetectionResult {
+  // 1. Check for pnpm-workspace.yaml (highest priority)
+  const pnpmYaml = join(projectPath, 'pnpm-workspace.yaml');
+  const pnpmYml = join(projectPath, 'pnpm-workspace.yml');
+
+  if (existsSync(pnpmYaml)) {
+    return { type: 'pnpm', configPath: pnpmYaml, rootPath: projectPath };
+  }
+  if (existsSync(pnpmYml)) {
+    return { type: 'pnpm', configPath: pnpmYml, rootPath: projectPath };
+  }
+
+  // 2. Check for npm/yarn workspaces in package.json
+  const packageJsonPath = join(projectPath, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    try {
+      const content = readFileSync(packageJsonPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      if (pkg.workspaces) {
+        // Both npm and yarn use package.json workspaces - detect as 'npm'
+        // The format is compatible for both
+        return { type: 'npm', configPath: packageJsonPath, rootPath: projectPath };
+      }
+    } catch {
+      // Ignore JSON parse errors
+    }
+  }
+
+  // 3. Check for lerna.json
+  const lernaJsonPath = join(projectPath, 'lerna.json');
+  if (existsSync(lernaJsonPath)) {
+    return { type: 'lerna', configPath: lernaJsonPath, rootPath: projectPath };
+  }
+
+  // No workspace configuration found
+  return { type: null, configPath: null, rootPath: projectPath };
+}