ng-di-graph 0.3.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) {
@@ -758,6 +790,103 @@ var AngularParser = class {
 		return this.findDecoratedClasses();
 	}
 	/**
+	* Retrieve source files, optionally filtering by user-provided file paths
+	*/
+	getTargetSourceFiles() {
+		if (!this._project) throw ErrorHandler.createError("Failed to load TypeScript project", "PROJECT_LOAD_FAILED", this._options.project);
+		if (!this._options.files || this._options.files.length === 0) return this._project.getSourceFiles();
+		const projectDir = node_path.default.dirname(node_path.default.resolve(this._options.project));
+		const targetPaths = this._options.files.map((filePath) => {
+			if (node_path.default.isAbsolute(filePath)) {
+				const normalized = node_path.default.normalize(filePath);
+				return {
+					raw: filePath,
+					normalized,
+					isDirectory: (0, node_fs.existsSync)(normalized) && (0, node_fs.statSync)(normalized).isDirectory()
+				};
+			}
+			const projectResolved = node_path.default.normalize(node_path.default.resolve(projectDir, filePath));
+			const cwdResolved = node_path.default.normalize(node_path.default.resolve(filePath));
+			const normalizedPath = (0, node_fs.existsSync)(projectResolved) ? projectResolved : cwdResolved;
+			return {
+				raw: filePath,
+				normalized: normalizedPath,
+				isDirectory: (0, node_fs.existsSync)(normalizedPath) && (0, node_fs.statSync)(normalizedPath).isDirectory()
+			};
+		});
+		const isFileMatch = (filePath, target) => {
+			if (target.isDirectory) {
+				const relative = node_path.default.relative(target.normalized, filePath);
+				return relative !== "" && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+			}
+			return filePath === target.normalized;
+		};
+		const directoryTargets = targetPaths.filter((target) => target.isDirectory);
+		const fileTargets = targetPaths.filter((target) => !target.isDirectory);
+		const directoryAdds = [];
+		for (const target of directoryTargets) {
+			if (!(0, node_fs.existsSync)(target.normalized) || !(0, node_fs.statSync)(target.normalized).isDirectory()) continue;
+			const directoryGlob = `${target.normalized.replace(/\\/g, "/")}/**/*.{ts,tsx}`;
+			const added = this._project.addSourceFilesAtPaths(directoryGlob);
+			if (added.length > 0) {
+				directoryAdds.push({
+					target,
+					addedCount: added.length
+				});
+				this._logger?.warn(LogCategory.FILE_PROCESSING, "Added directory outside tsconfig scope", {
+					directory: target.raw,
+					addedCount: added.length
+				});
+			}
+		}
+		let sourceFiles = this._project.getSourceFiles();
+		let matchedFiles = sourceFiles.filter((sourceFile) => {
+			const filePath = node_path.default.normalize(sourceFile.getFilePath());
+			return targetPaths.some((target) => isFileMatch(filePath, target));
+		});
+		const missingFileTargets = fileTargets.filter((target) => matchedFiles.every((file) => !isFileMatch(node_path.default.normalize(file.getFilePath()), target)));
+		if (missingFileTargets.length > 0) {
+			const addedFiles = [];
+			for (const target of missingFileTargets) {
+				if (!(0, node_fs.existsSync)(target.normalized)) continue;
+				const added = this._project.addSourceFileAtPathIfExists(target.normalized);
+				if (added) {
+					addedFiles.push(added);
+					this._logger?.warn(LogCategory.FILE_PROCESSING, "Added file outside tsconfig scope", { filePath: target.raw });
+				}
+			}
+			if (addedFiles.length > 0 || directoryAdds.length > 0) {
+				sourceFiles = this._project.getSourceFiles();
+				matchedFiles = sourceFiles.filter((sourceFile) => {
+					const filePath = node_path.default.normalize(sourceFile.getFilePath());
+					return targetPaths.some((target) => isFileMatch(filePath, target));
+				});
+			}
+		}
+		const missingTargets = targetPaths.filter((target) => matchedFiles.every((file) => !isFileMatch(node_path.default.normalize(file.getFilePath()), target)));
+		if (missingTargets.length > 0) {
+			const emptyDirectories = missingTargets.filter((target) => target.isDirectory && (0, node_fs.existsSync)(target.normalized) && (0, node_fs.statSync)(target.normalized).isDirectory());
+			if (emptyDirectories.length > 0) {
+				const firstEmpty = emptyDirectories[0];
+				throw ErrorHandler.createError(`Directory "${firstEmpty.raw}" contained no TypeScript files`, "FILE_NOT_FOUND", firstEmpty.raw);
+			}
+			const missingList = missingTargets.map((target) => target.raw).join(", ");
+			throw ErrorHandler.createError(`Target file(s) not found in project: ${missingList}`, "FILE_NOT_FOUND", missingTargets[0]?.raw);
+		}
+		this._logger?.info(LogCategory.FILE_PROCESSING, "Applied file filter", {
+			targetCount: targetPaths.length,
+			matchedCount: matchedFiles.length
+		});
+		if (this._options.verbose) {
+			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;
+	}
+	/**
 	* Find all classes decorated with @Injectable, @Component, or @Directive
 	* Implements FR-02: Decorated Class Collection
 	* @returns Promise<ParsedClass[]> List of decorated classes
@@ -766,20 +895,18 @@ var AngularParser = class {
 		if (!this._project) this.loadProject();
 		if (!this._project) throw ErrorHandler.createError("Failed to load TypeScript project", "PROJECT_LOAD_FAILED", this._options.project);
 		const decoratedClasses = [];
-		const sourceFiles = this._project.getSourceFiles();
+		const sourceFiles = this.getTargetSourceFiles();
 		let processedFiles = 0;
 		let skippedFiles = 0;
 		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
@@ -788,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,
@@ -810,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,
@@ -829,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 {
@@ -921,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}`);
 		}
 	}
 	/**
@@ -957,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();
@@ -1015,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;
 	}
 	/**
@@ -1102,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",
@@ -1166,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();
@@ -1268,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 {
@@ -1369,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;
@@ -1405,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;
 		}
@@ -1431,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();
@@ -1451,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;
 	}
@@ -1496,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 {};
 		}
@@ -1528,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;
 		}
 	}
@@ -1542,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];
@@ -1558,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;
 				}
 			}
@@ -1581,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,
@@ -1591,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;
 		}
 	}
@@ -1606,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++;
@@ -1627,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();
@@ -1638,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 });
 		}
 	}
 	/**
@@ -1670,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
+		});
 	}
 };
 
@@ -1858,8 +1996,8 @@ function enforceMinimumNodeVersion() {
 	process.exit(1);
 }
 enforceMinimumNodeVersion();
-function resolveProjectPath(projectPath, projectOption) {
-	const candidatePath = projectPath ?? projectOption;
+function resolveProjectPath(projectOption) {
+	const candidatePath = projectOption;
 	try {
 		if ((0, node_fs.statSync)(candidatePath).isDirectory()) {
 			const tsconfigPath = (0, node_path.join)(candidatePath, "tsconfig.json");
@@ -1870,18 +2008,22 @@ function resolveProjectPath(projectPath, projectOption) {
 }
 const program = new commander.Command();
 program.name("ng-di-graph").description("Angular DI dependency graph CLI tool").version("0.1.0");
-program.argument("[projectPath]", "tsconfig.json path or project directory containing tsconfig.json").option("-p, --project <path>", "tsconfig.json path", "./tsconfig.json").option("-f, --format <format>", "output format: json | mermaid", "json").option("-e, --entry <symbol...>", "starting nodes for sub-graph").option("-d, --direction <dir>", "filtering direction: upstream|downstream|both", "downstream").option("--include-decorators", "include Optional/Self/SkipSelf/Host flags", false).option("--out <file>", "output file (stdout if omitted)").option("-v, --verbose", "show detailed parsing information", false);
-program.action(async (projectPath, options) => {
+program.argument("[filePaths...]", "TypeScript files to analyze (alias for --files)").option("-p, --project <path>", "tsconfig.json path", "./tsconfig.json").option("--files <paths...>", "specific file paths to analyze (similar to eslint targets)").option("-f, --format <format>", "output format: json | mermaid", "json").option("-e, --entry <symbol...>", "starting nodes for sub-graph").option("-d, --direction <dir>", "filtering direction: upstream|downstream|both", "downstream").option("--include-decorators", "include Optional/Self/SkipSelf/Host flags", false).option("--out <file>", "output file (stdout if omitted)").option("-v, --verbose", "show detailed parsing information", false);
+program.action(async (filePaths = [], options) => {
 	try {
-		const project = resolveProjectPath(projectPath, options.project);
+		const project = resolveProjectPath(options.project);
 		if (options.direction && ![
 			"upstream",
 			"downstream",
 			"both"
 		].includes(options.direction)) throw ErrorHandler.createError(`Invalid direction: ${options.direction}. Must be 'upstream', 'downstream', or 'both'`, "INVALID_ARGUMENTS");
 		if (options.format && !["json", "mermaid"].includes(options.format)) throw ErrorHandler.createError(`Invalid format: ${options.format}. Must be 'json' or 'mermaid'`, "INVALID_ARGUMENTS");
+		const tsconfigLikePositional = filePaths.find((filePath) => /(?:^|[\\/])tsconfig(?:\.[^/\\]+)?\.json$/.test(filePath));
+		if (tsconfigLikePositional) throw ErrorHandler.createError(`Positional argument "${tsconfigLikePositional}" looks like a tsconfig. Use --project "${tsconfigLikePositional}" instead.`, "INVALID_ARGUMENTS");
+		const mergedFiles = mergeFileTargets(filePaths, options.files);
 		const cliOptions = {
 			project,
+			files: mergedFiles.length > 0 ? mergedFiles : void 0,
 			format: options.format,
 			entry: options.entry,
 			direction: options.direction,
@@ -1917,7 +2059,7 @@ program.action(async (projectPath, 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;
@@ -1945,6 +2087,11 @@ program.action(async (projectPath, options) => {
 		}
 	}
 });
+function mergeFileTargets(positionalFiles, flagFiles) {
+	const merged = [];
+	for (const filePath of [...positionalFiles, ...flagFiles ?? []]) if (!merged.includes(filePath)) merged.push(filePath);
+	return merged;
+}
 process.on("unhandledRejection", (reason, promise) => {
 	const error = ErrorHandler.createError(`Unhandled promise rejection: ${reason}`, "INTERNAL_ERROR", void 0, { promise: String(promise) });
 	ErrorHandler.handleError(error, false);