@ts-for-gir/reporter 4.0.0-beta.39 → 4.0.0-beta.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/reporter",
-  "version": "4.0.0-beta.39",
+  "version": "4.0.0-beta.41",
   "description": "Problem reporting and comprehensive generation analysis for ts-for-gir",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -37,7 +37,8 @@
     "analysis"
   ],
   "devDependencies": {
-    "@types/node": "^24.11.0",
+    "@ts-for-gir/tsconfig": "^4.0.0-beta.41",
+    "@types/node": "^24.12.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {

package/src/console-reporter.ts

@@ -8,8 +8,9 @@ import { blue, gray, green, red, yellow, yellowBright } from "colorette";
 import { PACKAGE_VERSION } from "./constants.ts";
 import { analyzeError, analyzeWarning } from "./message-analyzer.ts";
 import { ReporterBase } from "./reporter-base.ts";
-import type { GenerationReport, ProblemEntry, ReporterConfig, ReportStatistics } from "./types/index.ts";
+import type { GenerationReport, ReporterConfig } from "./types/index.ts";
 import { ProblemCategory, ProblemSeverity } from "./types/index.ts";
+import { computeProblemStatistics, generateReportSummary, groupProblemsByCategory } from "./types/report.ts";
 
 /**
  * Console Reporter implementation with full logging capabilities
@@ -146,10 +147,16 @@ export class ConsoleReporter extends ReporterBase {
 	// === Problem-specific reporting methods ===
 
 	public reportTypeResolutionError(typeName: string, namespace: string, message: string, details?: string): void {
-		this.addProblem(ProblemSeverity.ERROR, ProblemCategory.TYPE_RESOLUTION, message, details, typeName, namespace, {
-			namespace,
+		this.addProblem(
+			ProblemSeverity.ERROR,
+			ProblemCategory.TYPE_RESOLUTION,
+			message,
+			details,
 			typeName,
-		});
+			namespace,
+			undefined,
+			namespace,
+		);
 
 		if (this.config.verbose) {
 			const txt = this.prependInfo(message, "ERROR:");
@@ -157,11 +164,23 @@ export class ConsoleReporter extends ReporterBase {
 		}
 	}
 
-	public reportTypeResolutionWarning(typeName: string, namespace: string, message: string, details?: string): void {
-		this.addProblem(ProblemSeverity.WARNING, ProblemCategory.TYPE_RESOLUTION, message, details, typeName, namespace, {
-			namespace,
+	public reportTypeResolutionWarning(
+		typeName: string,
+		namespace: string,
+		message: string,
+		details?: string,
+		sourceModule?: string,
+	): void {
+		this.addProblem(
+			ProblemSeverity.WARNING,
+			ProblemCategory.TYPE_RESOLUTION,
+			message,
+			details,
 			typeName,
-		});
+			namespace,
+			sourceModule ? { sourceModule } : undefined,
+			namespace,
+		);
 
 		if (this.config.verbose) {
 			const txt = this.prependInfo(message, "WARN:");
@@ -204,10 +223,16 @@ export class ConsoleReporter extends ReporterBase {
 	public reportTypeConflict(conflictType: string, elementName: string, namespace: string, details?: string): void {
 		const message = `Type conflict (${conflictType}): ${elementName}`;
 
-		this.addProblem(ProblemSeverity.WARNING, ProblemCategory.TYPE_CONFLICT, message, details, elementName, namespace, {
-			conflictType,
+		this.addProblem(
+			ProblemSeverity.WARNING,
+			ProblemCategory.TYPE_CONFLICT,
+			message,
+			details,
+			elementName,
 			namespace,
-		});
+			{ conflictType },
+			namespace,
+		);
 
 		if (this.config.verbose) {
 			const txt = this.prependInfo(message, "WARN:");
@@ -235,182 +260,9 @@ export class ConsoleReporter extends ReporterBase {
 
 	// === Report generation methods ===
 
-	private generateStatistics(): ReportStatistics {
-		const bySeverity = Object.values(ProblemSeverity).reduce(
-			(acc, severity) => {
-				acc[severity] = 0;
-				return acc;
-			},
-			{} as Record<ProblemSeverity, number>,
-		);
-
-		const byCategory = Object.values(ProblemCategory).reduce(
-			(acc, category) => {
-				acc[category] = 0;
-				return acc;
-			},
-			{} as Record<ProblemCategory, number>,
-		);
-
-		const byModule: Record<string, number> = {};
-
-		// Type-specific tracking
-		const unresolvedTypes: Record<string, { count: number; namespaces: Set<string> }> = {};
-		const typeConflicts: Record<string, { count: number; examples: Set<string> }> = {};
-		const namespaceProblems: Record<string, { count: number; types: Set<string> }> = {};
-
-		for (const problem of this.problems) {
-			bySeverity[problem.severity]++;
-			byCategory[problem.category]++;
-			byModule[problem.module] = (byModule[problem.module] || 0) + 1;
-
-			// Track type resolution problems
-			if (problem.category === ProblemCategory.TYPE_RESOLUTION && problem.typeName) {
-				if (!unresolvedTypes[problem.typeName]) {
-					unresolvedTypes[problem.typeName] = { count: 0, namespaces: new Set() };
-				}
-				unresolvedTypes[problem.typeName].count++;
-				if (problem.location) {
-					unresolvedTypes[problem.typeName].namespaces.add(problem.location);
-				}
-
-				// Track namespace problems
-				if (problem.location) {
-					if (!namespaceProblems[problem.location]) {
-						namespaceProblems[problem.location] = { count: 0, types: new Set() };
-					}
-					namespaceProblems[problem.location].count++;
-					namespaceProblems[problem.location].types.add(problem.typeName);
-				}
-			}
-
-			// Track type conflicts
-			if (problem.category === ProblemCategory.TYPE_CONFLICT && problem.metadata?.conflictType) {
-				const conflictType = problem.metadata.conflictType as string;
-				if (!typeConflicts[conflictType]) {
-					typeConflicts[conflictType] = { count: 0, examples: new Set() };
-				}
-				typeConflicts[conflictType].count++;
-				if (problem.typeName) {
-					typeConflicts[conflictType].examples.add(problem.typeName);
-				}
-			}
-		}
-
-		// Convert to arrays and sort
-		const commonUnresolvedTypes = Object.entries(unresolvedTypes)
-			.map(([type, data]) => ({
-				type,
-				count: data.count,
-				namespaces: Array.from(data.namespaces),
-			}))
-			.sort((a, b) => b.count - a.count)
-			.slice(0, 20);
-
-		const commonTypeConflicts = Object.entries(typeConflicts)
-			.map(([conflictType, data]) => ({
-				conflictType,
-				count: data.count,
-				examples: Array.from(data.examples).slice(0, 5),
-			}))
-			.sort((a, b) => b.count - a.count);
-
-		const problematicNamespaces = Object.entries(namespaceProblems)
-			.map(([namespace, data]) => ({
-				namespace,
-				problems: data.count,
-				types: Array.from(data.types).slice(0, 10),
-			}))
-			.sort((a, b) => b.problems - a.problems)
-			.slice(0, 10);
-
-		const mostProblematicModules = Object.entries(byModule)
-			.sort(([, a], [, b]) => b - a)
-			.slice(0, 10)
-			.map(([module, count]) => ({ module, count }));
-
-		const endTime = new Date();
-		const durationMs = endTime.getTime() - this.startTime.getTime();
-
-		return {
-			bySeverity,
-			byCategory,
-			byModule,
-			totalProblems: this.problems.length,
-			mostProblematicModules,
-			typeStatistics: {
-				commonUnresolvedTypes,
-				commonTypeConflicts,
-				problematicNamespaces,
-			},
-			startTime: this.startTime,
-			endTime,
-			durationMs,
-		};
-	}
-
-	private generateSummary(statistics: ReportStatistics): GenerationReport["summary"] {
-		const { bySeverity, byCategory, totalProblems } = statistics;
-
-		let status: "success" | "partial" = "success";
-		if (bySeverity[ProblemSeverity.ERROR] > 0 || bySeverity[ProblemSeverity.WARNING] > 20) {
-			status = "partial";
-		}
-
-		const keyIssues: string[] = [];
-		const recommendations: string[] = [];
-
-		// Analyze key issues
-		if (byCategory[ProblemCategory.TYPE_RESOLUTION] > 0) {
-			keyIssues.push(`${byCategory[ProblemCategory.TYPE_RESOLUTION]} type resolution issues detected`);
-			recommendations.push("Review GIR files for missing or incorrect type definitions");
-		}
-
-		if (byCategory[ProblemCategory.PARSING_FAILURE] > 0) {
-			keyIssues.push(`${byCategory[ProblemCategory.PARSING_FAILURE]} parsing failures occurred`);
-			recommendations.push("Check GIR file syntax and ensure proper introspection data");
-		}
-
-		if (byCategory[ProblemCategory.GENERATION_FAILURE] > 0) {
-			keyIssues.push(`${byCategory[ProblemCategory.GENERATION_FAILURE]} generation failures encountered`);
-			recommendations.push("Review template configuration and output settings");
-		}
-
-		if (byCategory[ProblemCategory.TYPE_CONFLICT] > 5) {
-			keyIssues.push(`High number of type conflicts (${byCategory[ProblemCategory.TYPE_CONFLICT]})`);
-			recommendations.push("Consider using ignore patterns or updating GIR files to resolve conflicts");
-		}
-
-		if (keyIssues.length === 0 && totalProblems > 0) {
-			keyIssues.push(`${totalProblems} minor issues detected`);
-		}
-
-		if (recommendations.length === 0 && totalProblems > 0) {
-			recommendations.push("Review detailed problem list for specific improvement opportunities");
-		}
-
-		return {
-			status,
-			keyIssues,
-			recommendations,
-		};
-	}
-
 	public generateReport(): GenerationReport {
-		const statistics = this.generateStatistics();
-		const summary = this.generateSummary(statistics);
-
-		const problemsByCategory = Object.values(ProblemCategory).reduce(
-			(acc, category) => {
-				acc[category] = [];
-				return acc;
-			},
-			{} as Record<ProblemCategory, ProblemEntry[]>,
-		);
-
-		for (const problem of this.problems) {
-			problemsByCategory[problem.category].push(problem);
-		}
+		const statistics = computeProblemStatistics(this.problems, this.startTime);
+		const summary = generateReportSummary(statistics);
 
 		return {
 			metadata: {
@@ -419,7 +271,7 @@ export class ConsoleReporter extends ReporterBase {
 			},
 			statistics,
 			problems: [...this.problems],
-			problemsByCategory,
+			problemsByCategory: groupProblemsByCategory(this.problems),
 			summary,
 		};
 	}
@@ -455,8 +307,11 @@ export class ConsoleReporter extends ReporterBase {
 		console.log("=".repeat(50));
 
 		// Status
-		const statusColor = summary.status === "success" ? green : summary.status === "partial" ? yellow : red;
+		const statusColor = summary.status === "partial" ? yellow : green;
 		console.log(`Status: ${statusColor(summary.status.toUpperCase())}`);
+		if (summary.status === "success_with_warnings") {
+			console.log(green("  All issues are non-blocking. Generated types are complete."));
+		}
 
 		// Statistics
 		console.log(`\n📈 Statistics:`);
@@ -481,13 +336,17 @@ export class ConsoleReporter extends ReporterBase {
 
 			// Type-specific statistics
 			if (statistics.typeStatistics.commonUnresolvedTypes.length > 0) {
-				console.log(`\n❌ Most Common Unresolved Types:`);
-				statistics.typeStatistics.commonUnresolvedTypes.slice(0, 10).forEach(({ type, count, namespaces }) => {
-					console.log(`  ${red(type)}: ${count} occurrences in ${namespaces.length} namespace(s)`);
-					if (namespaces.length <= 3) {
-						console.log(`    └─ ${gray(namespaces.join(", "))}`);
-					}
-				});
+				console.log(`\n⚠️  Most Common Unresolved Types (produce 'never' type):`);
+				statistics.typeStatistics.commonUnresolvedTypes
+					.slice(0, 10)
+					.forEach(({ type, count, namespaces, sourceModules }) => {
+						console.log(`  ${yellow(type)}: ${count} occurrences (origin: ${namespaces.join(", ") || "unknown"})`);
+						if (sourceModules.length > 0) {
+							const moduleList = sourceModules.slice(0, 5).join(", ");
+							const moreModules = sourceModules.length > 5 ? ` and ${sourceModules.length - 5} more` : "";
+							console.log(`    └─ Referenced from: ${gray(moduleList + moreModules)}`);
+						}
+					});
 			}
 
 			if (statistics.typeStatistics.commonTypeConflicts.length > 0) {
@@ -501,9 +360,9 @@ export class ConsoleReporter extends ReporterBase {
 			}
 
 			if (statistics.typeStatistics.problematicNamespaces.length > 0) {
-				console.log(`\n🚨 Most Problematic Namespaces:`);
+				console.log(`\n📂 Namespaces with Most Warnings:`);
 				statistics.typeStatistics.problematicNamespaces.slice(0, 5).forEach(({ namespace, problems, types }) => {
-					console.log(`  ${namespace}: ${problems} problems`);
+					console.log(`  ${namespace}: ${problems} warnings`);
 					if (types.length > 0) {
 						const typeList = types.slice(0, 5).join(", ");
 						const moreTypes = types.length > 5 ? ` and ${types.length - 5} more` : "";

package/src/index.ts

@@ -1,5 +1,6 @@
 // Backwards compatibility export - alias ConsoleReporter as Reporter
 export { ConsoleReporter, ConsoleReporter as Reporter } from "./console-reporter.ts";
+export { LazyReporter } from "./lazy-reporter.ts";
 export type { AnalyzedMessage } from "./message-analyzer.ts";
 export { analyzeError, analyzeWarning } from "./message-analyzer.ts";
 export { ReporterBase } from "./reporter-base.ts";

package/src/lazy-reporter.ts

@@ -0,0 +1,35 @@
+import { ConsoleReporter } from "./console-reporter.ts";
+import { ReporterService } from "./reporter-service.ts";
+
+/**
+ * A lazily-initialized reporter that auto-registers with ReporterService.
+ * Consolidates the repeated lazy-init + configure pattern used across the codebase.
+ */
+export class LazyReporter {
+	private config = { enabled: false, output: "ts-for-gir-report.json" };
+	private instance: ConsoleReporter | null = null;
+
+	constructor(private readonly name: string) {}
+
+	configure(enabled: boolean, output = "ts-for-gir-report.json"): void {
+		this.config = { enabled, output };
+		this.instance = null;
+
+		if (enabled) {
+			this.instance = new ConsoleReporter(true, this.name, enabled, output);
+			ReporterService.getInstance().registerReporter(this.name, this.instance);
+		}
+	}
+
+	get(): ConsoleReporter {
+		if (!this.instance) {
+			const { enabled, output } = this.config;
+			this.instance = new ConsoleReporter(true, this.name, enabled, output);
+
+			if (enabled) {
+				ReporterService.getInstance().registerReporter(this.name, this.instance);
+			}
+		}
+		return this.instance;
+	}
+}

package/src/message-analyzer.ts

@@ -71,13 +71,13 @@ export function analyzeWarning(message: string, args?: unknown[]): AnalyzedMessa
 export function analyzeError(message: string, args?: unknown[]): AnalyzedMessage | null {
 	const details = args && args.length > 0 ? JSON.stringify(args) : undefined;
 
-	// Type resolution errors
+	// Type resolution failures are non-fatal (produce 'never' type), classify as WARNING
 	if (message.includes("Unable to resolve type") || message.includes("could not be resolved")) {
 		const unresolvedMatch = message.match(/Unable to resolve type (\w+) in same namespace (\w+)!/);
 		if (unresolvedMatch) {
 			const [, typeName, namespace] = unresolvedMatch;
 			return {
-				severity: ProblemSeverity.ERROR,
+				severity: ProblemSeverity.WARNING,
 				category: ProblemCategory.TYPE_RESOLUTION,
 				typeName,
 				namespace,
@@ -93,12 +93,12 @@ export function analyzeError(message: string, args?: unknown[]): AnalyzedMessage
 			const namespace = namespaceMatch ? namespaceMatch[1] : context;
 
 			return {
-				severity: ProblemSeverity.ERROR,
+				severity: ProblemSeverity.WARNING,
 				category: ProblemCategory.TYPE_RESOLUTION,
 				typeName,
 				namespace,
 				details,
-				metadata: { namespace, typeName, context },
+				metadata: { namespace, typeName, context, resolutionType: "cross_namespace" },
 			};
 		}
 	}

package/src/reporter-base.ts

@@ -42,6 +42,8 @@ export abstract class ReporterBase {
 		typeName?: string,
 		location?: string,
 		metadata?: Record<string, unknown>,
+		/** Override the module field with the actual GIR namespace instead of the reporter name */
+		moduleOverride?: string,
 	): void {
 		if (!this.config.enabled) {
 			return;
@@ -51,7 +53,7 @@ export abstract class ReporterBase {
 			id: this.generateProblemId(),
 			severity,
 			category,
-			module: this.config.moduleName,
+			module: moduleOverride || this.config.moduleName,
 			message,
 			details,
 			typeName,
@@ -105,12 +107,14 @@ export abstract class ReporterBase {
 
 	/**
 	 * Report a type resolution warning (fallback cases)
+	 * @param sourceModule - The GIR module that references this type (e.g., "Shell 17")
 	 */
 	public abstract reportTypeResolutionWarning(
 		typeName: string,
 		namespace: string,
 		message: string,
 		details?: string,
+		sourceModule?: string,
 	): void;
 
 	/**

package/src/reporter-service.ts

@@ -8,8 +8,8 @@ import { resolve } from "node:path";
 import { blue, green, red, yellow } from "colorette";
 import { PACKAGE_VERSION } from "./constants.ts";
 import type { ReporterBase } from "./reporter-base.ts";
-import type { GenerationReport, ProblemEntry, ReportStatistics } from "./types/index.ts";
-import { ProblemCategory, ProblemSeverity } from "./types/index.ts";
+import type { GenerationReport, ProblemEntry } from "./types/index.ts";
+import { computeProblemStatistics, generateReportSummary, groupProblemsByCategory } from "./types/report.ts";
 
 /**
  * Centralized service for managing multiple Reporter instances
@@ -83,8 +83,7 @@ export class ReporterService {
 		const allProblems: ProblemEntry[] = [];
 
 		for (const reporter of this.reporters.values()) {
-			const report = reporter.generateReport();
-			allProblems.push(...report.problems);
+			allProblems.push(...reporter.getProblems());
 		}
 
 		return allProblems;
@@ -93,231 +92,14 @@ export class ReporterService {
 	/**
 	 * Generate comprehensive statistics from all reporters
 	 */
-	private generateComprehensiveStatistics(): ReportStatistics {
-		const allProblems = this.collectAllProblems();
-
-		// If we have no reporters, return empty stats
-		if (this.reporters.size === 0) {
-			return {
-				bySeverity: {
-					[ProblemSeverity.DEBUG]: 0,
-					[ProblemSeverity.INFO]: 0,
-					[ProblemSeverity.WARNING]: 0,
-					[ProblemSeverity.ERROR]: 0,
-					[ProblemSeverity.CRITICAL]: 0,
-				},
-				byCategory: {
-					[ProblemCategory.TYPE_RESOLUTION]: 0,
-					[ProblemCategory.PARSING_FAILURE]: 0,
-					[ProblemCategory.GENERATION_FAILURE]: 0,
-					[ProblemCategory.TYPE_CONFLICT]: 0,
-					[ProblemCategory.DEPENDENCY_ISSUE]: 0,
-					[ProblemCategory.CONFIGURATION]: 0,
-					[ProblemCategory.IO_ERROR]: 0,
-					[ProblemCategory.GENERAL]: 0,
-				},
-				byModule: {},
-				totalProblems: 0,
-				mostProblematicModules: [],
-				typeStatistics: {
-					commonUnresolvedTypes: [],
-					commonTypeConflicts: [],
-					problematicNamespaces: [],
-				},
-				startTime: new Date(),
-				endTime: new Date(),
-				durationMs: 0,
-			};
-		}
-
-		// Get the first reporter's report as base for timing
-		const firstReport = this.reporters.values().next().value?.generateReport();
-		const startTime = firstReport?.statistics.startTime || new Date();
-
-		// Use current time as end time
-		const endTime = new Date();
-		const durationMs = endTime.getTime() - startTime.getTime();
-
-		// Aggregate statistics
-		const bySeverity: Record<ProblemSeverity, number> = {
-			[ProblemSeverity.DEBUG]: 0,
-			[ProblemSeverity.INFO]: 0,
-			[ProblemSeverity.WARNING]: 0,
-			[ProblemSeverity.ERROR]: 0,
-			[ProblemSeverity.CRITICAL]: 0,
-		};
-
-		const byCategory: Record<ProblemCategory, number> = {
-			[ProblemCategory.TYPE_RESOLUTION]: 0,
-			[ProblemCategory.PARSING_FAILURE]: 0,
-			[ProblemCategory.GENERATION_FAILURE]: 0,
-			[ProblemCategory.TYPE_CONFLICT]: 0,
-			[ProblemCategory.DEPENDENCY_ISSUE]: 0,
-			[ProblemCategory.CONFIGURATION]: 0,
-			[ProblemCategory.IO_ERROR]: 0,
-			[ProblemCategory.GENERAL]: 0,
-		};
-
-		const byModule: Record<string, number> = {};
-
-		// Type-specific tracking
-		const unresolvedTypes: Record<string, { count: number; namespaces: Set<string> }> = {};
-		const typeConflicts: Record<string, { count: number; examples: Set<string> }> = {};
-		const namespaceProblems: Record<string, { count: number; types: Set<string> }> = {};
-
-		for (const problem of allProblems) {
-			bySeverity[problem.severity] = (bySeverity[problem.severity] || 0) + 1;
-			byCategory[problem.category] = (byCategory[problem.category] || 0) + 1;
-			byModule[problem.module] = (byModule[problem.module] || 0) + 1;
-
-			// Track type resolution problems
-			if (problem.category === ProblemCategory.TYPE_RESOLUTION && problem.typeName) {
-				if (!unresolvedTypes[problem.typeName]) {
-					unresolvedTypes[problem.typeName] = { count: 0, namespaces: new Set() };
-				}
-				unresolvedTypes[problem.typeName].count++;
-				if (problem.location) {
-					unresolvedTypes[problem.typeName].namespaces.add(problem.location);
-				}
-
-				// Track namespace problems
-				if (problem.location) {
-					if (!namespaceProblems[problem.location]) {
-						namespaceProblems[problem.location] = { count: 0, types: new Set() };
-					}
-					namespaceProblems[problem.location].count++;
-					namespaceProblems[problem.location].types.add(problem.typeName);
-				}
-			}
-
-			// Track type conflicts
-			if (problem.category === ProblemCategory.TYPE_CONFLICT && problem.metadata?.conflictType) {
-				const conflictType = problem.metadata.conflictType as string;
-				if (!typeConflicts[conflictType]) {
-					typeConflicts[conflictType] = { count: 0, examples: new Set() };
-				}
-				typeConflicts[conflictType].count++;
-				if (problem.typeName) {
-					typeConflicts[conflictType].examples.add(problem.typeName);
-				}
-			}
-		}
-
-		// Convert to arrays and sort
-		const commonUnresolvedTypes = Object.entries(unresolvedTypes)
-			.map(([type, data]) => ({
-				type,
-				count: data.count,
-				namespaces: Array.from(data.namespaces),
-			}))
-			.sort((a, b) => b.count - a.count)
-			.slice(0, 20);
-
-		const commonTypeConflicts = Object.entries(typeConflicts)
-			.map(([conflictType, data]) => ({
-				conflictType,
-				count: data.count,
-				examples: Array.from(data.examples).slice(0, 5),
-			}))
-			.sort((a, b) => b.count - a.count);
-
-		const problematicNamespaces = Object.entries(namespaceProblems)
-			.map(([namespace, data]) => ({
-				namespace,
-				problems: data.count,
-				types: Array.from(data.types).slice(0, 10),
-			}))
-			.sort((a, b) => b.problems - a.problems)
-			.slice(0, 10);
-
-		const mostProblematicModules = Object.entries(byModule)
-			.sort(([, a], [, b]) => b - a)
-			.slice(0, 10)
-			.map(([module, count]) => ({ module, count }));
-
-		return {
-			bySeverity,
-			byCategory,
-			byModule,
-			totalProblems: allProblems.length,
-			mostProblematicModules,
-			typeStatistics: {
-				commonUnresolvedTypes,
-				commonTypeConflicts,
-				problematicNamespaces,
-			},
-			startTime,
-			endTime,
-			durationMs,
-		};
-	}
-
 	/**
 	 * Generate comprehensive report from all reporters
 	 */
 	public generateComprehensiveReport(): GenerationReport {
-		const statistics = this.generateComprehensiveStatistics();
 		const allProblems = this.collectAllProblems();
-
-		// Generate problems by category
-		const problemsByCategory = Object.values(ProblemCategory).reduce(
-			(acc, category) => {
-				acc[category] = [];
-				return acc;
-			},
-			{} as Record<ProblemCategory, ProblemEntry[]>,
-		);
-
-		for (const problem of allProblems) {
-			problemsByCategory[problem.category].push(problem);
-		}
-
-		// Generate summary
-		const errorCount = statistics.bySeverity[ProblemSeverity.ERROR] || 0;
-		const _criticalCount = statistics.bySeverity[ProblemSeverity.CRITICAL] || 0;
-		const warningCount = statistics.bySeverity[ProblemSeverity.WARNING] || 0;
-
-		let status: "success" | "partial" = "success";
-		if (errorCount > 0 || warningCount > 20) {
-			status = "partial";
-		}
-
-		const keyIssues: string[] = [];
-		const recommendations: string[] = [];
-
-		// Analyze key issues across all modules
-		const typeResolutionCount = statistics.byCategory[ProblemCategory.TYPE_RESOLUTION] || 0;
-		const parsingFailureCount = statistics.byCategory[ProblemCategory.PARSING_FAILURE] || 0;
-		const generationFailureCount = statistics.byCategory[ProblemCategory.GENERATION_FAILURE] || 0;
-		const conflictCount = statistics.byCategory[ProblemCategory.TYPE_CONFLICT] || 0;
-
-		if (typeResolutionCount > 0) {
-			keyIssues.push(`${typeResolutionCount} type resolution issues across all modules`);
-			recommendations.push("Review GIR files for missing or incorrect type definitions");
-		}
-
-		if (parsingFailureCount > 0) {
-			keyIssues.push(`${parsingFailureCount} parsing failures encountered`);
-			recommendations.push("Check GIR file syntax and ensure proper introspection data");
-		}
-
-		if (generationFailureCount > 0) {
-			keyIssues.push(`${generationFailureCount} generation failures occurred`);
-			recommendations.push("Review template configuration and output settings");
-		}
-
-		if (conflictCount > 10) {
-			keyIssues.push(`High number of type conflicts (${conflictCount})`);
-			recommendations.push("Consider using ignore patterns or updating GIR files to resolve conflicts");
-		}
-
-		if (keyIssues.length === 0 && statistics.totalProblems > 0) {
-			keyIssues.push(`${statistics.totalProblems} minor issues detected across all modules`);
-		}
-
-		if (recommendations.length === 0 && statistics.totalProblems > 0) {
-			recommendations.push("Review detailed problem list for specific improvement opportunities");
-		}
+		const startTime = this.reporters.values().next().value?.getProblems()[0]?.timestamp || new Date();
+		const statistics = computeProblemStatistics(allProblems, startTime);
+		const summary = generateReportSummary(statistics);
 
 		return {
 			metadata: {
@@ -326,24 +108,20 @@ export class ReporterService {
 			},
 			statistics,
 			problems: allProblems,
-			problemsByCategory,
-			summary: {
-				status,
-				keyIssues,
-				recommendations,
-			},
+			problemsByCategory: groupProblemsByCategory(allProblems),
+			summary,
 		};
 	}
 
 	/**
 	 * Save comprehensive report to file
 	 */
-	public async saveComprehensiveReport(outputPath?: string): Promise<void> {
+	public async saveComprehensiveReport(outputPath?: string, precomputedReport?: GenerationReport): Promise<void> {
 		if (!this.config.enabled) {
 			return;
 		}
 
-		const report = this.generateComprehensiveReport();
+		const report = precomputedReport || this.generateComprehensiveReport();
 		const filePath = outputPath || this.config.outputPath;
 
 		try {
@@ -358,8 +136,8 @@ export class ReporterService {
 	/**
 	 * Print comprehensive summary to console
 	 */
-	public printComprehensiveSummary(): void {
-		const report = this.generateComprehensiveReport();
+	public printComprehensiveSummary(precomputedReport?: GenerationReport): void {
+		const report = precomputedReport || this.generateComprehensiveReport();
 		const { statistics, summary } = report;
 
 		console.log(`\n${"=".repeat(60)}`);
@@ -367,8 +145,11 @@ export class ReporterService {
 		console.log("=".repeat(60));
 
 		// Overall status
-		const statusColor = summary.status === "success" ? green : yellow;
+		const statusColor = summary.status === "partial" ? yellow : green;
 		console.log(`\n🎯 Overall Status: ${statusColor(summary.status.toUpperCase())}`);
+		if (summary.status === "success_with_warnings") {
+			console.log(green("  All issues are non-blocking. Generated types are complete."));
+		}
 
 		// Total statistics
 		console.log(`\n📈 Total Statistics:`);
@@ -396,9 +177,9 @@ export class ReporterService {
 				}
 			}
 
-			// Most problematic modules
+			// Most problematic namespaces (byModule now tracks GIR namespaces)
 			if (statistics.mostProblematicModules.length > 0) {
-				console.log(`\n📦 Most Problematic Modules:`);
+				console.log(`\n📦 Namespaces with Most Issues:`);
 				statistics.mostProblematicModules.slice(0, 10).forEach(({ module, count }) => {
 					const percentage = Math.round((count / statistics.totalProblems) * 100);
 					console.log(`  ${module}: ${count} issues (${percentage}%)`);

package/src/types/report.ts

@@ -1,11 +1,226 @@
-import type { ProblemCategory, ProblemEntry, ProblemSeverity } from "./problem.ts";
+import { ProblemCategory, type ProblemEntry, ProblemSeverity } from "./problem.ts";
+
+/**
+ * Generation status levels
+ */
+export type GenerationStatus = "success" | "success_with_warnings" | "partial";
+
+/**
+ * Determine the generation status based on problem statistics.
+ * - "partial": actual errors, parsing failures, or generation failures occurred
+ * - "success_with_warnings": generation completed but with non-blocking warnings
+ * - "success": no problems at all
+ */
+export function determineGenerationStatus(
+	bySeverity: Record<ProblemSeverity, number>,
+	byCategory: Record<ProblemCategory, number>,
+): GenerationStatus {
+	const hasErrors = (bySeverity[ProblemSeverity.ERROR] || 0) > 0;
+	const hasCritical = (bySeverity[ProblemSeverity.CRITICAL] || 0) > 0;
+	const hasGenerationFailures = (byCategory[ProblemCategory.GENERATION_FAILURE] || 0) > 0;
+	const hasParsingFailures = (byCategory[ProblemCategory.PARSING_FAILURE] || 0) > 0;
+
+	if (hasErrors || hasCritical || hasGenerationFailures || hasParsingFailures) {
+		return "partial";
+	}
+
+	if ((bySeverity[ProblemSeverity.WARNING] || 0) > 0) {
+		return "success_with_warnings";
+	}
+
+	return "success";
+}
+
+/**
+ * Compute problem statistics from a list of problems.
+ * Shared between ConsoleReporter and ReporterService to avoid duplication.
+ */
+export function computeProblemStatistics(problems: ProblemEntry[], startTime: Date): ReportStatistics {
+	const bySeverity: Record<ProblemSeverity, number> = {
+		[ProblemSeverity.DEBUG]: 0,
+		[ProblemSeverity.INFO]: 0,
+		[ProblemSeverity.WARNING]: 0,
+		[ProblemSeverity.ERROR]: 0,
+		[ProblemSeverity.CRITICAL]: 0,
+	};
+
+	const byCategory: Record<ProblemCategory, number> = {
+		[ProblemCategory.TYPE_RESOLUTION]: 0,
+		[ProblemCategory.PARSING_FAILURE]: 0,
+		[ProblemCategory.GENERATION_FAILURE]: 0,
+		[ProblemCategory.TYPE_CONFLICT]: 0,
+		[ProblemCategory.DEPENDENCY_ISSUE]: 0,
+		[ProblemCategory.CONFIGURATION]: 0,
+		[ProblemCategory.IO_ERROR]: 0,
+		[ProblemCategory.GENERAL]: 0,
+	};
+
+	const byModule: Record<string, number> = {};
+
+	const unresolvedTypes: Record<string, { count: number; namespaces: Set<string>; sourceModules: Set<string> }> = {};
+	const typeConflicts: Record<string, { count: number; examples: Set<string> }> = {};
+	const namespaceProblems: Record<string, { count: number; types: Set<string> }> = {};
+
+	for (const problem of problems) {
+		bySeverity[problem.severity]++;
+		byCategory[problem.category]++;
+		byModule[problem.module] = (byModule[problem.module] || 0) + 1;
+
+		if (problem.category === ProblemCategory.TYPE_RESOLUTION && problem.typeName) {
+			if (!unresolvedTypes[problem.typeName]) {
+				unresolvedTypes[problem.typeName] = { count: 0, namespaces: new Set(), sourceModules: new Set() };
+			}
+			unresolvedTypes[problem.typeName].count++;
+			if (problem.location) {
+				unresolvedTypes[problem.typeName].namespaces.add(problem.location);
+			}
+			const sourceModule = problem.metadata?.sourceModule as string | undefined;
+			if (sourceModule) {
+				unresolvedTypes[problem.typeName].sourceModules.add(sourceModule);
+			}
+
+			if (problem.location) {
+				if (!namespaceProblems[problem.location]) {
+					namespaceProblems[problem.location] = { count: 0, types: new Set() };
+				}
+				namespaceProblems[problem.location].count++;
+				namespaceProblems[problem.location].types.add(problem.typeName);
+			}
+		}
+
+		if (problem.category === ProblemCategory.TYPE_CONFLICT && problem.metadata?.conflictType) {
+			const conflictType = problem.metadata.conflictType as string;
+			if (!typeConflicts[conflictType]) {
+				typeConflicts[conflictType] = { count: 0, examples: new Set() };
+			}
+			typeConflicts[conflictType].count++;
+			if (problem.typeName) {
+				typeConflicts[conflictType].examples.add(problem.typeName);
+			}
+		}
+	}
+
+	const commonUnresolvedTypes = Object.entries(unresolvedTypes)
+		.map(([type, data]) => ({
+			type,
+			count: data.count,
+			namespaces: Array.from(data.namespaces),
+			sourceModules: Array.from(data.sourceModules),
+		}))
+		.sort((a, b) => b.count - a.count)
+		.slice(0, 20);
+
+	const commonTypeConflicts = Object.entries(typeConflicts)
+		.map(([conflictType, data]) => ({
+			conflictType,
+			count: data.count,
+			examples: Array.from(data.examples).slice(0, 5),
+		}))
+		.sort((a, b) => b.count - a.count);
+
+	const problematicNamespaces = Object.entries(namespaceProblems)
+		.map(([namespace, data]) => ({
+			namespace,
+			problems: data.count,
+			types: Array.from(data.types).slice(0, 10),
+		}))
+		.sort((a, b) => b.problems - a.problems)
+		.slice(0, 10);
+
+	const mostProblematicModules = Object.entries(byModule)
+		.sort(([, a], [, b]) => b - a)
+		.slice(0, 10)
+		.map(([module, count]) => ({ module, count }));
+
+	const endTime = new Date();
+
+	return {
+		bySeverity,
+		byCategory,
+		byModule,
+		totalProblems: problems.length,
+		mostProblematicModules,
+		typeStatistics: { commonUnresolvedTypes, commonTypeConflicts, problematicNamespaces },
+		startTime,
+		endTime,
+		durationMs: endTime.getTime() - startTime.getTime(),
+	};
+}
+
+/**
+ * Generate report summary with key issues and recommendations.
+ * Shared between ConsoleReporter and ReporterService.
+ */
+export function generateReportSummary(statistics: ReportStatistics): GenerationReport["summary"] {
+	const { bySeverity, byCategory, totalProblems } = statistics;
+
+	const status = determineGenerationStatus(bySeverity, byCategory);
+
+	const keyIssues: string[] = [];
+	const recommendations: string[] = [];
+
+	if (byCategory[ProblemCategory.TYPE_RESOLUTION] > 0) {
+		keyIssues.push(
+			`${byCategory[ProblemCategory.TYPE_RESOLUTION]} type resolution warnings (produce 'never' type in output)`,
+		);
+		recommendations.push(
+			"Unresolved types produce 'never' in output — these are typically non-introspectable types or missing GIR dependencies",
+		);
+	}
+
+	if (byCategory[ProblemCategory.PARSING_FAILURE] > 0) {
+		keyIssues.push(`${byCategory[ProblemCategory.PARSING_FAILURE]} parsing failures occurred`);
+		recommendations.push("Check GIR file syntax and ensure proper introspection data");
+	}
+
+	if (byCategory[ProblemCategory.GENERATION_FAILURE] > 0) {
+		keyIssues.push(`${byCategory[ProblemCategory.GENERATION_FAILURE]} generation failures encountered`);
+		recommendations.push("Review template configuration and output settings");
+	}
+
+	if (byCategory[ProblemCategory.TYPE_CONFLICT] > 0) {
+		keyIssues.push(`${byCategory[ProblemCategory.TYPE_CONFLICT]} type conflicts detected`);
+		recommendations.push(
+			"Type conflicts are handled automatically — conflicting members are omitted or use union types",
+		);
+	}
+
+	if (keyIssues.length === 0 && totalProblems > 0) {
+		keyIssues.push(`${totalProblems} minor issues detected`);
+	}
+
+	if (recommendations.length === 0 && totalProblems > 0) {
+		recommendations.push("Review detailed problem list for specific improvement opportunities");
+	}
+
+	return { status, keyIssues, recommendations };
+}
+
+/**
+ * Group problems by category.
+ */
+export function groupProblemsByCategory(problems: ProblemEntry[]): Record<ProblemCategory, ProblemEntry[]> {
+	const result = Object.values(ProblemCategory).reduce(
+		(acc, category) => {
+			acc[category] = [];
+			return acc;
+		},
+		{} as Record<ProblemCategory, ProblemEntry[]>,
+	);
+
+	for (const problem of problems) {
+		result[problem.category].push(problem);
+	}
+
+	return result;
+}
 
 /**
  * Aggregated problem statistics by type
  */
 export interface ProblemTypeStatistics {
 	/** Most common unresolved types */
-	commonUnresolvedTypes: Array<{ type: string; count: number; namespaces: string[] }>;
+	commonUnresolvedTypes: Array<{ type: string; count: number; namespaces: string[]; sourceModules: string[] }>;
 	/** Most common type conflicts */
 	commonTypeConflicts: Array<{ conflictType: string; count: number; examples: string[] }>;
 	/** Namespaces with most problems */
@@ -54,7 +269,7 @@ export interface GenerationReport {
 	/** Summary and recommendations */
 	summary: {
 		/** Overall generation status */
-		status: "success" | "partial";
+		status: GenerationStatus;
 		/** Key issues summary */
 		keyIssues: string[];
 		/** Recommendations for fixing issues */