ng-di-graph 0.4.0 → 0.4.1

package/dist/cli/index.cjs

@@ -510,32 +510,37 @@ function buildGraph(parsedClasses, logger) {
 * @param adjacencyList The adjacency list for traversal
 * @param resultSet The set to collect traversal results
 * @param options CLI options for verbose output
+* @param logger Optional logger for structured output
 */
-function validateAndTraverseEntryPoints(entryPoints, graph, adjacencyList, resultSet, options) {
+function validateAndTraverseEntryPoints(entryPoints, graph, adjacencyList, resultSet, options, logger) {
 	for (const entryPoint of entryPoints) if (graph.nodes.some((n) => n.id === entryPoint)) traverseFromEntry(entryPoint, adjacencyList, resultSet);
-	else if (options.verbose) console.warn(`Entry point '${entryPoint}' not found in graph`);
+	else if (options.verbose && logger) {
+		const message = `Entry point '${entryPoint}' not found in graph`;
+		logger.warn(LogCategory.FILTERING, message, { entryPoint });
+	}
 }
 /**
 * Filters a graph based on entry points and traversal direction
 * @param graph The graph to filter
 * @param options CLI options containing entry points and direction
+* @param logger Optional logger for structured output
 * @returns Filtered graph containing only nodes reachable from entry points
 */
-function filterGraph(graph, options) {
+function filterGraph(graph, options, logger) {
 	if (!options.entry || options.entry.length === 0) return graph;
 	const includedNodeIds = /* @__PURE__ */ new Set();
 	if (options.direction === "both") {
 		const upstreamAdjacencyList = buildAdjacencyList(graph, "upstream");
 		const upstreamNodes = /* @__PURE__ */ new Set();
-		validateAndTraverseEntryPoints(options.entry, graph, upstreamAdjacencyList, upstreamNodes, options);
+		validateAndTraverseEntryPoints(options.entry, graph, upstreamAdjacencyList, upstreamNodes, options, logger);
 		const downstreamAdjacencyList = buildAdjacencyList(graph, "downstream");
 		const downstreamNodes = /* @__PURE__ */ new Set();
-		validateAndTraverseEntryPoints(options.entry, graph, downstreamAdjacencyList, downstreamNodes, options);
+		validateAndTraverseEntryPoints(options.entry, graph, downstreamAdjacencyList, downstreamNodes, options, logger);
 		const combinedNodes = new Set([...upstreamNodes, ...downstreamNodes]);
 		for (const nodeId of combinedNodes) includedNodeIds.add(nodeId);
 	} else {
 		const adjacencyList = buildAdjacencyList(graph, options.direction);
-		validateAndTraverseEntryPoints(options.entry, graph, adjacencyList, includedNodeIds, options);
+		validateAndTraverseEntryPoints(options.entry, graph, adjacencyList, includedNodeIds, options, logger);
 	}
 	const filteredNodes = graph.nodes.filter((node) => includedNodeIds.has(node.id));
 	const filteredEdges = graph.edges.filter((edge) => includedNodeIds.has(edge.from) && includedNodeIds.has(edge.to));
@@ -554,9 +559,12 @@ function filterGraph(graph, options) {
 		}
 		return true;
 	});
-	if (options.verbose) {
-		console.log(`Filtered graph: ${filteredNodes.length} nodes, ${filteredEdges.length} edges`);
-		console.log(`Entry points: ${options.entry.join(", ")}`);
+	if (options.verbose && logger) {
+		logger.info(LogCategory.FILTERING, "Filtered graph summary", {
+			nodeCount: filteredNodes.length,
+			edgeCount: filteredEdges.length
+		});
+		logger.debug(LogCategory.FILTERING, "Entry points applied", { entryPoints: options.entry });
 	}
 	return {
 		nodes: filteredNodes,
@@ -663,6 +671,21 @@ var AngularParser = class {
 			totalCount: 0
 		};
 	}
+	verboseInfo(category, message, context) {
+		if (!this._options.verbose || !this._logger) return;
+		this._logger.info(category, message, context);
+	}
+	verboseDebug(category, message, context) {
+		if (!this._options.verbose || !this._logger) return;
+		this._logger.debug(category, message, context);
+	}
+	warn(category, message, context) {
+		if (this._logger) {
+			this._logger.warn(category, message, context);
+			return;
+		}
+		ErrorHandler.warn(message, context?.filePath);
+	}
 	/**
 	* Reset global warning deduplication state (useful for testing)
 	*/
@@ -698,8 +721,23 @@ var AngularParser = class {
 			this._structuredWarnings.categories[category].push(warning);
 			this._structuredWarnings.totalCount++;
 			const location = warning.line ? `${warning.file}:${warning.line}:${warning.column}` : warning.file;
-			console.warn(`[${warning.severity.toUpperCase()}] ${warning.message} (${location})`);
-			if (warning.suggestion && this._options.verbose) console.warn(`  Suggestion: ${warning.suggestion}`);
+			const formattedWarning = `[${warning.severity.toUpperCase()}] ${warning.message} (${location})`;
+			if (this._logger) {
+				this._logger.warn(LogCategory.ERROR_RECOVERY, formattedWarning, {
+					category,
+					filePath: warning.file,
+					lineNumber: warning.line,
+					suggestion: warning.suggestion
+				});
+				if (warning.suggestion && this._options.verbose) this._logger.info(LogCategory.ERROR_RECOVERY, warning.suggestion, {
+					category,
+					filePath: warning.file,
+					lineNumber: warning.line
+				});
+			} else {
+				ErrorHandler.warn(formattedWarning, warning.file);
+				if (warning.suggestion && this._options.verbose) ErrorHandler.warn(warning.suggestion, warning.file);
+			}
 			GLOBAL_WARNING_KEYS.add(warnKey);
 		}
 	}
@@ -723,12 +761,6 @@ var AngularParser = class {
 			}
 			this._project = new ts_morph.Project({ tsConfigFilePath: tsConfigPath });
 			if (!this._project) throw ErrorHandler.createError("Failed to load TypeScript project", "PROJECT_LOAD_FAILED", this._options.project);
-			this._project.getSourceFiles();
-			const diagnostics = this._project.getProgram().getConfigFileParsingDiagnostics();
-			if (diagnostics.length > 0) {
-				const message = diagnostics[0].getMessageText();
-				throw ErrorHandler.createError(`TypeScript configuration error: ${message}`, "PROJECT_LOAD_FAILED", this._options.project, { diagnosticCount: diagnostics.length });
-			}
 		} catch (error) {
 			if (error instanceof CliError) throw error;
 			if (error instanceof Error) {
@@ -846,8 +878,11 @@ var AngularParser = class {
 			matchedCount: matchedFiles.length
 		});
 		if (this._options.verbose) {
-			console.log(`🎯 Filtering to specific file(s): ${matchedFiles.length}`);
-			for (const file of matchedFiles) console.log(`   - ${file.getFilePath()}`);
+			this._logger?.info(LogCategory.FILE_PROCESSING, `Filtering to specific file(s): ${matchedFiles.length}`, {
+				matchedCount: matchedFiles.length,
+				targetCount: targetPaths.length
+			});
+			for (const file of matchedFiles) this._logger?.debug(LogCategory.FILE_PROCESSING, "Including file", { filePath: file.getFilePath() });
 		}
 		return matchedFiles;
 	}
@@ -866,14 +901,12 @@ var AngularParser = class {
 		this._circularTypeRefs.clear();
 		this._logger?.time("findDecoratedClasses");
 		this._logger?.info(LogCategory.FILE_PROCESSING, "Starting file processing", { fileCount: sourceFiles.length });
-		if (this._options.verbose) console.log(`Processing ${sourceFiles.length} source files`);
+		this._logger?.info(LogCategory.FILE_PROCESSING, "Processing source files", { fileCount: sourceFiles.length });
 		for (const sourceFile of sourceFiles) {
 			const filePath = sourceFile.getFilePath();
 			try {
-				if (this._options.verbose) console.log(`🔍 Parsing file: ${filePath}`);
-				this._logger?.debug(LogCategory.FILE_PROCESSING, "Processing file", { filePath });
+				this._logger?.debug(LogCategory.FILE_PROCESSING, "Parsing file", { filePath });
 				const classes = sourceFile.getClasses();
-				if (this._options.verbose) console.log(`File: ${filePath}, Classes: ${classes.length}`);
 				this._logger?.debug(LogCategory.AST_ANALYSIS, "Analyzing classes in file", {
 					filePath,
 					classCount: classes.length
@@ -882,7 +915,6 @@ var AngularParser = class {
 					const parsedClass = this.parseClassDeclaration(classDeclaration);
 					if (parsedClass) {
 						decoratedClasses.push(parsedClass);
-						if (this._options.verbose) console.log(`Found decorated class: ${parsedClass.name} (${parsedClass.kind})`);
 						this._logger?.info(LogCategory.AST_ANALYSIS, "Found decorated class", {
 							className: parsedClass.name,
 							kind: parsedClass.kind,
@@ -904,7 +936,10 @@ var AngularParser = class {
 				ErrorHandler.warn(`Failed to parse file (skipping): ${error instanceof Error ? error.message : "Unknown error"}`, filePath);
 			}
 		}
-		if (this._options.verbose) console.log(`✅ Processed ${processedFiles} files, skipped ${skippedFiles} files`);
+		this._logger?.info(LogCategory.FILE_PROCESSING, "File processing summary", {
+			processedFiles,
+			skippedFiles
+		});
 		const elapsed = this._logger?.timeEnd("findDecoratedClasses") || 0;
 		this._logger?.info(LogCategory.PERFORMANCE, "File processing complete", {
 			totalClasses: decoratedClasses.length,
@@ -923,17 +958,26 @@ var AngularParser = class {
 	parseClassDeclaration(classDeclaration) {
 		const className = classDeclaration.getName();
 		if (!className) {
-			console.warn("Warning: Skipping anonymous class - classes must be named for dependency injection analysis");
+			const message = "Skipping anonymous class - classes must be named for dependency injection analysis";
+			if (this._logger) this._logger.warn(LogCategory.AST_ANALYSIS, message);
+			else ErrorHandler.warn(message);
 			return null;
 		}
 		const decorators = classDeclaration.getDecorators();
 		if (this._options.verbose) {
 			const decoratorNames = decorators.map((d) => this.getDecoratorName(d)).join(", ");
-			console.log(`Class: ${className}, Decorators: ${decorators.length} [${decoratorNames}]`);
+			this._logger?.debug(LogCategory.AST_ANALYSIS, "Decorator metadata", {
+				className,
+				decoratorCount: decorators.length,
+				decoratorNames
+			});
 		}
 		const angularDecorator = this.findAngularDecorator(decorators);
 		if (!angularDecorator) {
-			if (this._options.verbose && decorators.length > 0) console.log(`  No Angular decorator found for ${className}`);
+			if (this._options.verbose && decorators.length > 0) this._logger?.debug(LogCategory.AST_ANALYSIS, "No Angular decorator found", {
+				className,
+				decoratorCount: decorators.length
+			});
 			return null;
 		}
 		return {
@@ -1015,14 +1059,14 @@ var AngularParser = class {
 					if (parent && parent.getKind() === ts_morph.SyntaxKind.CallExpression) {
 						const grandParent = parent.getParent();
 						if (grandParent && grandParent.getKind() === ts_morph.SyntaxKind.CallExpression) {
-							console.warn("Warning: Skipping anonymous class - classes must be named for dependency injection analysis");
-							if (this._options.verbose) console.log(`    Anonymous class found in ${sourceFile.getFilePath()}`);
+							this.warn(LogCategory.AST_ANALYSIS, "Skipping anonymous class - classes must be named for dependency injection analysis", { filePath: sourceFile.getFilePath() });
+							this.verboseDebug(LogCategory.AST_ANALYSIS, `Anonymous class found in ${sourceFile.getFilePath()}`);
 						}
 					}
 				}
 			});
 		} catch (error) {
-			if (this._options.verbose) console.log(`    Could not detect anonymous classes in ${sourceFile.getFilePath()}: ${error}`);
+			this.verboseDebug(LogCategory.AST_ANALYSIS, `Could not detect anonymous classes in ${sourceFile.getFilePath()}: ${error}`);
 		}
 	}
 	/**
@@ -1051,11 +1095,11 @@ var AngularParser = class {
 		};
 		const startTime = performance.now();
 		if (this._options.verbose && this._options.includeDecorators) {
-			console.log("=== Decorator Analysis ===");
+			this.verboseInfo(LogCategory.AST_ANALYSIS, "=== Decorator Analysis ===");
 			const className = classDeclaration.getName() || "unknown";
-			console.log(`Analyzing decorators for class: ${className}`);
+			this.verboseInfo(LogCategory.AST_ANALYSIS, `Analyzing decorators for class: ${className}`, { className });
 		}
-		if (this._options.verbose && !this._options.includeDecorators) console.log("Decorator analysis disabled - --include-decorators flag not set");
+		if (this._options.verbose && !this._options.includeDecorators) this.verboseInfo(LogCategory.AST_ANALYSIS, "Decorator analysis disabled - --include-decorators flag not set");
 		const constructors = classDeclaration.getConstructors();
 		if (constructors.length > 0) {
 			const parameters = constructors[0].getParameters();
@@ -1109,7 +1153,7 @@ var AngularParser = class {
 	* @returns Token string or null
 	*/
 	handleGenericType(typeText, _filePath, _lineNumber, _columnNumber) {
-		if (this._options.verbose) console.log(`Processing generic type: ${typeText}`);
+		this.verboseDebug(LogCategory.TYPE_RESOLUTION, `Processing generic type: ${typeText}`);
 		return typeText;
 	}
 	/**
@@ -1196,7 +1240,10 @@ var AngularParser = class {
 	*/
 	extractTypeTokenEnhanced(typeNode, filePath, lineNumber, columnNumber) {
 		const typeText = typeNode.getText();
-		if (this._options.verbose) console.log(`Type resolution steps: Processing '${typeText}' at ${filePath}:${lineNumber}:${columnNumber}`);
+		this.verboseInfo(LogCategory.TYPE_RESOLUTION, `Type resolution steps: Processing '${typeText}' at ${filePath}:${lineNumber}:${columnNumber}`, {
+			filePath,
+			lineNumber
+		});
 		if (this.isCircularTypeReference(typeText, typeNode)) {
 			this.addStructuredWarning("circularReferences", {
 				type: "circular_type_reference",
@@ -1260,7 +1307,10 @@ var AngularParser = class {
 	* @returns Resolved token or null
 	*/
 	resolveInferredTypeEnhanced(type, typeText, param, filePath, lineNumber, columnNumber) {
-		if (this._options.verbose) console.log(`Attempting to resolve inferred type: ${typeText}`);
+		this.verboseInfo(LogCategory.TYPE_RESOLUTION, `Attempting to resolve inferred type: ${typeText}`, {
+			filePath,
+			lineNumber
+		});
 		const symbol = type.getSymbol?.();
 		if (symbol) {
 			const symbolName = symbol.getName();
@@ -1362,14 +1412,20 @@ var AngularParser = class {
 			cacheKey = `${filePath}:${parameterName}:${typeText}`;
 			if (this._typeResolutionCache.has(cacheKey)) {
 				const cachedResult = this._typeResolutionCache.get(cacheKey);
-				if (this._options.verbose) console.log(`Cache hit for parameter '${parameterName}': ${typeText}`);
+				this.verboseDebug(LogCategory.TYPE_RESOLUTION, `Cache hit for parameter '${parameterName}': ${typeText}`, {
+					parameterName,
+					cacheKey
+				});
 				return cachedResult ? {
 					token: cachedResult,
 					flags,
 					parameterName
 				} : null;
 			}
-			if (this._options.verbose) console.log(`Cache miss for parameter '${parameterName}': ${typeText}`);
+			this.verboseDebug(LogCategory.TYPE_RESOLUTION, `Cache miss for parameter '${parameterName}': ${typeText}`, {
+				parameterName,
+				cacheKey
+			});
 			const resolvedToken = this.resolveInferredTypeEnhanced(type, typeText, param, filePath, lineNumber, columnNumber);
 			this._typeResolutionCache.set(cacheKey, resolvedToken);
 			if (resolvedToken) return {
@@ -1463,7 +1519,10 @@ var AngularParser = class {
 			if (this._options.verbose) {
 				const className = classDeclaration.getName() || "unknown";
 				const filePath = classDeclaration.getSourceFile().getFilePath();
-				console.warn(`Warning: Failed to extract inject() dependencies for class '${className}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+				this.warn(LogCategory.ERROR_RECOVERY, `Failed to extract inject() dependencies for class '${className}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`, {
+					className,
+					filePath
+				});
 			}
 		}
 		return dependencies;
@@ -1499,7 +1558,10 @@ var AngularParser = class {
 			if (this._options.verbose) {
 				const propertyName = property.getName() || "unknown";
 				const filePath = property.getSourceFile().getFilePath();
-				console.warn(`Warning: Failed to parse inject() property '${propertyName}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+				this.warn(LogCategory.ERROR_RECOVERY, `Failed to parse inject() property '${propertyName}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`, {
+					propertyName,
+					filePath
+				});
 			}
 			return null;
 		}
@@ -1525,7 +1587,7 @@ var AngularParser = class {
 				const propertyAssignment = prop;
 				const name = propertyAssignment.getName();
 				if (!supportedOptions.has(name)) {
-					if (this._options.verbose) console.warn(`Unknown inject() option: '${name}' - ignoring`);
+					if (this._options.verbose) this.warn(LogCategory.AST_ANALYSIS, `Unknown inject() option: '${name}' - ignoring`);
 					continue;
 				}
 				const initializer = propertyAssignment.getInitializer();
@@ -1545,7 +1607,7 @@ var AngularParser = class {
 				}
 			}
 		} catch (error) {
-			if (this._options.verbose) console.warn(`Warning: Failed to parse inject() options: ${error instanceof Error ? error.message : String(error)}`);
+			if (this._options.verbose) this.warn(LogCategory.ERROR_RECOVERY, `Failed to parse inject() options: ${error instanceof Error ? error.message : String(error)}`);
 		}
 		return flags;
 	}
@@ -1590,14 +1652,21 @@ var AngularParser = class {
 						name: decoratorName,
 						reason: "Unknown or unsupported decorator"
 					});
-					console.warn(`Unknown or unsupported decorator: @${decoratorName}() - This decorator is not recognized as an Angular DI decorator and will be ignored.`);
+					const className = parameter.getFirstAncestorByKind(ts_morph.SyntaxKind.ClassDeclaration)?.getName() || void 0;
+					this.warn(LogCategory.AST_ANALYSIS, `Unknown or unsupported decorator: @${decoratorName}() - This decorator is not recognized as an Angular DI decorator and will be ignored.`, {
+						filePath: parameter.getSourceFile().getFilePath(),
+						className
+					});
 				}
 			}
 		} catch (error) {
 			if (this._options.verbose) {
 				const paramName = parameter.getName();
 				const filePath = parameter.getSourceFile().getFilePath();
-				console.warn(`Warning: Failed to extract decorators for parameter '${paramName}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+				this.warn(LogCategory.ERROR_RECOVERY, `Failed to extract decorators for parameter '${paramName}' in ${filePath}: ${error instanceof Error ? error.message : String(error)}`, {
+					paramName,
+					filePath
+				});
 			}
 			return {};
 		}
@@ -1622,7 +1691,7 @@ var AngularParser = class {
 			}
 			return false;
 		} catch (error) {
-			if (this._options.verbose) console.warn(`Warning: Could not verify inject() import in ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
+			if (this._options.verbose) this.warn(LogCategory.ERROR_RECOVERY, `Could not verify inject() import in ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`, { filePath: sourceFile.getFilePath() });
 			return true;
 		}
 	}
@@ -1636,15 +1705,19 @@ var AngularParser = class {
 		if (!expression) return null;
 		if (expression.getKind() !== ts_morph.SyntaxKind.CallExpression) return null;
 		const callExpression = expression;
+		const sourceFile = expression.getSourceFile();
+		const warnVerbose = (message) => {
+			if (this._options.verbose) this.warn(LogCategory.AST_ANALYSIS, message, { filePath: sourceFile.getFilePath() });
+		};
 		try {
 			const callIdentifier = callExpression.getExpression();
 			if (callIdentifier.getKind() !== ts_morph.SyntaxKind.Identifier) return null;
 			if (callIdentifier.getText() !== "inject") return null;
-			const sourceFile = expression.getSourceFile();
-			if (!this.isAngularInjectImported(sourceFile)) return null;
+			const sourceFile$1 = expression.getSourceFile();
+			if (!this.isAngularInjectImported(sourceFile$1)) return null;
 			const args = callExpression.getArguments();
 			if (args.length === 0) {
-				if (this._options.verbose) console.warn("inject() called without token parameter - skipping");
+				warnVerbose("inject() called without token parameter - skipping");
 				return null;
 			}
 			const tokenArg = args[0];
@@ -1652,22 +1725,22 @@ var AngularParser = class {
 			if (tokenArg.getKind() === ts_morph.SyntaxKind.StringLiteral) {
 				token = tokenArg.getText().slice(1, -1);
 				if (!token) {
-					if (this._options.verbose) console.warn("inject() called with empty string token - skipping");
+					warnVerbose("inject() called with empty string token - skipping");
 					return null;
 				}
 			} else if (tokenArg.getKind() === ts_morph.SyntaxKind.Identifier) {
 				token = tokenArg.getText();
 				if (token === "undefined" || token === "null") {
-					if (this._options.verbose) console.warn(`inject() called with ${token} token - skipping`);
+					warnVerbose(`inject() called with ${token} token - skipping`);
 					return null;
 				}
 			} else if (tokenArg.getKind() === ts_morph.SyntaxKind.NullKeyword) {
-				if (this._options.verbose) console.warn("inject() called with null token - skipping");
+				warnVerbose("inject() called with null token - skipping");
 				return null;
 			} else {
 				token = tokenArg.getText();
 				if (!token) {
-					if (this._options.verbose) console.warn("inject() called with invalid token expression - skipping");
+					warnVerbose("inject() called with invalid token expression - skipping");
 					return null;
 				}
 			}
@@ -1675,9 +1748,7 @@ var AngularParser = class {
 			if (args.length > 1 && this._options.includeDecorators) {
 				const optionsArg = args[1];
 				if (optionsArg.getKind() === ts_morph.SyntaxKind.ObjectLiteralExpression) flags = this.parseInjectOptions(optionsArg);
-				else if (optionsArg.getKind() !== ts_morph.SyntaxKind.NullKeyword && optionsArg.getKind() !== ts_morph.SyntaxKind.UndefinedKeyword) {
-					if (this._options.verbose) console.warn(`inject() called with invalid options type: ${optionsArg.getKindName()} - expected object literal`);
-				}
+				else if (optionsArg.getKind() !== ts_morph.SyntaxKind.NullKeyword && optionsArg.getKind() !== ts_morph.SyntaxKind.UndefinedKeyword) warnVerbose(`inject() called with invalid options type: ${optionsArg.getKindName()} - expected object literal`);
 			}
 			return {
 				token,
@@ -1685,10 +1756,7 @@ var AngularParser = class {
 				source: "inject"
 			};
 		} catch (error) {
-			if (this._options.verbose) {
-				const filePath = expression.getSourceFile().getFilePath();
-				console.warn(`Warning: Failed to analyze inject() call in ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-			}
+			if (this._options.verbose) warnVerbose(`Failed to analyze inject() call in ${sourceFile.getFilePath()}: ${error instanceof Error ? error.message : String(error)}`);
 			return null;
 		}
 	}
@@ -1700,8 +1768,11 @@ var AngularParser = class {
 	*/
 	collectVerboseStats(param, dependency, verboseStats) {
 		const paramName = param.getName();
-		console.log(`Parameter: ${paramName}`);
-		console.log(`  Token: ${dependency.token}`);
+		this.verboseDebug(LogCategory.AST_ANALYSIS, "Parameter analysis", {
+			paramName,
+			token: dependency.token,
+			flags: dependency.flags
+		});
 		if (Object.keys(dependency.flags || {}).length > 0) {
 			verboseStats.parametersWithDecorators++;
 			if (dependency.flags?.optional) verboseStats.decoratorCounts.optional++;
@@ -1721,7 +1792,10 @@ var AngularParser = class {
 					"Host"
 				].includes(decoratorName)) {
 					hasLegacyDecorators = true;
-					console.log(`  Legacy decorator: @${decoratorName}`);
+					this.verboseDebug(LogCategory.AST_ANALYSIS, `Legacy decorator detected`, {
+						decoratorName,
+						paramName
+					});
 				}
 			}
 			const initializer = param.getInitializer();
@@ -1732,29 +1806,44 @@ var AngularParser = class {
 						hasInjectPattern = true;
 						verboseStats.injectPatternsUsed++;
 						const flagsStr = JSON.stringify(dependency.flags);
-						console.log(`  inject() options: ${flagsStr}`);
+						this.verboseDebug(LogCategory.AST_ANALYSIS, "inject() options detected", {
+							paramName,
+							flags: flagsStr
+						});
 					}
 				}
 			}
 			if (hasLegacyDecorators) {
 				verboseStats.legacyDecoratorsUsed++;
 				if (hasInjectPattern) {
-					console.log("  Decorator Precedence Analysis");
-					console.log("  Legacy decorators take precedence over inject() options");
+					this.verboseInfo(LogCategory.AST_ANALYSIS, "Decorator precedence analysis", {
+						paramName,
+						legacyDecorators: true,
+						injectPattern: true
+					});
 					const appliedFlags = Object.keys(dependency.flags || {}).filter((key) => dependency.flags?.[key] === true).map((key) => `@${key.charAt(0).toUpperCase() + key.slice(1)}`).join(", ");
-					console.log(`  Applied: ${appliedFlags}`);
+					this.verboseDebug(LogCategory.AST_ANALYSIS, "Applied decorator flags", {
+						paramName,
+						appliedFlags
+					});
 					const injectResult = this.analyzeInjectCall(initializer);
 					if (injectResult && Object.keys(injectResult.flags).length > 0) {
 						const overriddenFlags = JSON.stringify(injectResult.flags);
-						console.log(`  Overridden inject() options: ${overriddenFlags}`);
+						this.verboseDebug(LogCategory.AST_ANALYSIS, "Overridden inject() options", {
+							paramName,
+							overriddenFlags
+						});
 					}
 					const finalFlags = JSON.stringify(dependency.flags);
-					console.log(`  Final flags: ${finalFlags}`);
+					this.verboseDebug(LogCategory.AST_ANALYSIS, "Final decorator flags", {
+						paramName,
+						finalFlags
+					});
 				}
 			}
 		} else {
 			verboseStats.parametersWithoutDecorators++;
-			console.log("  No decorators detected");
+			this.verboseDebug(LogCategory.AST_ANALYSIS, "No decorators detected", { paramName });
 		}
 	}
 	/**
@@ -1764,69 +1853,24 @@ var AngularParser = class {
 	* @param classDeclaration Class being analyzed
 	*/
 	outputVerboseAnalysis(dependencies, verboseStats, classDeclaration) {
-		if (!this._options.verbose) return;
-		if (this._options.includeDecorators) {
-			console.log("=== Decorator Statistics ===");
-			console.log(`Total decorators detected: ${verboseStats.decoratorCounts.optional + verboseStats.decoratorCounts.self + verboseStats.decoratorCounts.skipSelf + verboseStats.decoratorCounts.host}`);
-			if (verboseStats.decoratorCounts.optional > 0) console.log(`@Optional: ${verboseStats.decoratorCounts.optional}`);
-			if (verboseStats.decoratorCounts.self > 0) console.log(`@Self: ${verboseStats.decoratorCounts.self}`);
-			if (verboseStats.decoratorCounts.skipSelf > 0) console.log(`@SkipSelf: ${verboseStats.decoratorCounts.skipSelf}`);
-			if (verboseStats.decoratorCounts.host > 0) console.log(`@Host: ${verboseStats.decoratorCounts.host}`);
-			console.log(`Parameters with decorators: ${verboseStats.parametersWithDecorators}`);
-			console.log(`Parameters without decorators: ${verboseStats.parametersWithoutDecorators}`);
-			if (verboseStats.injectPatternsUsed > 0) {
-				console.log("inject() Pattern Analysis");
-				for (const dep of dependencies) if (dep.parameterName) {
-					const constructors = classDeclaration.getConstructors();
-					if (constructors.length > 0) {
-						const param = constructors[0].getParameters().find((p) => p.getName() === dep.parameterName);
-						if (param) {
-							const initializer = param.getInitializer();
-							if (initializer) {
-								const injectResult = this.analyzeInjectCall(initializer);
-								if (injectResult) {
-									if (injectResult.token.startsWith("\"") && injectResult.token.endsWith("\"")) console.log(`String token: ${injectResult.token}`);
-									else console.log(`Service token: ${injectResult.token}`);
-									if (Object.keys(injectResult.flags).length > 0) {
-										const flagsStr = JSON.stringify(injectResult.flags);
-										console.log(`inject() options detected: ${flagsStr}`);
-									} else console.log("inject() with no options");
-								}
-							}
-						}
-					}
-				}
-			}
-			if (verboseStats.skippedDecorators.length > 0) {
-				console.log("Skipped Decorators");
-				for (const skipped of verboseStats.skippedDecorators) {
-					console.log(`${skipped.name}`);
-					console.log(`Reason: ${skipped.reason}`);
-				}
-				console.log(`Total skipped: ${verboseStats.skippedDecorators.length}`);
-			}
-			console.log("Performance Metrics");
-			console.log(`Decorator processing time: ${verboseStats.totalProcessingTime.toFixed(2)}ms`);
-			console.log(`Total parameters analyzed: ${verboseStats.totalParameters}`);
-			if (verboseStats.totalParameters > 0) {
-				const avgTime = verboseStats.totalProcessingTime / verboseStats.totalParameters;
-				console.log(`Average time per parameter: ${avgTime.toFixed(3)}ms`);
-			}
-			console.log("=== Analysis Summary ===");
-			console.log(`Total dependencies: ${dependencies.length}`);
-			console.log(`With decorator flags: ${verboseStats.parametersWithDecorators}`);
-			console.log(`Without decorator flags: ${verboseStats.parametersWithoutDecorators}`);
-			console.log(`Legacy decorators used: ${verboseStats.legacyDecoratorsUsed}`);
-			console.log(`inject() patterns used: ${verboseStats.injectPatternsUsed}`);
-			if (verboseStats.skippedDecorators.length > 0) console.log(`Unknown decorators skipped: ${verboseStats.skippedDecorators.length}`);
-			if (verboseStats.parametersWithDecorators > 0) {
-				console.log("Flags distribution:");
-				if (verboseStats.decoratorCounts.optional > 0) console.log(`optional: ${verboseStats.decoratorCounts.optional}`);
-				if (verboseStats.decoratorCounts.self > 0) console.log(`self: ${verboseStats.decoratorCounts.self}`);
-				if (verboseStats.decoratorCounts.skipSelf > 0) console.log(`skipSelf: ${verboseStats.decoratorCounts.skipSelf}`);
-				if (verboseStats.decoratorCounts.host > 0) console.log(`host: ${verboseStats.decoratorCounts.host}`);
-			}
-		}
+		if (!this._options.verbose || !this._logger) return;
+		const className = classDeclaration.getName() || "unknown";
+		this._logger.info(LogCategory.AST_ANALYSIS, "Decorator analysis summary", {
+			className,
+			decoratorCounts: verboseStats.decoratorCounts,
+			parametersWithDecorators: verboseStats.parametersWithDecorators,
+			parametersWithoutDecorators: verboseStats.parametersWithoutDecorators,
+			injectPatternsUsed: verboseStats.injectPatternsUsed,
+			skippedDecorators: verboseStats.skippedDecorators.length,
+			legacyDecoratorsUsed: verboseStats.legacyDecoratorsUsed,
+			totalProcessingTime: verboseStats.totalProcessingTime,
+			totalParameters: verboseStats.totalParameters,
+			dependencyCount: dependencies.length
+		});
+		if (verboseStats.skippedDecorators.length > 0) this._logger.debug(LogCategory.AST_ANALYSIS, "Skipped decorators", {
+			skippedDecorators: verboseStats.skippedDecorators,
+			className
+		});
 	}
 };
 
@@ -2015,7 +2059,7 @@ program.action(async (filePaths = [], options) => {
 		}
 		if (cliOptions.entry && cliOptions.entry.length > 0) {
 			if (cliOptions.verbose) console.log(`🔍 Filtering graph by entry points: ${cliOptions.entry.join(", ")}`);
-			graph = filterGraph(graph, cliOptions);
+			graph = filterGraph(graph, cliOptions, logger);
 			if (cliOptions.verbose) console.log(`✅ Filtered graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
 		}
 		let formatter;