@ts-for-gir/cli 4.0.0-beta.9 → 4.0.0-rc.10

package/src/commands/analyze.ts

@@ -0,0 +1,344 @@
+/**
+ * Everything you need for the `ts-for-gir analyze` command is located here
+ */
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { APP_NAME, Logger } from "@ts-for-gir/lib";
+import type { ProblemEntry } from "@ts-for-gir/reporter";
+import { analyzeOptions } from "../config.ts";
+import type { AnalyzeCommandArgs, ReportData } from "../types/index.ts";
+import { createBuilder } from "./command-builder.ts";
+
+const command = "analyze [options]";
+
+const description = "Analyze report files generated by ts-for-gir reporter";
+
+const examples: ReadonlyArray<[string, string?]> = [
+	[`${APP_NAME} analyze -f ./ts-for-gir-report.json`, "Show summary statistics of the report"],
+	[`${APP_NAME} analyze -f ./ts-for-gir-report.json --summary`, "Show only summary statistics"],
+	[`${APP_NAME} analyze -f ./ts-for-gir-report.json --severity error critical`, "Show only errors and critical issues"],
+	[
+		`${APP_NAME} analyze -f ./ts-for-gir-report.json --category type_resolution --detailed`,
+		"Show detailed type resolution problems",
+	],
+	[`${APP_NAME} analyze -f ./ts-for-gir-report.json --namespace GLib --top 5`, "Show top 5 problems in GLib namespace"],
+	[
+		`${APP_NAME} analyze -f ./ts-for-gir-report.json --type time_t --export ./time_t_issues.json`,
+		"Export all time_t related issues",
+	],
+	[
+		`${APP_NAME} analyze -f ./ts-for-gir-report.json --search "Unable to resolve" --format csv`,
+		"Search for resolution failures and export as CSV",
+	],
+];
+
+const builder = createBuilder<AnalyzeCommandArgs>(analyzeOptions, examples);
+
+const parseReportDate = (dateValue: string | Date): Date => {
+	return typeof dateValue === "string" ? new Date(dateValue) : dateValue;
+};
+
+const loadReportFile = (filePath: string): ReportData => {
+	if (!existsSync(filePath)) {
+		throw new Error(`Report file not found: ${filePath}`);
+	}
+
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const report = JSON.parse(content) as ReportData;
+
+		// Convert string dates to Date objects
+		report.metadata.generatedAt = parseReportDate(report.metadata.generatedAt);
+		report.statistics.startTime = parseReportDate(report.statistics.startTime);
+
+		if (report.statistics.endTime) {
+			report.statistics.endTime = parseReportDate(report.statistics.endTime);
+		}
+
+		// Convert problem timestamps
+		report.problems = report.problems.map((problem) => ({
+			...problem,
+			timestamp: parseReportDate(problem.timestamp),
+		}));
+
+		return report;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		throw new Error(`Failed to parse report file: ${errorMessage}`);
+	}
+};
+
+const filterProblems = (problems: ProblemEntry[], args: AnalyzeCommandArgs): ProblemEntry[] => {
+	let filtered = [...problems];
+
+	// Filter by severity
+	if (args.severity?.length) {
+		filtered = filtered.filter((p) => args.severity?.includes(p.severity));
+	}
+
+	// Filter by category
+	if (args.category?.length) {
+		filtered = filtered.filter((p) => args.category?.includes(p.category));
+	}
+
+	// Filter by namespace
+	if (args.namespace?.length) {
+		filtered = filtered.filter((p) =>
+			args.namespace?.some((ns) => p.location?.includes(ns) || p.module?.includes(ns) || p.metadata?.namespace === ns),
+		);
+	}
+
+	// Filter by type name
+	if (args.type?.length) {
+		filtered = filtered.filter((p) => Boolean(p.typeName && args.type?.includes(p.typeName)));
+	}
+
+	// Search filter
+	if (args.search) {
+		const searchLower = args.search.toLowerCase();
+		filtered = filtered.filter(
+			(p) =>
+				p.message.toLowerCase().includes(searchLower) ||
+				p.details?.toLowerCase().includes(searchLower) ||
+				p.typeName?.toLowerCase().includes(searchLower),
+		);
+	}
+
+	// Time range filters
+	if (args.since) {
+		const sinceDate = new Date(args.since);
+		filtered = filtered.filter((p) => p.timestamp >= sinceDate);
+	}
+
+	if (args.until) {
+		const untilDate = new Date(args.until);
+		filtered = filtered.filter((p) => p.timestamp <= untilDate);
+	}
+
+	return filtered;
+};
+
+const displaySummary = (report: ReportData, args: AnalyzeCommandArgs): void => {
+	const { statistics } = report;
+
+	console.log("📊 Report Summary\n");
+
+	// Basic info
+	console.log(`Generated: ${report.metadata.generatedAt}`);
+	console.log(`Version: ${report.metadata.version}`);
+	console.log(`Total Problems: ${statistics.totalProblems}`);
+
+	if (statistics.durationMs) {
+		console.log(`Generation Duration: ${(statistics.durationMs / 1000).toFixed(2)}s`);
+	}
+
+	// Problems by severity
+	console.log("\n🔴 Problems by Severity:");
+	Object.entries(statistics.bySeverity)
+		.filter(([, count]) => count > 0)
+		.sort(([, a], [, b]) => b - a)
+		.forEach(([severity, count]) => {
+			console.log(`  ${severity}: ${count}`);
+		});
+
+	// Problems by category
+	console.log("\n📂 Problems by Category:");
+	Object.entries(statistics.byCategory)
+		.filter(([, count]) => count > 0)
+		.sort(([, a], [, b]) => b - a)
+		.forEach(([category, count]) => {
+			console.log(`  ${category}: ${count}`);
+		});
+
+	// Top problematic namespaces
+	if (statistics.typeStatistics.problematicNamespaces.length > 0) {
+		console.log("\n🏢 Most Problematic Namespaces:");
+		const topCount = args.top ?? 10;
+		statistics.typeStatistics.problematicNamespaces.slice(0, topCount).forEach((ns) => {
+			console.log(`  ${ns.namespace}: ${ns.problems} problems`);
+			if (args.detailed) {
+				const typesList = ns.types.slice(0, 5).join(", ");
+				const moreTypes = ns.types.length > 5 ? "..." : "";
+				console.log(`    Types: ${typesList}${moreTypes}`);
+			}
+		});
+	}
+
+	// Common unresolved types
+	if (statistics.typeStatistics.commonUnresolvedTypes.length > 0) {
+		console.log("\n🔍 Most Common Unresolved Types:");
+		const topCount = args.top ?? 10;
+		statistics.typeStatistics.commonUnresolvedTypes.slice(0, topCount).forEach((type) => {
+			console.log(`  ${type.type}: ${type.count} occurrences`);
+			if (args.detailed) {
+				const namespacesList = type.namespaces.slice(0, 3).join(", ");
+				const moreNamespaces = type.namespaces.length > 3 ? "..." : "";
+				console.log(`    Namespaces: ${namespacesList}${moreNamespaces}`);
+			}
+		});
+	}
+};
+
+const displayProblems = (problems: ProblemEntry[], args: AnalyzeCommandArgs): void => {
+	if (problems.length === 0) {
+		console.log("No problems match the specified filters.");
+		return;
+	}
+
+	console.log(`\n🔍 Found ${problems.length} matching problems:\n`);
+
+	problems.forEach((problem, index) => {
+		const message = `${index + 1}. [${problem.severity.toUpperCase()}] ${problem.message}`;
+
+		console.log(message);
+
+		if (args.detailed) {
+			console.log(`   ID: ${problem.id}`);
+			console.log(`   Category: ${problem.category}`);
+			console.log(`   Module: ${problem.module}`);
+			if (problem.typeName) {
+				console.log(`   Type: ${problem.typeName}`);
+			}
+			if (problem.location) {
+				console.log(`   Location: ${problem.location}`);
+			}
+			if (problem.details) {
+				console.log(`   Details: ${problem.details}`);
+			}
+			console.log(`   Timestamp: ${problem.timestamp}`);
+			if (problem.metadata && Object.keys(problem.metadata).length > 0) {
+				console.log(`   Metadata: ${JSON.stringify(problem.metadata)}`);
+			}
+		} else if (problem.typeName) {
+			const location = problem.location ?? "unknown";
+			console.log(`   Type: ${problem.typeName} | Location: ${location}`);
+		}
+
+		if (index < problems.length - 1) {
+			console.log("");
+		}
+	});
+};
+
+const formatAsTable = (problems: ProblemEntry[]): string => {
+	if (problems.length === 0) {
+		return "No problems found.";
+	}
+
+	const headers = ["Severity", "Category", "Module", "Type", "Message"];
+	const rows = problems.map((p) => [
+		p.severity,
+		p.category,
+		p.module ?? "",
+		p.typeName ?? "",
+		p.message.length > 50 ? `${p.message.substring(0, 47)}...` : p.message,
+	]);
+
+	const columnWidths = headers.map((header, i) => Math.max(header.length, ...rows.map((row) => row[i].length)));
+
+	const separator = columnWidths.map((w) => "-".repeat(w)).join(" | ");
+	const headerRow = headers.map((h, i) => h.padEnd(columnWidths[i])).join(" | ");
+	const dataRows = rows.map((row) => row.map((cell, i) => cell.padEnd(columnWidths[i])).join(" | "));
+
+	return [headerRow, separator, ...dataRows].join("\n");
+};
+
+const formatAsCsv = (problems: ProblemEntry[]): string => {
+	const headers = ["id", "severity", "category", "module", "typeName", "location", "message", "details", "timestamp"];
+	const rows = problems.map((p) => [
+		p.id,
+		p.severity,
+		p.category,
+		p.module ?? "",
+		p.typeName ?? "",
+		p.location ?? "",
+		`"${p.message.replace(/"/g, '""')}"`,
+		`"${(p.details ?? "").replace(/"/g, '""')}"`,
+		p.timestamp.toISOString(),
+	]);
+
+	return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
+};
+
+const exportResults = (problems: ProblemEntry[], filePath: string, format: string, logger: Logger): void => {
+	let content: string;
+
+	switch (format) {
+		case "json": {
+			content = JSON.stringify(problems, null, 2);
+			break;
+		}
+		case "csv": {
+			content = formatAsCsv(problems);
+			break;
+		}
+		case "table": {
+			content = formatAsTable(problems);
+			break;
+		}
+		default: {
+			throw new Error(`Unsupported export format: ${format}`);
+		}
+	}
+
+	writeFileSync(filePath, content, "utf-8");
+	logger.success(`Results exported to: ${filePath}`);
+};
+
+const handler = async (args: AnalyzeCommandArgs): Promise<void> => {
+	const logger = new Logger(args.verbose ?? false, "AnalyzeCommand");
+
+	try {
+		// Load and parse report file
+		const report = loadReportFile(args.reportFile);
+
+		if (args.verbose) {
+			logger.info(`Loaded report with ${report.problems.length} problems`);
+		}
+
+		// Show summary if requested or if no specific filters are applied
+		const hasFilters = Boolean(args.severity || args.category || args.namespace || args.type || args.search);
+
+		if (args.summary || !hasFilters) {
+			displaySummary(report, args);
+		}
+
+		// If summary-only mode, stop here
+		if (args.summary) {
+			return;
+		}
+
+		// Filter problems based on criteria
+		const filteredProblems = filterProblems(report.problems, args);
+
+		// Display filtered results
+		if (hasFilters || args.detailed) {
+			displayProblems(filteredProblems, args);
+		}
+
+		// Export results if requested
+		if (args.export) {
+			const format = args.format ?? "json";
+			exportResults(filteredProblems, args.export, format, logger);
+		}
+
+		// Show filter summary if filters were applied
+		if (hasFilters && !args.summary) {
+			console.log(
+				`\n📋 Filter Summary: Showing ${filteredProblems.length} of ${report.problems.length} total problems`,
+			);
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		logger.error(`Analysis failed: ${errorMessage}`);
+		process.exit(1);
+	}
+};
+
+export const analyze = {
+	command,
+	description,
+	builder,
+	handler,
+	examples,
+};

package/src/commands/command-builder.ts

@@ -0,0 +1,30 @@
+/**
+ * Helper to build yargs commands with common structure
+ */
+
+import type { ConfigFlags } from "@ts-for-gir/lib";
+import type { Argv, BuilderCallback, Options } from "yargs";
+
+export interface CommandDefinition {
+	command: string;
+	description: string;
+	builder: BuilderCallback<unknown, ConfigFlags>;
+	handler: (args: ConfigFlags) => Promise<void>;
+	examples: ReadonlyArray<[string, string?]>;
+}
+
+/**
+ * Creates a builder function for yargs commands
+ */
+export function createBuilder<TArgs>(
+	options: Record<string, Options>,
+	examples: ReadonlyArray<[string, string?]>,
+): BuilderCallback<TArgs, ConfigFlags> {
+	return (yargs: Argv<TArgs>) => {
+		const optionNames = Object.keys(options);
+		for (const optionName of optionNames) {
+			yargs = yargs.option(optionName, options[optionName]);
+		}
+		return yargs.example(examples) as Argv<ConfigFlags>;
+	};
+}

package/src/commands/copy.ts

@@ -2,93 +2,88 @@
  * Everything you need for the `ts-for-gir copy` command is located here
  */
 
-import { Argv, BuilderCallback } from 'yargs'
-import { copyFile, mkdir } from 'fs/promises'
-import { basename, join } from 'path'
-import { ModuleLoader } from '../module-loader.js'
-import { Config } from '../config.js'
-import { Logger, ERROR_NO_MODULES_FOUND } from '@ts-for-gir/lib'
+import { copyFile, mkdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+import type { ConfigFlags, GirModuleResolvedBy, UserConfig } from "@ts-for-gir/lib";
+import { APP_NAME, ERROR_NO_MODULES_FOUND, Logger, NSRegistry } from "@ts-for-gir/lib";
+import { copyOptions, getOptionsGeneration, load } from "../config.ts";
+import { ModuleLoader } from "../module-loader.ts";
+import type { CopyCommandArgs } from "../types/index.ts";
+import { createBuilder } from "./command-builder.ts";
 
-import type { ConfigFlags, UserConfig, GirModuleResolvedBy } from '@ts-for-gir/lib'
+const command = "copy [modules..]";
 
-const command = 'copy [modules..]'
+const description = "Scan for *.gir files and copy them to a new directory";
 
-const description = 'Scan for *.gir files and copy them to a new directory'
+const logger = new Logger(true, "CopyCommand");
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const builder: BuilderCallback<any, ConfigFlags> = (yargs: Argv<any>) => {
-    const optionNames = Object.keys(Config.copyOptions)
-    for (const optionName of optionNames) {
-        yargs = yargs.option(optionName, Config.copyOptions[optionName])
-    }
-    return yargs.example(examples) as Argv<ConfigFlags>
-}
+const examples: ReadonlyArray<[string, string?]> = [
+	[`${APP_NAME} copy -o ./gir`, "Copy found *.gir files to ./gir"],
+	[
+		`${APP_NAME} copy -g /usr/share/gir-1.0 --ignore=Gtk-3.0 xrandr-1.3 -o ./gir`,
+		"Copy all found *.gir files in /usr/share/gir-1.0 excluding Gtk-3.0 and xrandr-1.3 to ./gir",
+	],
+];
+
+const builder = createBuilder<CopyCommandArgs>(copyOptions, examples);
 
 const copyGirFile = async (config: UserConfig, depModule: GirModuleResolvedBy) => {
-    if (!depModule.path) {
-        Logger.danger(`- ${depModule.packageName} not found`)
-        return
-    }
-    if (!config.outdir) {
-        Logger.error(`outdir not found`)
-        return
-    }
-    const filename = basename(depModule.path)
-    const dest = join(config.outdir, filename)
-    if (depModule.path === dest) {
-        Logger.yellow(`Skip ${depModule.path}`)
-        return
-    }
-    Logger.success(`Copy ${depModule.path}`)
-    await copyFile(depModule.path, dest)
-}
+	if (!depModule.path) {
+		logger.danger(`- ${depModule.packageName} not found`);
+		return;
+	}
+	if (!config.outdir) {
+		logger.error("outdir not found");
+		return;
+	}
+	const filename = basename(depModule.path);
+	const dest = join(config.outdir, filename);
+	if (depModule.path === dest) {
+		logger.yellow(`Skip ${depModule.path}`);
+		return;
+	}
+	logger.success(`Copy ${depModule.path}`);
+	await copyFile(depModule.path, dest);
+};
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const handler = async (args: ConfigFlags) => {
-    const config = await Config.load(args)
-    const generateConfig = Config.getOptionsGeneration(config)
-    const moduleLoader = new ModuleLoader(generateConfig)
-    const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore)
-    const moduleGroups = Object.values(grouped)
-    if (Object.keys(grouped).length === 0) {
-        return Logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories))
-    }
+	const config = await load(args);
+	const generateConfig = getOptionsGeneration(config);
+	const registry = new NSRegistry();
+	const moduleLoader = new ModuleLoader(generateConfig, registry);
+	const { grouped, failed } = await moduleLoader.getModules(config.modules, config.ignore);
+	const moduleGroups = Object.values(grouped);
+	if (Object.keys(grouped).length === 0) {
+		return logger.error(ERROR_NO_MODULES_FOUND(config.girDirectories));
+	}
 
-    if (!config.outdir) {
-        Logger.error(`outdir not found`)
-        return
-    }
+	if (!config.outdir) {
+		logger.error("outdir not found");
+		return;
+	}
 
-    await mkdir(config.outdir, { recursive: true }).catch((err) => {
-        Logger.error(`Failed to copy gir files to ${config.outdir}: ${err}`)
-    })
+	await mkdir(config.outdir, { recursive: true }).catch((err) => {
+		logger.error(`Failed to copy gir files to ${config.outdir}: ${err}`);
+	});
 
-    for (const module of moduleGroups) {
-        for (const mod of module.modules) {
-            await copyGirFile(config, mod)
-        }
-    }
+	for (const module of moduleGroups) {
+		for (const mod of module.modules) {
+			await copyGirFile(config, mod);
+		}
+	}
 
-    if (failed.length > 0) {
-        Logger.danger('\nDependencies not found:')
-        for (const fail of failed) {
-            Logger.white(`- ${fail}`)
-        }
-    }
-}
-
-const examples: ReadonlyArray<[string, string?]> = [
-    [`${Config.appName} copy -o ./gir`, `Copy found *.gir files to ./gir`],
-    [
-        `${Config.appName} copy -g /usr/share/gir-1.0 --ignore=Gtk-3.0 xrandr-1.3 -o ./gir`,
-        'Copy all found *.gir files in /usr/share/gir-1.0 excluding Gtk-3.0 and xrandr-1.3 to ./gir',
-    ],
-]
+	if (failed.length > 0) {
+		logger.danger("\nDependencies not found:");
+		for (const fail of failed) {
+			logger.white(`- ${fail}`);
+		}
+	}
+};
 
 export const copy = {
-    command,
-    description,
-    builder,
-    handler,
-    examples,
-}
+	command,
+	description,
+	builder,
+	handler,
+	examples,
+};