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

package/dist/plugins/discovery/resolveSourceEntrypoint.js

@@ -0,0 +1,86 @@
+/**
+ * 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';
+/**
+ * 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',
+];
+/**
+ * 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, packageJson) {
+    // 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/dist/plugins/discovery/workspaces/detector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Workspace Type Detector
+ *
+ * Detects which workspace system is used in a project by checking
+ * for configuration files in priority order: pnpm > npm/yarn > lerna.
+ */
+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 declare function detectWorkspaceType(projectPath: string): WorkspaceDetectionResult;
+//# sourceMappingURL=detector.d.ts.map

package/dist/plugins/discovery/workspaces/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../../../src/plugins/discovery/workspaces/detector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAErE,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB,CAqCjF"}

package/dist/plugins/discovery/workspaces/detector.js

@@ -0,0 +1,49 @@
+/**
+ * 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';
+/**
+ * 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) {
+    // 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 };
+}

package/dist/plugins/discovery/workspaces/globResolver.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Glob Resolver for Workspace Packages
+ *
+ * Resolves workspace glob patterns to actual directories containing package.json.
+ * Uses minimatch for pattern matching.
+ */
+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 declare function resolveWorkspacePackages(projectPath: string, config: WorkspaceConfig): WorkspacePackage[];
+export {};
+//# sourceMappingURL=globResolver.d.ts.map

package/dist/plugins/discovery/workspaces/globResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globResolver.d.ts","sourceRoot":"","sources":["../../../../src/plugins/discovery/workspaces/globResolver.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,UAAU,WAAW;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,eAAe,GACtB,gBAAgB,EAAE,CAwCpB"}

package/dist/plugins/discovery/workspaces/globResolver.js

@@ -0,0 +1,184 @@
+/**
+ * Glob Resolver for Workspace Packages
+ *
+ * Resolves workspace glob patterns to actual directories containing package.json.
+ * Uses minimatch for pattern matching.
+ */
+import { readdirSync, existsSync, readFileSync, lstatSync } from 'fs';
+import { join, relative } from 'path';
+import { minimatch } from 'minimatch';
+/**
+ * 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, config) {
+    const packages = [];
+    const seen = new Set();
+    // 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;
+            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, pattern) {
+    // 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, pattern) {
+    // 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, pattern) {
+    const parts = pattern.split('/');
+    const results = [];
+    // 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, pattern) {
+    const results = [];
+    const maxDepth = 10; // Safety limit
+    function walk(dir, depth) {
+        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) {
+    try {
+        const stat = lstatSync(path);
+        // Return true for real directories, false for symlinks
+        return stat.isDirectory() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plugins/discovery/workspaces/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/discovery/workspaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/discovery/workspaces/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,wBAAwB,EAC9B,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,KAAK,eAAe,EACrB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,wBAAwB,EACxB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC"}

package/dist/plugins/discovery/workspaces/index.js

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

package/dist/plugins/discovery/workspaces/parsers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Workspace Config Parsers
+ *
+ * Parse workspace configuration files and extract glob patterns.
+ * Supports pnpm-workspace.yaml, package.json workspaces, and lerna.json.
+ */
+export interface WorkspaceConfig {
+    patterns: string[];
+    negativePatterns: string[];
+}
+/**
+ * Parse pnpm-workspace.yaml
+ *
+ * Format:
+ * packages:
+ *   - 'packages/*'
+ *   - 'apps/**'
+ *   - '!packages/internal'
+ */
+export declare function parsePnpmWorkspace(configPath: string): WorkspaceConfig;
+/**
+ * Parse npm/yarn workspaces from package.json
+ *
+ * Formats:
+ * - Array: { "workspaces": ["packages/*", "apps/**"] }
+ * - Object (yarn): { "workspaces": { "packages": ["packages/*"], "nohoist": [...] } }
+ */
+export declare function parseNpmWorkspace(packageJsonPath: string): WorkspaceConfig;
+/**
+ * Parse lerna.json
+ *
+ * Format:
+ * { "packages": ["packages/*", "components/*"] }
+ *
+ * Default: ["packages/*"] if packages field is missing
+ */
+export declare function parseLernaConfig(lernaJsonPath: string): WorkspaceConfig;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/plugins/discovery/workspaces/parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.d.ts","sourceRoot":"","sources":["../../../../src/plugins/discovery/workspaces/parsers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,CAgBtE;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,MAAM,GAAG,eAAe,CA0B1E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,eAAe,CAavE"}

package/dist/plugins/discovery/workspaces/parsers.js

@@ -0,0 +1,80 @@
+/**
+ * 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';
+/**
+ * Parse pnpm-workspace.yaml
+ *
+ * Format:
+ * packages:
+ *   - 'packages/*'
+ *   - 'apps/**'
+ *   - '!packages/internal'
+ */
+export function parsePnpmWorkspace(configPath) {
+    const content = readFileSync(configPath, 'utf-8');
+    const config = parseYaml(content);
+    const patterns = [];
+    const negativePatterns = [];
+    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) {
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    let workspaces = [];
+    if (Array.isArray(pkg.workspaces)) {
+        workspaces = pkg.workspaces;
+    }
+    else if (pkg.workspaces?.packages) {
+        workspaces = pkg.workspaces.packages;
+    }
+    const patterns = [];
+    const negativePatterns = [];
+    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) {
+    const content = readFileSync(lernaJsonPath, 'utf-8');
+    const config = JSON.parse(content);
+    // 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/dist/plugins/enrichment/AliasTracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AliasTracker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/AliasTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgDhF,qBAAa,YAAa,SAAQ,MAAM;IACtC,MAAM,CAAC,SAAS,SAAM;IACtB,OAAO,CAAC,aAAa,CAA2B;IAEhD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAmH5D;;;OAGG;YACW,eAAe;IAkC7B;;OAEG;YACW,oBAAoB;IAsDlC;;OAEG;YACW,gBAAgB;IAyB9B;;OAEG;YACW,wBAAwB;CA6EvC"}
+{"version":3,"file":"AliasTracker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/AliasTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgDhF,qBAAa,YAAa,SAAQ,MAAM;IACtC,MAAM,CAAC,SAAS,SAAM;IACtB,OAAO,CAAC,aAAa,CAA2B;IAEhD,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyH5D;;;OAGG;YACW,eAAe;IAkC7B;;OAEG;YACW,oBAAoB;IAsDlC;;OAEG;YACW,gBAAgB;IAyB9B;;OAEG;YACW,wBAAwB;CA6EvC"}

package/dist/plugins/enrichment/AliasTracker.js

@@ -29,7 +29,8 @@ export class AliasTracker extends Plugin {
     }
     async execute(context) {
         const { graph, onProgress } = context;
-        console.log('[AliasTracker] Starting alias resolution...');
+        const logger = this.log(context);
+        logger.info('Starting alias resolution');
         let callsProcessed = 0;
         let aliasesFound = 0;
         let edgesCreated = 0;
@@ -49,10 +50,10 @@ export class AliasTracker extends Plugin {
                 continue;
             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);
         // 4. Обрабатываем каждый нерезолвленный вызов
@@ -108,12 +109,17 @@ 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/dist/plugins/enrichment/HTTPConnectionEnricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTTPConnectionEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/HTTPConnectionEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuF5D;;;OAGG;IACH,OAAO,CAAC,UAAU;IAqBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;CAaxB"}
+{"version":3,"file":"HTTPConnectionEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/HTTPConnectionEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8F5D;;;OAGG;IACH,OAAO,CAAC,UAAU;IAqBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;CAaxB"}

package/dist/plugins/enrichment/HTTPConnectionEnricher.js

@@ -24,6 +24,7 @@ export class HTTPConnectionEnricher extends Plugin {
     }
     async execute(context) {
         const { graph } = context;
+        const logger = this.log(context);
         try {
             // Собираем все http:route (backend endpoints)
             const routes = [];
@@ -35,11 +36,17 @@ export class HTTPConnectionEnricher extends Plugin {
             for await (const node of graph.queryNodes({ type: 'http:request' })) {
                 requests.push(node);
             }
-            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 = [];
             // Для каждого request ищем matching route
@@ -75,10 +82,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({ nodes: 0, edges: edgesCreated }, {
                 connections: connections.length,
@@ -87,7 +94,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/dist/plugins/enrichment/ImportExportLinker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImportExportLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ImportExportLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyH5D;;;OAGG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,iBAAiB;CAWhC"}
+{"version":3,"file":"ImportExportLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ImportExportLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA2I5D;;;OAGG;YACW,gBAAgB;IA+B9B;;OAEG;YACW,iBAAiB;CAWhC"}