ng-di-graph 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,1907 @@
+#!/usr/bin/env node
+let commander = require("commander");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let ts_morph = require("ts-morph");
+
+//#region src/core/error-handler.ts
+/**
+* Comprehensive error handling infrastructure for ng-di-graph CLI
+* Implements FR-10 requirements from PRD Section 13
+*/
+/**
+* Exit codes for ng-di-graph CLI
+* Implements PRD Section 13 error handling requirements
+*/
+let ExitCodes = /* @__PURE__ */ function(ExitCodes$1) {
+	ExitCodes$1[ExitCodes$1["SUCCESS"] = 0] = "SUCCESS";
+	ExitCodes$1[ExitCodes$1["GENERAL_ERROR"] = 1] = "GENERAL_ERROR";
+	ExitCodes$1[ExitCodes$1["INVALID_ARGUMENTS"] = 2] = "INVALID_ARGUMENTS";
+	ExitCodes$1[ExitCodes$1["TSCONFIG_ERROR"] = 3] = "TSCONFIG_ERROR";
+	ExitCodes$1[ExitCodes$1["PARSING_ERROR"] = 4] = "PARSING_ERROR";
+	ExitCodes$1[ExitCodes$1["TYPE_RESOLUTION_ERROR"] = 5] = "TYPE_RESOLUTION_ERROR";
+	ExitCodes$1[ExitCodes$1["MEMORY_ERROR"] = 6] = "MEMORY_ERROR";
+	ExitCodes$1[ExitCodes$1["FILE_NOT_FOUND"] = 7] = "FILE_NOT_FOUND";
+	ExitCodes$1[ExitCodes$1["PERMISSION_ERROR"] = 8] = "PERMISSION_ERROR";
+	return ExitCodes$1;
+}({});
+/**
+* Custom error class for ng-di-graph CLI
+* Provides structured error information with context
+*/
+var CliError = class CliError extends Error {
+	constructor(message, code, filePath, context) {
+		super(message);
+		this.code = code;
+		this.filePath = filePath;
+		this.context = context;
+		this.name = "CliError";
+		Object.setPrototypeOf(this, CliError.prototype);
+	}
+	/**
+	* Check if error is fatal (should exit immediately)
+	*/
+	isFatal() {
+		return [
+			"TSCONFIG_NOT_FOUND",
+			"TSCONFIG_INVALID",
+			"PROJECT_LOAD_FAILED",
+			"MEMORY_LIMIT_EXCEEDED",
+			"INTERNAL_ERROR",
+			"INVALID_ARGUMENTS",
+			"PERMISSION_DENIED",
+			"COMPILATION_ERROR"
+		].includes(this.code);
+	}
+	/**
+	* Check if error is recoverable (can continue processing)
+	*/
+	isRecoverable() {
+		return !this.isFatal();
+	}
+};
+/**
+* ErrorHandler - Static utility class for error handling
+* Provides centralized error formatting and exit code management
+*/
+var ErrorHandler = class ErrorHandler {
+	/**
+	* Map error code to exit code
+	* @param error CliError instance or null
+	* @returns Exit code for process.exit()
+	*/
+	static classifyExitCode(error) {
+		if (!error) return ExitCodes.SUCCESS;
+		switch (error.code) {
+			case "TSCONFIG_NOT_FOUND":
+			case "TSCONFIG_INVALID":
+			case "PROJECT_LOAD_FAILED": return ExitCodes.TSCONFIG_ERROR;
+			case "FILE_PARSE_ERROR":
+			case "COMPILATION_ERROR": return ExitCodes.PARSING_ERROR;
+			case "TYPE_RESOLUTION_ERROR":
+			case "DEPENDENCY_NOT_FOUND": return ExitCodes.TYPE_RESOLUTION_ERROR;
+			case "MEMORY_LIMIT_EXCEEDED": return ExitCodes.MEMORY_ERROR;
+			case "FILE_NOT_FOUND": return ExitCodes.FILE_NOT_FOUND;
+			case "PERMISSION_DENIED": return ExitCodes.PERMISSION_ERROR;
+			case "INVALID_ARGUMENTS": return ExitCodes.INVALID_ARGUMENTS;
+			default: return ExitCodes.GENERAL_ERROR;
+		}
+	}
+	/**
+	* Format error for user-friendly display
+	* @param error CliError to format
+	* @param verbose Include stack traces and detailed info
+	* @returns Formatted error message string
+	*/
+	static formatError(error, verbose = false) {
+		const lines = [];
+		if (error.isFatal()) lines.push("❌ Fatal Error");
+		else if (error.code === "TYPE_RESOLUTION_ERROR") lines.push("⚠️  Type Resolution Warning");
+		else lines.push("⚠️  Warning");
+		lines.push("");
+		lines.push(`Message: ${error.message}`);
+		if (error.filePath) lines.push(`File: ${error.filePath}`);
+		lines.push(`Code: ${error.code}`);
+		if (error.context && Object.keys(error.context).length > 0) {
+			lines.push("");
+			lines.push("Context:");
+			for (const [key, value] of Object.entries(error.context)) lines.push(`  ${key}: ${JSON.stringify(value)}`);
+		}
+		const guidance = ErrorHandler.getRecoveryGuidance(error);
+		if (guidance) {
+			lines.push("");
+			lines.push("💡 Suggestions:");
+			for (const line of guidance.split("\n")) if (line.trim()) lines.push(`  • ${line.trim()}`);
+		}
+		if (verbose && error.stack) {
+			lines.push("");
+			lines.push("🔍 Stack Trace:");
+			lines.push(error.stack);
+		}
+		lines.push("");
+		lines.push("Run with --help for usage information");
+		lines.push("Use --verbose for detailed debugging information");
+		return lines.join("\n");
+	}
+	/**
+	* Get actionable recovery guidance for error
+	* @param error CliError to provide guidance for
+	* @returns Multi-line guidance string
+	*/
+	static getRecoveryGuidance(error) {
+		switch (error.code) {
+			case "TSCONFIG_NOT_FOUND": return `Check that the file path is correct
+Ensure the tsconfig.json file exists
+Try using an absolute path instead of relative
+Use --project flag to specify correct path`;
+			case "TSCONFIG_INVALID": return `Validate JSON syntax with a JSON validator
+Check TypeScript compiler options are valid
+Ensure all referenced files exist
+Try with a minimal tsconfig.json first`;
+			case "PROJECT_LOAD_FAILED": return `Check TypeScript compilation errors
+Ensure all dependencies are installed
+Verify import paths are correct
+Try cleaning node_modules and reinstalling`;
+			case "FILE_PARSE_ERROR": return `Check TypeScript syntax in the problematic file
+Ensure all imports are properly resolved
+Try excluding the file from tsconfig if not needed
+Use --verbose to see detailed parsing errors`;
+			case "TYPE_RESOLUTION_ERROR": return `Consider adding explicit type annotations
+Check import statements are correct
+Verify the dependency is properly exported
+Use 'any' type as temporary workaround if needed`;
+			case "DEPENDENCY_NOT_FOUND": return `Check import statements in ${error.filePath || "the file"}
+Verify all dependencies are properly installed
+Ensure the dependency is exported from its module
+Consider using --verbose for detailed analysis`;
+			case "MEMORY_LIMIT_EXCEEDED": return `Try processing smaller portions of the codebase
+Use --entry filtering to limit scope
+Consider increasing available memory (NODE_OPTIONS="--max-old-space-size=4096")
+Process files in batches rather than all at once`;
+			case "ANONYMOUS_CLASS_SKIPPED": return `Consider giving the class a name for better tracking
+This is a non-fatal warning - processing will continue
+Anonymous classes cannot be included in dependency graphs`;
+			case "OUTPUT_WRITE_ERROR": return `Check file permissions for the output location
+Ensure the output directory exists
+Try writing to a different location
+Use stdout instead of file output as workaround`;
+			case "PERMISSION_DENIED": return `Check file and directory permissions
+Try running with appropriate user privileges
+Ensure you have read access to source files
+Verify write access to output location`;
+			case "COMPILATION_ERROR": return `Fix TypeScript compilation errors
+Check compiler options in tsconfig.json
+Ensure all type definitions are available
+Try running tsc directly to see detailed errors`;
+			case "INVALID_ARGUMENTS": return `Check CLI argument syntax
+Review --help for valid options
+Ensure all required arguments are provided
+Verify argument values are in correct format`;
+			case "FILE_NOT_FOUND": return `Verify file path is correct
+Check file exists in the specified location
+Ensure file permissions allow reading
+Try using absolute path instead of relative`;
+			default: return `Review the error message for specific details
+Try running with --verbose for more information
+Check project configuration and dependencies
+Consider filing an issue if the problem persists`;
+		}
+	}
+	/**
+	* Handle error and exit process (never returns)
+	* @param error CliError to handle
+	* @param verbose Include verbose error information
+	*/
+	static handleError(error, verbose = false) {
+		const formattedError = ErrorHandler.formatError(error, verbose);
+		console.error(formattedError);
+		const exitCode = ErrorHandler.classifyExitCode(error);
+		process.exit(exitCode);
+	}
+	/**
+	* Factory method to create CliError
+	* @param message Error message
+	* @param code Error code
+	* @param filePath Optional file path
+	* @param context Optional context object
+	* @returns CliError instance
+	*/
+	static createError(message, code, filePath, context) {
+		return new CliError(message, code, filePath, context);
+	}
+	/**
+	* Output warning without exiting
+	* @param message Warning message
+	* @param filePath Optional file path
+	*/
+	static warn(message, filePath) {
+		console.warn(`⚠️  Warning: ${message}${filePath ? ` (${filePath})` : ""}`);
+	}
+};
+
+//#endregion
+//#region src/core/logger.ts
+/**
+* Logger Infrastructure for ng-di-graph
+* Provides structured logging with categories, performance timing, and memory tracking
+* Implements FR-12: Verbose mode support
+*
+* Usage:
+* ```typescript
+* const logger = createLogger(verbose);
+* logger?.info(LogCategory.FILE_PROCESSING, 'Processing file', { filePath: '/test.ts' });
+* logger?.time('operation');
+* // ... operation ...
+* const elapsed = logger?.timeEnd('operation');
+* const stats = logger?.getStats();
+* ```
+*/
+/**
+* Log category enumeration for structured logging
+* Each category represents a distinct phase of ng-di-graph processing
+*/
+let LogCategory = /* @__PURE__ */ function(LogCategory$1) {
+	LogCategory$1["FILE_PROCESSING"] = "file-processing";
+	LogCategory$1["AST_ANALYSIS"] = "ast-analysis";
+	LogCategory$1["TYPE_RESOLUTION"] = "type-resolution";
+	LogCategory$1["GRAPH_CONSTRUCTION"] = "graph-construction";
+	LogCategory$1["FILTERING"] = "filtering";
+	LogCategory$1["ERROR_RECOVERY"] = "error-recovery";
+	LogCategory$1["PERFORMANCE"] = "performance";
+	return LogCategory$1;
+}({});
+/**
+* Factory function for Logger creation
+* Returns undefined when verbose is false (no-op pattern)
+*
+* @param verbose - Enable verbose logging
+* @returns Logger instance or undefined
+*
+* @example
+* ```typescript
+* const logger = createLogger(cliOptions.verbose);
+* logger?.info(LogCategory.FILE_PROCESSING, 'Starting processing');
+* ```
+*/
+function createLogger(verbose) {
+	return verbose ? new LoggerImpl() : void 0;
+}
+/**
+* Logger implementation (internal)
+* Provides structured logging with minimal performance overhead
+*/
+var LoggerImpl = class {
+	constructor() {
+		this._timers = /* @__PURE__ */ new Map();
+		this._stats = {
+			totalLogs: 0,
+			categoryCounts: {},
+			performanceMetrics: {
+				totalTime: 0,
+				fileProcessingTime: 0,
+				graphBuildingTime: 0,
+				outputGenerationTime: 0
+			},
+			memoryUsage: {
+				peakUsage: 0,
+				currentUsage: 0
+			}
+		};
+		this._peakMemory = 0;
+	}
+	debug(category, message, context) {
+		this._log("DEBUG", category, message, context);
+	}
+	info(category, message, context) {
+		this._log("INFO", category, message, context);
+	}
+	warn(category, message, context) {
+		this._log("WARN", category, message, context);
+	}
+	error(category, message, context) {
+		this._log("ERROR", category, message, context);
+	}
+	time(label) {
+		this._timers.set(label, { startTime: performance.now() });
+	}
+	timeEnd(label) {
+		const timer = this._timers.get(label);
+		if (!timer) throw new Error(`Timer '${label}' does not exist`);
+		const elapsed = performance.now() - timer.startTime;
+		this._timers.delete(label);
+		return elapsed;
+	}
+	getStats() {
+		const memUsage = process.memoryUsage();
+		this._stats.memoryUsage.currentUsage = memUsage.heapUsed;
+		return { ...this._stats };
+	}
+	_log(level, category, message, context) {
+		this._stats.totalLogs++;
+		this._stats.categoryCounts[category] = (this._stats.categoryCounts[category] || 0) + 1;
+		const memUsage = process.memoryUsage().heapUsed;
+		if (memUsage > this._peakMemory) {
+			this._peakMemory = memUsage;
+			this._stats.memoryUsage.peakUsage = memUsage;
+		}
+		const formattedLog = this._formatLog(level, category, message, context);
+		console.error(formattedLog);
+	}
+	_formatLog(level, category, message, context) {
+		return `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level}] [${category}] ${message}${context ? ` ${JSON.stringify(context)}` : ""}`;
+	}
+};
+
+//#endregion
+//#region src/core/graph-builder.ts
+/**
+* Validates input parameters for the buildGraph function
+* @param parsedClasses Array to validate
+* @throws Error if validation fails
+*/
+function validateInput(parsedClasses) {
+	if (parsedClasses == null) throw new Error("parsedClasses parameter cannot be null or undefined");
+	for (let i = 0; i < parsedClasses.length; i++) {
+		const parsedClass = parsedClasses[i];
+		if (typeof parsedClass.name !== "string") throw new Error("ParsedClass must have a valid name property");
+		if (parsedClass.name.trim() === "") throw new Error("ParsedClass name cannot be empty");
+		if (typeof parsedClass.kind !== "string") throw new Error("ParsedClass must have a valid kind property");
+		if (parsedClass.dependencies == null) throw new Error("ParsedClass must have a dependencies array");
+		if (!Array.isArray(parsedClass.dependencies)) throw new Error("ParsedClass dependencies must be an array");
+		for (const dependency of parsedClass.dependencies) if (typeof dependency.token !== "string") throw new Error("ParsedDependency must have a valid token property");
+	}
+}
+/**
+* Detects circular dependencies using DFS (Depth-First Search)
+* @param edges Array of edges representing the dependency graph
+* @param nodes Array of nodes in the graph
+* @returns Array of circular dependency paths and edges marked as circular
+*/
+function detectCircularDependencies(edges, nodes) {
+	const circularDependencies = [];
+	const circularEdges = /* @__PURE__ */ new Set();
+	const adjacencyList = /* @__PURE__ */ new Map();
+	for (const node of nodes) adjacencyList.set(node.id, []);
+	for (const edge of edges) {
+		if (!adjacencyList.has(edge.from)) adjacencyList.set(edge.from, []);
+		const neighbors = adjacencyList.get(edge.from);
+		if (neighbors) neighbors.push(edge.to);
+	}
+	const recursionStack = /* @__PURE__ */ new Set();
+	const processedNodes = /* @__PURE__ */ new Set();
+	/**
+	* DFS helper function to detect cycles
+	*/
+	function dfs(node, path) {
+		if (processedNodes.has(node)) return;
+		if (recursionStack.has(node)) {
+			const cycleStartIndex = path.indexOf(node);
+			const cyclePath = [...path.slice(cycleStartIndex), node];
+			circularDependencies.push(cyclePath);
+			for (let i = 0; i < cyclePath.length - 1; i++) {
+				const edgeKey = `${cyclePath[i]}->${cyclePath[i + 1]}`;
+				circularEdges.add(edgeKey);
+			}
+			return;
+		}
+		recursionStack.add(node);
+		const newPath = [...path, node];
+		const neighbors = adjacencyList.get(node) || [];
+		for (const neighbor of neighbors) dfs(neighbor, newPath);
+		recursionStack.delete(node);
+		processedNodes.add(node);
+	}
+	for (const node of nodes) if (!processedNodes.has(node.id)) dfs(node.id, []);
+	return {
+		circularDependencies,
+		circularEdges
+	};
+}
+/**
+* Builds a dependency graph from parsed Angular classes
+* @param parsedClasses Array of parsed classes with their dependencies
+* @param logger Optional Logger instance for verbose mode logging
+* @returns Graph containing nodes and edges representing the dependency relationships
+*/
+function buildGraph(parsedClasses, logger) {
+	logger?.time("buildGraph");
+	logger?.info(LogCategory.GRAPH_CONSTRUCTION, "Starting graph construction", { classCount: parsedClasses.length });
+	validateInput(parsedClasses);
+	const nodeMap = /* @__PURE__ */ new Map();
+	const edges = [];
+	for (const parsedClass of parsedClasses) if (!nodeMap.has(parsedClass.name)) nodeMap.set(parsedClass.name, {
+		id: parsedClass.name,
+		kind: parsedClass.kind
+	});
+	logger?.info(LogCategory.GRAPH_CONSTRUCTION, `Created ${nodeMap.size} nodes`, { nodeCount: nodeMap.size });
+	let unknownNodeCount = 0;
+	for (const parsedClass of parsedClasses) for (const dependency of parsedClass.dependencies) {
+		if (!nodeMap.has(dependency.token)) {
+			nodeMap.set(dependency.token, {
+				id: dependency.token,
+				kind: "unknown"
+			});
+			unknownNodeCount++;
+			logger?.warn(LogCategory.GRAPH_CONSTRUCTION, `Created unknown node: ${dependency.token}`, {
+				nodeId: dependency.token,
+				referencedBy: parsedClass.name
+			});
+		}
+		const edge = {
+			from: parsedClass.name,
+			to: dependency.token
+		};
+		if (dependency.flags) edge.flags = dependency.flags;
+		edges.push(edge);
+	}
+	logger?.info(LogCategory.GRAPH_CONSTRUCTION, `Created ${edges.length} edges`, {
+		edgeCount: edges.length,
+		unknownNodeCount
+	});
+	const nodes = Array.from(nodeMap.values()).sort((a, b) => a.id.localeCompare(b.id));
+	edges.sort((a, b) => {
+		const fromCompare = a.from.localeCompare(b.from);
+		if (fromCompare !== 0) return fromCompare;
+		return a.to.localeCompare(b.to);
+	});
+	logger?.time("circularDetection");
+	const { circularDependencies, circularEdges } = detectCircularDependencies(edges, nodes);
+	const circularDetectionTime = logger?.timeEnd("circularDetection");
+	if (circularDependencies.length > 0) logger?.warn(LogCategory.GRAPH_CONSTRUCTION, `Circular dependencies detected: ${circularDependencies.length}`, {
+		circularCount: circularDependencies.length,
+		cycles: circularDependencies,
+		detectionTime: circularDetectionTime
+	});
+	else logger?.info(LogCategory.GRAPH_CONSTRUCTION, "No circular dependencies detected", { detectionTime: circularDetectionTime });
+	for (const edge of edges) {
+		const edgeKey = `${edge.from}->${edge.to}`;
+		if (circularEdges.has(edgeKey)) edge.isCircular = true;
+	}
+	const duration = logger?.timeEnd("buildGraph");
+	logger?.info(LogCategory.GRAPH_CONSTRUCTION, "Graph construction complete", {
+		duration,
+		nodeCount: nodes.length,
+		edgeCount: edges.length,
+		circularCount: circularDependencies.length
+	});
+	return {
+		nodes,
+		edges,
+		circularDependencies
+	};
+}
+
+//#endregion
+//#region src/core/graph-filter.ts
+/**
+* Helper function to validate entry points and perform traversal
+* @param entryPoints Array of entry point names to validate and traverse from
+* @param graph The graph containing all nodes
+* @param adjacencyList The adjacency list for traversal
+* @param resultSet The set to collect traversal results
+* @param options CLI options for verbose output
+*/
+function validateAndTraverseEntryPoints(entryPoints, graph, adjacencyList, resultSet, options) {
+	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`);
+}
+/**
+* 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
+* @returns Filtered graph containing only nodes reachable from entry points
+*/
+function filterGraph(graph, options) {
+	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);
+		const downstreamAdjacencyList = buildAdjacencyList(graph, "downstream");
+		const downstreamNodes = /* @__PURE__ */ new Set();
+		validateAndTraverseEntryPoints(options.entry, graph, downstreamAdjacencyList, downstreamNodes, options);
+		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);
+	}
+	const filteredNodes = graph.nodes.filter((node) => includedNodeIds.has(node.id));
+	const filteredEdges = graph.edges.filter((edge) => includedNodeIds.has(edge.from) && includedNodeIds.has(edge.to));
+	const filteredCircularDeps = graph.circularDependencies.filter((cycle) => {
+		if (cycle.length < 2) return false;
+		const isSelfLoop = cycle.length === 2 && cycle[0] === cycle[1];
+		const isProperCycleWithClosing = cycle.length >= 3 && cycle[0] === cycle[cycle.length - 1];
+		const isProperCycleWithoutClosing = cycle.length >= 3 && cycle[0] !== cycle[cycle.length - 1];
+		if (!isSelfLoop && !isProperCycleWithClosing && !isProperCycleWithoutClosing) return false;
+		if (!cycle.every((nodeId) => includedNodeIds.has(nodeId))) return false;
+		const edgesToCheck = isProperCycleWithClosing ? cycle.length - 1 : cycle.length;
+		for (let i = 0; i < edgesToCheck; i++) {
+			const fromNode = cycle[i];
+			const toNode = isProperCycleWithClosing ? cycle[i + 1] : cycle[(i + 1) % cycle.length];
+			if (!graph.edges.some((edge) => edge.from === fromNode && edge.to === toNode)) return false;
+		}
+		return true;
+	});
+	if (options.verbose) {
+		console.log(`Filtered graph: ${filteredNodes.length} nodes, ${filteredEdges.length} edges`);
+		console.log(`Entry points: ${options.entry.join(", ")}`);
+	}
+	return {
+		nodes: filteredNodes,
+		edges: filteredEdges,
+		circularDependencies: filteredCircularDeps
+	};
+}
+/**
+* Traverses the graph from a starting node using DFS
+* @param startNode The node to start traversal from
+* @param adjacencyList The adjacency list representation of the graph
+* @param visited Set to track visited nodes
+*/
+function traverseFromEntry(startNode, adjacencyList, visited) {
+	const stack = [startNode];
+	while (stack.length > 0) {
+		const currentNode = stack.pop();
+		if (!currentNode) break;
+		if (visited.has(currentNode)) continue;
+		visited.add(currentNode);
+		const neighbors = adjacencyList.get(currentNode) || [];
+		for (const neighbor of neighbors) if (!visited.has(neighbor)) stack.push(neighbor);
+	}
+}
+/**
+* Builds an adjacency list from the graph based on direction
+* @param graph The graph to build adjacency list from
+* @param direction The direction to follow edges
+* @returns Map representing adjacency list
+*/
+function buildAdjacencyList(graph, direction) {
+	const adjacencyList = /* @__PURE__ */ new Map();
+	for (const node of graph.nodes) adjacencyList.set(node.id, []);
+	for (const edge of graph.edges) if (direction === "downstream") {
+		const neighbors = adjacencyList.get(edge.from) || [];
+		neighbors.push(edge.to);
+		adjacencyList.set(edge.from, neighbors);
+	} else if (direction === "upstream") {
+		const neighbors = adjacencyList.get(edge.to) || [];
+		neighbors.push(edge.from);
+		adjacencyList.set(edge.to, neighbors);
+	}
+	return adjacencyList;
+}
+
+//#endregion
+//#region src/core/output-handler.ts
+/**
+* Handles output writing to stdout or files
+* Supports directory creation and error handling
+*/
+var OutputHandler = class {
+	/**
+	* Write output content to stdout or file
+	* @param content The content to write
+	* @param filePath Optional file path. If not provided, writes to stdout
+	*/
+	async writeOutput(content, filePath) {
+		if (!filePath) {
+			process.stdout.write(content);
+			return;
+		}
+		try {
+			const dir = (0, node_path.dirname)(filePath);
+			if (!(0, node_fs.existsSync)(dir)) (0, node_fs.mkdirSync)(dir, { recursive: true });
+			(0, node_fs.writeFileSync)(filePath, content, "utf-8");
+		} catch (error) {
+			throw new Error(`Failed to write output file: ${error instanceof Error ? error.message : "Unknown error"}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/parser.ts
+/**
+* AngularParser - Core TypeScript AST parsing using ts-morph
+* Implements FR-01: ts-morph project loading with comprehensive error handling
+* Implements FR-02: Decorated class collection
+* Implements FR-03: Constructor token resolution
+*/
+const GLOBAL_WARNING_KEYS = /* @__PURE__ */ new Set();
+var AngularParser = class {
+	constructor(_options, _logger) {
+		this._options = _options;
+		this._logger = _logger;
+		this._typeResolutionCache = /* @__PURE__ */ new Map();
+		this._circularTypeRefs = /* @__PURE__ */ new Set();
+		this._structuredWarnings = {
+			categories: {
+				typeResolution: [],
+				skippedTypes: [],
+				unresolvedImports: [],
+				circularReferences: [],
+				performance: []
+			},
+			totalCount: 0
+		};
+	}
+	/**
+	* Reset global warning deduplication state (useful for testing)
+	*/
+	static resetWarningState() {
+		GLOBAL_WARNING_KEYS.clear();
+	}
+	/**
+	* Get structured warnings for analysis (Task 3.3)
+	* Returns a copy of the structured warnings collected during parsing
+	* @returns StructuredWarnings object with categorized warnings
+	*/
+	getStructuredWarnings() {
+		return {
+			categories: {
+				typeResolution: [...this._structuredWarnings.categories.typeResolution],
+				skippedTypes: [...this._structuredWarnings.categories.skippedTypes],
+				unresolvedImports: [...this._structuredWarnings.categories.unresolvedImports],
+				circularReferences: [...this._structuredWarnings.categories.circularReferences],
+				performance: [...this._structuredWarnings.categories.performance]
+			},
+			totalCount: this._structuredWarnings.totalCount
+		};
+	}
+	/**
+	* Add structured warning to collection (Task 3.3)
+	* Includes global deduplication for both structured warnings and console output
+	* @param category Warning category
+	* @param warning Warning object
+	*/
+	addStructuredWarning(category, warning) {
+		const warnKey = `${category}_${warning.type}_${warning.file}_${warning.message}`;
+		if (!GLOBAL_WARNING_KEYS.has(warnKey)) {
+			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}`);
+			GLOBAL_WARNING_KEYS.add(warnKey);
+		}
+	}
+	/**
+	* Load TypeScript project using ts-morph
+	* Implements FR-01 with error handling from PRD Section 13
+	*/
+	loadProject() {
+		if (!(0, node_fs.existsSync)(this._options.project)) throw ErrorHandler.createError(`tsconfig.json not found at: ${this._options.project}`, "TSCONFIG_NOT_FOUND", this._options.project);
+		try {
+			try {
+				const configContent = (0, node_fs.readFileSync)(this._options.project, "utf8");
+				JSON.parse(configContent);
+			} catch (jsonError) {
+				const errorMessage = jsonError instanceof Error ? jsonError.message : String(jsonError);
+				throw ErrorHandler.createError(`Invalid tsconfig.json: ${errorMessage}`, "TSCONFIG_INVALID", this._options.project);
+			}
+			this._project = new ts_morph.Project({ tsConfigFilePath: this._options.project });
+			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) {
+				if (error.message.includes("JSON") || error.message.includes("Unexpected token") || error.message.includes("expected")) throw ErrorHandler.createError(`Invalid tsconfig.json: ${error.message}`, "TSCONFIG_INVALID", this._options.project);
+				if (error.message.includes("TypeScript") || error.message.includes("Compiler option")) throw ErrorHandler.createError(`TypeScript compilation failed: ${error.message}`, "COMPILATION_ERROR", this._options.project);
+				throw ErrorHandler.createError(`Failed to load TypeScript project: ${error.message}`, "PROJECT_LOAD_FAILED", this._options.project);
+			}
+			throw ErrorHandler.createError("Failed to load TypeScript project due to unknown error", "PROJECT_LOAD_FAILED", this._options.project);
+		}
+	}
+	/**
+	* Get the loaded ts-morph Project instance
+	* @returns Project instance
+	* @throws Error if project not loaded
+	*/
+	getProject() {
+		if (!this._project) throw new Error("Project not loaded. Call loadProject() first.");
+		return this._project;
+	}
+	/**
+	* Parse decorated classes from the loaded project
+	* Auto-loads project if not already loaded
+	* @returns Promise of parsed class information
+	*/
+	async parseClasses() {
+		if (!this._project) this.loadProject();
+		return this.findDecoratedClasses();
+	}
+	/**
+	* Find all classes decorated with @Injectable, @Component, or @Directive
+	* Implements FR-02: Decorated Class Collection
+	* @returns Promise<ParsedClass[]> List of decorated classes
+	*/
+	async findDecoratedClasses() {
+		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();
+		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`);
+		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 });
+				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
+				});
+				for (const classDeclaration of classes) {
+					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,
+							filePath
+						});
+					}
+				}
+				this.detectAnonymousClasses(sourceFile);
+				processedFiles++;
+			} catch (error) {
+				skippedFiles++;
+				if (error instanceof CliError) {
+					if (!error.isFatal()) {
+						ErrorHandler.warn(error.message, filePath);
+						continue;
+					}
+					throw error;
+				}
+				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`);
+		const elapsed = this._logger?.timeEnd("findDecoratedClasses") || 0;
+		this._logger?.info(LogCategory.PERFORMANCE, "File processing complete", {
+			totalClasses: decoratedClasses.length,
+			processedFiles,
+			skippedFiles,
+			timing: elapsed
+		});
+		if (decoratedClasses.length === 0) ErrorHandler.warn("No decorated classes found in the project");
+		return decoratedClasses;
+	}
+	/**
+	* Parse a single class declaration for Angular decorators
+	* @param classDeclaration ts-morph ClassDeclaration
+	* @returns ParsedClass if decorated with Angular decorator, null otherwise
+	*/
+	parseClassDeclaration(classDeclaration) {
+		const className = classDeclaration.getName();
+		if (!className) {
+			console.warn("Warning: Skipping anonymous class - classes must be named for dependency injection analysis");
+			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}]`);
+		}
+		const angularDecorator = this.findAngularDecorator(decorators);
+		if (!angularDecorator) {
+			if (this._options.verbose && decorators.length > 0) console.log(`  No Angular decorator found for ${className}`);
+			return null;
+		}
+		return {
+			name: className,
+			kind: this.determineNodeKind(angularDecorator),
+			filePath: classDeclaration.getSourceFile().getFilePath(),
+			dependencies: this.extractConstructorDependencies(classDeclaration)
+		};
+	}
+	/**
+	* Find Angular decorator (@Injectable, @Component, @Directive) from list of decorators
+	* @param decorators Array of decorators from ts-morph
+	* @returns Angular decorator if found, null otherwise
+	*/
+	findAngularDecorator(decorators) {
+		for (const decorator of decorators) {
+			const decoratorName = this.getDecoratorName(decorator);
+			if (decoratorName === "Injectable" || decoratorName === "Component" || decoratorName === "Directive") return decorator;
+		}
+		return null;
+	}
+	/**
+	* Extract decorator name from ts-morph Decorator
+	* Handles various import patterns and aliases
+	* @param decorator ts-morph Decorator
+	* @returns Decorator name string
+	*/
+	getDecoratorName(decorator) {
+		const callExpression = decorator.getCallExpression();
+		if (!callExpression) return "";
+		const expression = callExpression.getExpression();
+		if (expression.getKind() === ts_morph.SyntaxKind.Identifier) {
+			const decoratorName = expression.asKindOrThrow(ts_morph.SyntaxKind.Identifier).getText();
+			return this.resolveDecoratorAlias(decorator.getSourceFile(), decoratorName) || decoratorName;
+		}
+		return "";
+	}
+	/**
+	* Resolve decorator alias from import declarations with basic caching
+	* @param sourceFile Source file containing the decorator
+	* @param decoratorName Raw decorator name from AST
+	* @returns Original decorator name if alias found, null otherwise
+	*/
+	resolveDecoratorAlias(sourceFile, decoratorName) {
+		const importDeclarations = sourceFile.getImportDeclarations();
+		for (const importDecl of importDeclarations) if (importDecl.getModuleSpecifierValue() === "@angular/core") {
+			const namedImports = importDecl.getNamedImports();
+			for (const namedImport of namedImports) {
+				const alias = namedImport.getAliasNode();
+				if (alias && alias.getText() === decoratorName) return namedImport.getName();
+				if (!alias && namedImport.getName() === decoratorName) return decoratorName;
+			}
+		}
+		return null;
+	}
+	/**
+	* Determine NodeKind from Angular decorator
+	* @param decorator Angular decorator
+	* @returns NodeKind mapping
+	*/
+	determineNodeKind(decorator) {
+		switch (this.getDecoratorName(decorator)) {
+			case "Injectable": return "service";
+			case "Component": return "component";
+			case "Directive": return "directive";
+			default: return "unknown";
+		}
+	}
+	/**
+	* Detect and warn about anonymous class expressions
+	* Handles patterns like: const X = Decorator()(class { ... })
+	* @param sourceFile Source file to analyze
+	*/
+	detectAnonymousClasses(sourceFile) {
+		try {
+			sourceFile.forEachDescendant((node) => {
+				if (node.getKind() === ts_morph.SyntaxKind.ClassExpression) {
+					const parent = node.getParent();
+					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()}`);
+						}
+					}
+				}
+			});
+		} catch (error) {
+			if (this._options.verbose) console.log(`    Could not detect anonymous classes in ${sourceFile.getFilePath()}: ${error}`);
+		}
+	}
+	/**
+	* Extract constructor dependencies from a class declaration
+	* Implements FR-03: Constructor parameter analysis
+	* Implements TDD Cycle 2.1: inject() function detection
+	* @param classDeclaration ts-morph ClassDeclaration
+	* @returns Array of parsed dependencies
+	*/
+	extractConstructorDependencies(classDeclaration) {
+		const dependencies = [];
+		const verboseStats = {
+			decoratorCounts: {
+				optional: 0,
+				self: 0,
+				skipSelf: 0,
+				host: 0
+			},
+			skippedDecorators: [],
+			parametersWithDecorators: 0,
+			parametersWithoutDecorators: 0,
+			legacyDecoratorsUsed: 0,
+			injectPatternsUsed: 0,
+			totalProcessingTime: 0,
+			totalParameters: 0
+		};
+		const startTime = performance.now();
+		if (this._options.verbose && this._options.includeDecorators) {
+			console.log("=== Decorator Analysis ===");
+			const className = classDeclaration.getName() || "unknown";
+			console.log(`Analyzing decorators for class: ${className}`);
+		}
+		if (this._options.verbose && !this._options.includeDecorators) console.log("Decorator analysis disabled - --include-decorators flag not set");
+		const constructors = classDeclaration.getConstructors();
+		if (constructors.length > 0) {
+			const parameters = constructors[0].getParameters();
+			verboseStats.totalParameters = parameters.length;
+			for (const param of parameters) {
+				const paramStartTime = performance.now();
+				const dependency = this.parseConstructorParameter(param);
+				const paramEndTime = performance.now();
+				if (dependency) {
+					dependencies.push(dependency);
+					if (this._options.verbose && this._options.includeDecorators) this.collectVerboseStats(param, dependency, verboseStats);
+				}
+				verboseStats.totalProcessingTime += paramEndTime - paramStartTime;
+			}
+		}
+		const injectDependencies = this.extractInjectFunctionDependencies(classDeclaration);
+		dependencies.push(...injectDependencies);
+		verboseStats.totalProcessingTime = performance.now() - startTime;
+		if (this._options.verbose) this.outputVerboseAnalysis(dependencies, verboseStats, classDeclaration);
+		return dependencies;
+	}
+	/**
+	* Check if type reference is circular (Task 3.3)
+	* @param typeText Type text to check
+	* @param typeNode TypeNode for context
+	* @returns True if circular reference detected
+	*/
+	isCircularTypeReference(typeText, typeNode) {
+		const currentClass = typeNode.getFirstAncestorByKind(ts_morph.SyntaxKind.ClassDeclaration);
+		if (currentClass) {
+			if (currentClass.getName() === typeText) return true;
+		}
+		if (this._circularTypeRefs.has(typeText)) return true;
+		this._circularTypeRefs.add(typeText);
+		return false;
+	}
+	/**
+	* Check if type is generic (Task 3.3)
+	* @param typeText Type text to check
+	* @returns True if generic type
+	*/
+	isGenericType(typeText) {
+		return typeText.includes("<") && typeText.includes(">");
+	}
+	/**
+	* Handle generic types (Task 3.3)
+	* @param typeText Generic type text
+	* @param filePath File path for context
+	* @param lineNumber Line number
+	* @param columnNumber Column number
+	* @returns Token string or null
+	*/
+	handleGenericType(typeText, _filePath, _lineNumber, _columnNumber) {
+		if (this._options.verbose) console.log(`Processing generic type: ${typeText}`);
+		return typeText;
+	}
+	/**
+	* Check if type is union type (Task 3.3)
+	* @param typeText Type text to check
+	* @returns True if union type
+	*/
+	isUnionType(typeText) {
+		return typeText.includes(" | ") && !typeText.includes("<");
+	}
+	/**
+	* Handle union types (Task 3.3)
+	* @param typeText Union type text
+	* @param filePath File path for context
+	* @param lineNumber Line number
+	* @param columnNumber Column number
+	* @returns Null (union types are skipped)
+	*/
+	handleUnionType(typeText, filePath, lineNumber, columnNumber) {
+		this.addStructuredWarning("skippedTypes", {
+			type: "complex_union_type",
+			message: `Skipping complex union type: ${typeText}`,
+			file: filePath,
+			line: lineNumber,
+			column: columnNumber,
+			suggestion: "Consider using a single service type or interface",
+			severity: "info"
+		});
+		return null;
+	}
+	/**
+	* Check if type can be resolved through imports (Task 3.3)
+	* Handles module-scoped types (e.g., MyModule.ScopedService)
+	* @param typeNode TypeNode to check
+	* @returns True if type can be resolved
+	*/
+	canResolveType(typeNode) {
+		try {
+			const sourceFile = typeNode.getSourceFile();
+			const typeText = typeNode.getText();
+			const type = typeNode.getType();
+			const typeTextFromSystem = type.getText();
+			const symbol = type.getSymbol();
+			if (typeTextFromSystem === "error" || typeTextFromSystem === "any" || type.isUnknown()) return false;
+			if (!symbol) return false;
+			if ([
+				"Array",
+				"Promise",
+				"Observable",
+				"Date",
+				"Error"
+			].includes(typeText)) return true;
+			let simpleTypeText = typeText;
+			if (typeText.includes(".")) simpleTypeText = typeText.split(".")[0];
+			const imports = sourceFile.getImportDeclarations();
+			for (const importDecl of imports) {
+				const namedImports = importDecl.getNamedImports();
+				for (const namedImport of namedImports) if (namedImport.getName() === typeText || namedImport.getName() === simpleTypeText) return true;
+			}
+			const typeAliases = sourceFile.getTypeAliases();
+			const interfaces = sourceFile.getInterfaces();
+			const classes = sourceFile.getClasses();
+			if ([
+				...typeAliases,
+				...interfaces,
+				...classes
+			].some((decl) => decl.getName() === typeText || decl.getName() === simpleTypeText)) return true;
+			if (typeText.includes(".")) {
+				const namespaces = sourceFile.getModules();
+				for (const namespace of namespaces) if (namespace.getName() === simpleTypeText) return true;
+			}
+			return false;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Enhanced type token extraction with advanced analysis (Task 3.3)
+	* @param typeNode TypeNode to extract token from
+	* @param filePath File path for context
+	* @param lineNumber Line number
+	* @param columnNumber Column number
+	* @returns Token string or null
+	*/
+	extractTypeTokenEnhanced(typeNode, filePath, lineNumber, columnNumber) {
+		const typeText = typeNode.getText();
+		if (this._options.verbose) console.log(`Type resolution steps: Processing '${typeText}' at ${filePath}:${lineNumber}:${columnNumber}`);
+		if (this.isCircularTypeReference(typeText, typeNode)) {
+			this.addStructuredWarning("circularReferences", {
+				type: "circular_type_reference",
+				message: `Circular type reference detected: ${typeText}`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: "Consider using interfaces or breaking the circular dependency",
+				severity: "warning"
+			});
+			return null;
+		}
+		if (this.isGenericType(typeText)) return this.handleGenericType(typeText, filePath, lineNumber, columnNumber);
+		if (this.isUnionType(typeText)) return this.handleUnionType(typeText, filePath, lineNumber, columnNumber);
+		if (this.shouldSkipType(typeText)) {
+			this.addStructuredWarning("skippedTypes", {
+				type: "any_unknown_type",
+				message: `Skipping parameter with any/unknown type: ${typeText}`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: "Consider adding explicit type annotation",
+				severity: "warning"
+			});
+			return null;
+		}
+		if (this.isPrimitiveType(typeText)) {
+			this.addStructuredWarning("skippedTypes", {
+				type: "primitive_type",
+				message: `Skipping primitive type: ${typeText}`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: "Use dependency injection for services, not primitive types",
+				severity: "info"
+			});
+			return null;
+		}
+		if (!this.canResolveType(typeNode)) {
+			this.addStructuredWarning("unresolvedImports", {
+				type: "unresolved_type",
+				message: `Unresolved type '${typeText}' - check imports`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: `Ensure ${typeText} is properly imported`,
+				severity: "warning"
+			});
+			return null;
+		}
+		return typeText;
+	}
+	/**
+	* Resolve inferred types with enhanced validation (Task 3.3)
+	* @param type Type object from ts-morph
+	* @param typeText Type text representation
+	* @param param Parameter declaration for context
+	* @param filePath File path for warnings
+	* @param lineNumber Line number for warnings
+	* @param columnNumber Column number for warnings
+	* @returns Resolved token or null
+	*/
+	resolveInferredTypeEnhanced(type, typeText, param, filePath, lineNumber, columnNumber) {
+		if (this._options.verbose) console.log(`Attempting to resolve inferred type: ${typeText}`);
+		const symbol = type.getSymbol?.();
+		if (symbol) {
+			const symbolName = symbol.getName();
+			if (symbolName && symbolName !== "__type") return symbolName;
+		}
+		const aliasSymbol = type.getAliasSymbol?.();
+		if (aliasSymbol) {
+			const declarations = aliasSymbol.getDeclarations();
+			if (declarations && declarations.length > 0) return aliasSymbol.getName();
+		}
+		if (this.shouldSkipType(typeText)) {
+			this.addStructuredWarning("skippedTypes", {
+				type: "inferred_any_unknown",
+				message: `Skipping parameter '${param.getName()}' with inferred any/unknown type`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: "Add explicit type annotation to improve type safety",
+				severity: "warning"
+			});
+			return null;
+		}
+		if (this.isPrimitiveType(typeText)) {
+			this.addStructuredWarning("skippedTypes", {
+				type: "inferred_primitive",
+				message: `Skipping inferred primitive type parameter '${param.getName()}': ${typeText}`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: "Use dependency injection for services, not primitive types",
+				severity: "info"
+			});
+			return null;
+		}
+		const aliasSymbolCheck = type.getAliasSymbol?.();
+		const hasValidAliasSymbol = aliasSymbolCheck && aliasSymbolCheck.getDeclarations().length > 0;
+		if (!symbol && !hasValidAliasSymbol) {
+			this.addStructuredWarning("unresolvedImports", {
+				type: "unresolved_type",
+				message: `Unresolved type '${typeText}' - check imports`,
+				file: filePath,
+				line: lineNumber,
+				column: columnNumber,
+				suggestion: `Ensure ${typeText} is properly imported`,
+				severity: "warning"
+			});
+			return null;
+		}
+		return typeText;
+	}
+	/**
+	* Parse a single constructor parameter to extract dependency token
+	* Implements FR-03 token resolution priority: @Inject > type annotation > inferred type
+	* Implements FR-04 parameter decorator handling
+	* @param param ts-morph ParameterDeclaration
+	* @returns ParsedDependency if valid dependency, null if should be skipped
+	*/
+	parseConstructorParameter(param) {
+		const parameterName = param.getName();
+		const filePath = param.getSourceFile().getFilePath();
+		const lineNumber = param.getStartLineNumber();
+		const columnNumber = param.getStart() - param.getStartLinePos();
+		const startTime = performance.now();
+		let cacheKey = null;
+		try {
+			const flags = this.extractParameterDecorators(param);
+			const injectDecorator = param.getDecorator("Inject");
+			if (injectDecorator) {
+				const token = this.extractInjectToken(injectDecorator);
+				if (token) return {
+					token,
+					flags,
+					parameterName
+				};
+			}
+			const initializer = param.getInitializer();
+			if (initializer) {
+				const injectResult = this.analyzeInjectCall(initializer);
+				if (injectResult) {
+					const finalFlags = Object.keys(flags).length > 0 ? flags : injectResult.flags;
+					return {
+						token: injectResult.token,
+						flags: finalFlags,
+						parameterName
+					};
+				}
+			}
+			const typeNode_check = param.getTypeNode();
+			if (typeNode_check) {
+				const token = this.extractTypeTokenEnhanced(typeNode_check, filePath, lineNumber, columnNumber);
+				if (token) return {
+					token,
+					flags,
+					parameterName
+				};
+			}
+			const type = param.getType();
+			const typeText = type.getText(param);
+			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}`);
+				return cachedResult ? {
+					token: cachedResult,
+					flags,
+					parameterName
+				} : null;
+			}
+			if (this._options.verbose) console.log(`Cache miss for parameter '${parameterName}': ${typeText}`);
+			const resolvedToken = this.resolveInferredTypeEnhanced(type, typeText, param, filePath, lineNumber, columnNumber);
+			this._typeResolutionCache.set(cacheKey, resolvedToken);
+			if (resolvedToken) return {
+				token: resolvedToken,
+				flags,
+				parameterName
+			};
+			return null;
+		} finally {
+			const duration = performance.now() - startTime;
+			if (cacheKey && duration > 10) {
+				if (this._typeResolutionCache.get(cacheKey)) this.addStructuredWarning("performance", {
+					type: "slow_type_resolution",
+					message: `Slow type resolution for parameter '${parameterName}' (${duration.toFixed(2)}ms)`,
+					file: filePath,
+					line: lineNumber,
+					column: columnNumber,
+					suggestion: "Consider adding explicit type annotation",
+					severity: "info"
+				});
+			}
+		}
+	}
+	/**
+	* Extract token from @Inject decorator
+	* @param decorator @Inject decorator
+	* @returns Token string or null
+	*/
+	extractInjectToken(decorator) {
+		const callExpr = decorator.getCallExpression();
+		if (!callExpr) return null;
+		const args = callExpr.getArguments();
+		if (args.length === 0) return null;
+		return args[0].getText().replace(/['"]/g, "");
+	}
+	/**
+	* Check if type should be skipped (any/unknown types)
+	* Implements FR-09: Skip dependencies whose type resolves to any/unknown
+	* @param typeText Type text to check
+	* @returns True if should be skipped
+	*/
+	shouldSkipType(typeText) {
+		return [
+			"any",
+			"unknown",
+			"object",
+			"Object"
+		].includes(typeText);
+	}
+	/**
+	* Check if type is primitive and should be skipped
+	* @param typeText Type text to check
+	* @returns True if primitive type
+	*/
+	isPrimitiveType(typeText) {
+		return [
+			"string",
+			"number",
+			"boolean",
+			"symbol",
+			"bigint",
+			"undefined",
+			"null"
+		].includes(typeText);
+	}
+	/**
+	* Extract parameter decorators from constructor parameter
+	* Implements FR-04: Parameter decorator handling (@Optional, @Self, @SkipSelf, @Host)
+	* Optimized for performance with early returns and minimal object allocation
+	* @param param ts-morph ParameterDeclaration
+	* @returns EdgeFlags object with detected decorators
+	*/
+	extractParameterDecorators(param) {
+		return this.analyzeParameterDecorators(param, this._options.includeDecorators);
+	}
+	/**
+	* Extract dependencies from inject() function calls in class properties
+	* Implements TDD Cycle 2.1: Modern Angular inject() pattern detection
+	* @param classDeclaration ts-morph ClassDeclaration
+	* @returns Array of parsed dependencies from inject() calls
+	*/
+	extractInjectFunctionDependencies(classDeclaration) {
+		const dependencies = [];
+		try {
+			const properties = classDeclaration.getProperties();
+			for (const property of properties) {
+				const dependency = this.parseInjectProperty(property);
+				if (dependency) dependencies.push(dependency);
+			}
+		} catch (error) {
+			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)}`);
+			}
+		}
+		return dependencies;
+	}
+	/**
+	* Parse a property declaration for inject() function calls
+	* @param property ts-morph PropertyDeclaration
+	* @returns ParsedDependency if inject() call found, null otherwise
+	*/
+	parseInjectProperty(property) {
+		try {
+			const initializer = property.getInitializer();
+			if (!initializer) return null;
+			if (initializer.getKind() !== ts_morph.SyntaxKind.CallExpression) return null;
+			const callExpression = initializer;
+			const expression = callExpression.getExpression();
+			if (expression.getKind() !== ts_morph.SyntaxKind.Identifier) return null;
+			if (expression.getText() !== "inject") return null;
+			if (!this.isAngularInjectImported(property.getSourceFile())) return null;
+			const args = callExpression.getArguments();
+			if (args.length === 0) return null;
+			const token = args[0].getText().replace(/['"]/g, "");
+			if (this.shouldSkipType(token) || this.isPrimitiveType(token)) return null;
+			let flags = {};
+			if (args.length > 1 && this._options.includeDecorators) flags = this.parseInjectOptions(args[1]);
+			const propertyName = property.getName() || "unknown";
+			return {
+				token,
+				flags,
+				parameterName: propertyName
+			};
+		} catch (error) {
+			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)}`);
+			}
+			return null;
+		}
+	}
+	/**
+	* Parse options object from inject() function call
+	* @param optionsArg Options argument from inject() call
+	* @returns EdgeFlags object with parsed options
+	*/
+	parseInjectOptions(optionsArg) {
+		const flags = {};
+		try {
+			if (optionsArg.getKind() !== ts_morph.SyntaxKind.ObjectLiteralExpression) return flags;
+			const properties = optionsArg.getProperties();
+			const supportedOptions = new Set([
+				"optional",
+				"self",
+				"skipSelf",
+				"host"
+			]);
+			for (const prop of properties) {
+				if (prop.getKind() !== ts_morph.SyntaxKind.PropertyAssignment) continue;
+				const propertyAssignment = prop;
+				const name = propertyAssignment.getName();
+				if (!supportedOptions.has(name)) {
+					if (this._options.verbose) console.warn(`Unknown inject() option: '${name}' - ignoring`);
+					continue;
+				}
+				const initializer = propertyAssignment.getInitializer();
+				if (initializer && initializer.getText() === "true") switch (name) {
+					case "optional":
+						flags.optional = true;
+						break;
+					case "self":
+						flags.self = true;
+						break;
+					case "skipSelf":
+						flags.skipSelf = true;
+						break;
+					case "host":
+						flags.host = true;
+						break;
+				}
+			}
+		} catch (error) {
+			if (this._options.verbose) console.warn(`Warning: Failed to parse inject() options: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		return flags;
+	}
+	/**
+	* Analyze parameter decorators for TDD Cycle 1.1
+	* Legacy parameter decorator detection method for @Optional, @Self, @SkipSelf, @Host
+	* @param parameter ParameterDeclaration to analyze
+	* @param includeDecorators Whether to include decorators in analysis
+	* @returns EdgeFlags object with detected decorators
+	*/
+	analyzeParameterDecorators(parameter, includeDecorators, verboseStats) {
+		if (!includeDecorators) return {};
+		const decorators = parameter.getDecorators();
+		if (decorators.length === 0) return {};
+		const flags = {};
+		try {
+			const supportedDecorators = new Set([
+				"Optional",
+				"Self",
+				"SkipSelf",
+				"Host"
+			]);
+			for (const decorator of decorators) {
+				const decoratorName = this.getDecoratorName(decorator);
+				if (decoratorName === "Inject") continue;
+				if (supportedDecorators.has(decoratorName)) switch (decoratorName) {
+					case "Optional":
+						flags.optional = true;
+						break;
+					case "Self":
+						flags.self = true;
+						break;
+					case "SkipSelf":
+						flags.skipSelf = true;
+						break;
+					case "Host":
+						flags.host = true;
+						break;
+				}
+				else if (decoratorName) {
+					if (verboseStats) verboseStats.skippedDecorators.push({
+						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.`);
+				}
+			}
+		} 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)}`);
+			}
+			return {};
+		}
+		return flags;
+	}
+	/**
+	* Check if inject() function is imported from @angular/core
+	* Prevents false positives from custom inject() functions
+	* @param sourceFile Source file to check imports
+	* @returns True if Angular inject is imported
+	*/
+	isAngularInjectImported(sourceFile) {
+		try {
+			const importDeclarations = sourceFile.getImportDeclarations();
+			for (const importDecl of importDeclarations) if (importDecl.getModuleSpecifierValue() === "@angular/core") {
+				const namedImports = importDecl.getNamedImports();
+				for (const namedImport of namedImports) {
+					const importName = namedImport.getName();
+					const alias = namedImport.getAliasNode();
+					if (importName === "inject" || alias && alias.getText() === "inject") return true;
+				}
+			}
+			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)}`);
+			return true;
+		}
+	}
+	/**
+	* Analyze inject() function call expression to extract token and options
+	* Implements TDD Cycle 2.1 - Modern Angular inject() pattern support
+	* @param expression Expression to analyze (should be a CallExpression)
+	* @returns ParameterAnalysisResult or null if not a valid inject() call
+	*/
+	analyzeInjectCall(expression) {
+		if (!expression) return null;
+		if (expression.getKind() !== ts_morph.SyntaxKind.CallExpression) return null;
+		const callExpression = expression;
+		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 args = callExpression.getArguments();
+			if (args.length === 0) {
+				if (this._options.verbose) console.warn("inject() called without token parameter - skipping");
+				return null;
+			}
+			const tokenArg = args[0];
+			let token;
+			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");
+					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`);
+					return null;
+				}
+			} else if (tokenArg.getKind() === ts_morph.SyntaxKind.NullKeyword) {
+				if (this._options.verbose) console.warn("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");
+					return null;
+				}
+			}
+			let flags = {};
+			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`);
+				}
+			}
+			return {
+				token,
+				flags,
+				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)}`);
+			}
+			return null;
+		}
+	}
+	/**
+	* Collect verbose statistics for decorator analysis
+	* @param param Parameter declaration being analyzed
+	* @param dependency Parsed dependency result
+	* @param verboseStats Statistics object to update
+	*/
+	collectVerboseStats(param, dependency, verboseStats) {
+		const paramName = param.getName();
+		console.log(`Parameter: ${paramName}`);
+		console.log(`  Token: ${dependency.token}`);
+		if (Object.keys(dependency.flags || {}).length > 0) {
+			verboseStats.parametersWithDecorators++;
+			if (dependency.flags?.optional) verboseStats.decoratorCounts.optional++;
+			if (dependency.flags?.self) verboseStats.decoratorCounts.self++;
+			if (dependency.flags?.skipSelf) verboseStats.decoratorCounts.skipSelf++;
+			if (dependency.flags?.host) verboseStats.decoratorCounts.host++;
+			const decorators = param.getDecorators();
+			let hasLegacyDecorators = false;
+			let hasInjectPattern = false;
+			this.analyzeParameterDecorators(param, true, verboseStats);
+			for (const decorator of decorators) {
+				const decoratorName = this.getDecoratorName(decorator);
+				if ([
+					"Optional",
+					"Self",
+					"SkipSelf",
+					"Host"
+				].includes(decoratorName)) {
+					hasLegacyDecorators = true;
+					console.log(`  Legacy decorator: @${decoratorName}`);
+				}
+			}
+			const initializer = param.getInitializer();
+			if (initializer && initializer.getKind() === ts_morph.SyntaxKind.CallExpression) {
+				const expression = initializer.getExpression();
+				if (expression.getKind() === ts_morph.SyntaxKind.Identifier) {
+					if (expression.getText() === "inject") {
+						hasInjectPattern = true;
+						verboseStats.injectPatternsUsed++;
+						const flagsStr = JSON.stringify(dependency.flags);
+						console.log(`  inject() options: ${flagsStr}`);
+					}
+				}
+			}
+			if (hasLegacyDecorators) {
+				verboseStats.legacyDecoratorsUsed++;
+				if (hasInjectPattern) {
+					console.log("  Decorator Precedence Analysis");
+					console.log("  Legacy decorators take precedence over inject() options");
+					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}`);
+					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}`);
+					}
+					const finalFlags = JSON.stringify(dependency.flags);
+					console.log(`  Final flags: ${finalFlags}`);
+				}
+			}
+		} else {
+			verboseStats.parametersWithoutDecorators++;
+			console.log("  No decorators detected");
+		}
+	}
+	/**
+	* Output comprehensive verbose analysis summary
+	* @param dependencies All parsed dependencies
+	* @param verboseStats Collected statistics
+	* @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}`);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/formatters/json-formatter.ts
+/**
+* JSON formatter for dependency graph output
+* Produces pretty-printed JSON with 2-space indentation
+*/
+var JsonFormatter = class {
+	/**
+	* Create a new JSON formatter
+	* @param logger Optional Logger instance for verbose mode
+	*/
+	constructor(logger) {
+		this._logger = logger;
+	}
+	/**
+	* Format a dependency graph as JSON
+	* @param graph The dependency graph to format
+	* @returns Pretty-printed JSON string
+	*/
+	format(graph) {
+		this._logger?.time("json-format");
+		this._logger?.info(LogCategory.PERFORMANCE, "Generating JSON output", {
+			nodeCount: graph.nodes.length,
+			edgeCount: graph.edges.length
+		});
+		const result = JSON.stringify(graph, null, 2);
+		const elapsed = this._logger?.timeEnd("json-format") ?? 0;
+		this._logger?.info(LogCategory.PERFORMANCE, "JSON output complete", {
+			outputSize: result.length,
+			elapsed
+		});
+		return result;
+	}
+};
+
+//#endregion
+//#region src/formatters/mermaid-formatter.ts
+/**
+* Mermaid formatter for dependency graph output
+* Produces flowchart LR syntax compatible with Mermaid Live Editor
+*/
+var MermaidFormatter = class {
+	/**
+	* Create a new Mermaid formatter
+	* @param logger Optional Logger instance for verbose mode
+	*/
+	constructor(logger) {
+		this._logger = logger;
+	}
+	/**
+	* Format a dependency graph as Mermaid flowchart
+	* @param graph The dependency graph to format
+	* @returns Mermaid flowchart string
+	*/
+	format(graph) {
+		this._logger?.time("mermaid-format");
+		this._logger?.info(LogCategory.PERFORMANCE, "Generating Mermaid output", {
+			nodeCount: graph.nodes.length,
+			edgeCount: graph.edges.length
+		});
+		if (graph.nodes.length === 0) {
+			const result$1 = "flowchart LR\n  %% Empty graph - no nodes to display";
+			const elapsed$1 = this._logger?.timeEnd("mermaid-format") ?? 0;
+			this._logger?.info(LogCategory.PERFORMANCE, "Mermaid output complete", {
+				outputSize: 51,
+				elapsed: elapsed$1
+			});
+			return result$1;
+		}
+		const lines = ["flowchart LR"];
+		for (const edge of graph.edges) {
+			const fromNode = this.sanitizeNodeName(edge.from);
+			const toNode = this.sanitizeNodeName(edge.to);
+			if (edge.isCircular) lines.push(`  ${fromNode} -.->|circular| ${toNode}`);
+			else lines.push(`  ${fromNode} --> ${toNode}`);
+		}
+		if (graph.circularDependencies.length > 0) {
+			lines.push("");
+			lines.push("  %% Circular Dependencies Detected:");
+			for (const cycle of graph.circularDependencies) lines.push(`  %% ${cycle.join(" -> ")} -> ${cycle[0]}`);
+		}
+		const result = lines.join("\n");
+		const elapsed = this._logger?.timeEnd("mermaid-format") ?? 0;
+		this._logger?.info(LogCategory.PERFORMANCE, "Mermaid output complete", {
+			outputSize: result.length,
+			elapsed
+		});
+		return result;
+	}
+	/**
+	* Sanitize node names for Mermaid compatibility
+	* Replaces special characters that break Mermaid syntax
+	* @param nodeName The original node name
+	* @returns Sanitized node name
+	*/
+	sanitizeNodeName(nodeName) {
+		return nodeName.replace(/[.-]/g, "_").replace(/[^a-zA-Z0-9_]/g, "");
+	}
+};
+
+//#endregion
+//#region src/cli/index.ts
+/**
+* ng-di-graph CLI entry point
+* Supports Node.js (via tsx) execution
+*/
+const MIN_NODE_MAJOR_VERSION = 20;
+function enforceMinimumNodeVersion() {
+	const nodeVersion = process.versions.node;
+	if (!nodeVersion) return;
+	const [majorSegment] = nodeVersion.split(".");
+	const major = Number(majorSegment);
+	if (Number.isNaN(major) || major >= MIN_NODE_MAJOR_VERSION) return;
+	const runtimeLabel = process.versions.bun ? `Bun (Node compatibility ${nodeVersion})` : `Node.js ${nodeVersion}`;
+	console.error([
+		`ng-di-graph requires Node.js >= ${MIN_NODE_MAJOR_VERSION}.0.0.`,
+		`Detected runtime: ${runtimeLabel}.`,
+		"Upgrade to Node.js 20.x LTS (match `.node-version` / mise config) before running ng-di-graph."
+	].join("\n"));
+	process.exit(1);
+}
+enforceMinimumNodeVersion();
+const program = new commander.Command();
+program.name("ng-di-graph").description("Angular DI dependency graph CLI tool").version("0.1.0");
+program.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 (options) => {
+	try {
+		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 cliOptions = {
+			project: options.project,
+			format: options.format,
+			entry: options.entry,
+			direction: options.direction,
+			includeDecorators: options.includeDecorators,
+			out: options.out,
+			verbose: options.verbose
+		};
+		const logger = createLogger(cliOptions.verbose);
+		if (logger) {
+			logger.time("total-execution");
+			logger.info(LogCategory.FILE_PROCESSING, "CLI execution started", {
+				runtime: process.versions.bun ? "Bun" : "Node.js",
+				version: process.versions.bun || process.versions.node,
+				options: cliOptions
+			});
+		}
+		if (cliOptions.verbose) {
+			console.log("🔧 CLI Options:", JSON.stringify(cliOptions, null, 2));
+			console.log(`🚀 Running with ${process.versions.bun ? "Bun" : "Node.js"} ${process.versions.bun || process.versions.node}`);
+		}
+		const parser = new AngularParser(cliOptions, logger);
+		if (cliOptions.verbose) console.log("📂 Loading TypeScript project...");
+		parser.loadProject();
+		if (cliOptions.verbose) console.log("✅ Project loaded successfully");
+		if (cliOptions.verbose) console.log("🔍 Parsing Angular classes...");
+		const parsedClasses = await parser.parseClasses();
+		if (cliOptions.verbose) console.log(`✅ Found ${parsedClasses.length} decorated classes`);
+		if (cliOptions.verbose) console.log("🔗 Building dependency graph...");
+		let graph = buildGraph(parsedClasses, logger);
+		if (cliOptions.verbose) {
+			console.log(`✅ Graph built: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+			if (graph.circularDependencies.length > 0) console.log(`⚠️  Detected ${graph.circularDependencies.length} circular dependencies`);
+		}
+		if (cliOptions.entry && cliOptions.entry.length > 0) {
+			if (cliOptions.verbose) console.log(`🔍 Filtering graph by entry points: ${cliOptions.entry.join(", ")}`);
+			graph = filterGraph(graph, cliOptions);
+			if (cliOptions.verbose) console.log(`✅ Filtered graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges`);
+		}
+		let formatter;
+		if (cliOptions.format === "mermaid") formatter = new MermaidFormatter(logger);
+		else formatter = new JsonFormatter(logger);
+		const formattedOutput = formatter.format(graph);
+		await new OutputHandler().writeOutput(formattedOutput, cliOptions.out);
+		if (cliOptions.verbose && cliOptions.out) console.log(`✅ Output written to: ${cliOptions.out}`);
+		if (logger) {
+			const totalTime = logger.timeEnd("total-execution");
+			const stats = logger.getStats();
+			console.error("\n📊 Performance Summary:");
+			console.error(`  Total time: ${totalTime.toFixed(2)}ms`);
+			console.error(`  Peak memory: ${(stats.memoryUsage.peakUsage / 1024 / 1024).toFixed(2)}MB`);
+			console.error(`  Total logs: ${stats.totalLogs}`);
+		}
+	} catch (error) {
+		if (error instanceof CliError) ErrorHandler.handleError(error, options.verbose);
+		else if (error instanceof Error) {
+			const cliError = ErrorHandler.createError(error.message, "INTERNAL_ERROR", void 0, { originalError: error.name });
+			ErrorHandler.handleError(cliError, options.verbose);
+		} else {
+			const cliError = ErrorHandler.createError("An unexpected error occurred", "INTERNAL_ERROR", void 0, { error: String(error) });
+			ErrorHandler.handleError(cliError, options.verbose);
+		}
+	}
+});
+process.on("unhandledRejection", (reason, promise) => {
+	const error = ErrorHandler.createError(`Unhandled promise rejection: ${reason}`, "INTERNAL_ERROR", void 0, { promise: String(promise) });
+	ErrorHandler.handleError(error, false);
+});
+process.on("uncaughtException", (error) => {
+	const cliError = ErrorHandler.createError(`Uncaught exception: ${error.message}`, "INTERNAL_ERROR", void 0, { stack: error.stack });
+	ErrorHandler.handleError(cliError, true);
+});
+const argv = process.argv.length <= 2 ? [...process.argv, "--help"] : process.argv;
+program.parse(argv);
+
+//#endregion
+//# sourceMappingURL=index.cjs.map