dittory 0.0.1 → 0.0.3

package/dist/cli.mjs

@@ -1,209 +1,111 @@
 #!/usr/bin/env node
-import { a as ExtractUsages, i as isTestOrStorybookFile, n as classifyDeclarations, r as BaseAnalyzer, t as analyzePropsCore } from "./analyzeProps-YWnY-Mf7.mjs";
-import { Node, Project, SyntaxKind } from "ts-morph";
-import fs from "node:fs";
+import { i as isTestOrStorybookFile, n as analyzeFunctionsCore, r as collectCallSites, t as analyzePropsCore } from "./analyzeProps-B0TjCZhP.mjs";
+import { Project } from "ts-morph";
 import path from "node:path";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
 
-//#region src/analyzer/classMethodAnalyzer.ts
+//#region src/cli/loadConfig.ts
+/** コンフィグファイルの検索順序 */
+const CONFIG_FILE_NAMES = [
+	"dittory.config.js",
+	"dittory.config.mjs",
+	"dittory.config.json"
+];
 /**
-* クラスメソッドの引数分析を行うAnalyzer
+* コンフィグファイルを読み込む
 *
-* exportされたクラスのメソッド（static/instance）を収集し、
-* 各メソッドの引数使用状況を分析する。
-* 常に同じ値が渡されている引数を検出し、定数として報告する。
+* 現在の作業ディレクトリから以下の順序でコンフィグファイルを探す：
+* 1. dittory.config.js
+* 2. dittory.config.mjs
+* 3. dittory.config.json
 *
-* @example
-* ```ts
-* const analyzer = new ClassMethodAnalyzer({ minUsages: 2 });
-* const result = analyzer.analyze(declarations);
-* console.log(result.constants);
-* ```
+* ファイルが存在しない場合は空のオブジェクトを返す。
+*
+* @returns コンフィグオブジェクト
+* @throws {Error} コンフィグファイルの読み込みに失敗した場合
 */
-var ClassMethodAnalyzer = class extends BaseAnalyzer {
-	constructor(options = {}) {
-		super(options);
-	}
-	/**
-	* 事前分類済みの宣言からクラスメソッドを収集する
-	*
-	* @param declarations - 事前分類済みの宣言配列（type: "class"）
-	* @returns クラスメソッドとその使用状況の配列（名前は「ClassName.methodName」形式）
-	*/
-	collect(declarations) {
-		const results = [];
-		for (const classified of declarations) {
-			const { exportName, sourceFile, declaration } = classified;
-			if (!Node.isClassDeclaration(declaration)) continue;
-			const methods = declaration.getMethods();
-			for (const method of methods) {
-				const methodName = method.getName();
-				const parameters = this.getParameters(method);
-				const callable = {
-					name: `${exportName}.${methodName}`,
-					sourceFilePath: sourceFile.getFilePath(),
-					definitions: parameters,
-					declaration: method,
-					usages: {}
-				};
-				const nameNode = method.getNameNode();
-				if (!Node.isIdentifier(nameNode)) continue;
-				const references = nameNode.findReferences().flatMap((referencedSymbol) => referencedSymbol.getReferences()).filter((ref) => !this.shouldExcludeFile(ref.getSourceFile().getFilePath()));
-				const groupedUsages = {};
-				for (const reference of references) {
-					const propertyAccess = reference.getNode().getParent();
-					if (!propertyAccess || !Node.isPropertyAccessExpression(propertyAccess)) continue;
-					const callExpression = propertyAccess.getParent();
-					if (!callExpression || !Node.isCallExpression(callExpression)) continue;
-					if (callExpression.getExpression() !== propertyAccess) continue;
-					const usages = ExtractUsages.fromCall(callExpression, callable);
-					for (const usage of usages) {
-						if (!groupedUsages[usage.name]) groupedUsages[usage.name] = [];
-						groupedUsages[usage.name].push(usage);
-					}
-				}
-				callable.usages = groupedUsages;
-				results.push(callable);
-			}
-		}
-		return results;
+async function loadConfig() {
+	const cwd = process.cwd();
+	for (const fileName of CONFIG_FILE_NAMES) {
+		const configPath = path.join(cwd, fileName);
+		if (!fs.existsSync(configPath)) continue;
+		if (fileName.endsWith(".json")) return loadJsonConfig(configPath);
+		return loadJsConfig(configPath);
 	}
-	/**
-	* メソッドのパラメータ定義を取得する
-	*/
-	getParameters(method) {
-		return this.extractParameterDeclarations(method).map((param, index) => ({
-			name: param.getName(),
-			index,
-			required: !param.hasQuestionToken() && !param.hasInitializer()
-		}));
+	return {};
+}
+/**
+* JSON コンフィグを読み込む
+*/
+function loadJsonConfig(configPath) {
+	const content = fs.readFileSync(configPath, "utf-8");
+	try {
+		const config = JSON.parse(content);
+		if (typeof config !== "object" || config === null) throw new Error(`Invalid config: expected object, got ${typeof config}`);
+		return validateConfig(config);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new Error(`Failed to parse ${path.basename(configPath)}: ${error.message}`);
+		throw error;
 	}
-	/**
-	* メソッド宣言からParameterDeclarationの配列を抽出する
-	*/
-	extractParameterDeclarations(method) {
-		if (Node.isMethodDeclaration(method)) return method.getParameters();
-		return [];
+}
+/**
+* JS コンフィグを読み込む
+*/
+async function loadJsConfig(configPath) {
+	try {
+		const config = (await import(pathToFileURL(configPath).href)).default;
+		if (typeof config !== "object" || config === null) throw new Error(`Invalid config: expected object, got ${typeof config}`);
+		return validateConfig(config);
+	} catch (error) {
+		if (error instanceof Error) throw new Error(`Failed to load ${path.basename(configPath)}: ${error.message}`);
+		throw error;
 	}
-};
-
-//#endregion
-//#region src/analyzer/functionAnalyzer.ts
+}
+const VALID_TARGETS$1 = [
+	"all",
+	"components",
+	"functions"
+];
+const VALID_OUTPUTS$1 = ["simple", "verbose"];
 /**
-* 関数の引数分析を行うAnalyzer
-*
-* exportされた関数を収集し、各関数の引数使用状況を分析する。
-* 常に同じ値が渡されている引数を検出し、定数として報告する。
-*
-* @example
-* ```ts
-* const analyzer = new FunctionAnalyzer({ minUsages: 2 });
-* const result = analyzer.analyze(declarations);
-* console.log(result.constants);
-* ```
+* コンフィグの値を検証する
 */
-var FunctionAnalyzer = class extends BaseAnalyzer {
-	constructor(options = {}) {
-		super(options);
+function validateConfig(config) {
+	const result = {};
+	if ("minUsages" in config) {
+		if (typeof config.minUsages !== "number" || config.minUsages < 1) throw new Error(`Invalid config: minUsages must be a number >= 1, got ${config.minUsages}`);
+		result.minUsages = config.minUsages;
 	}
-	/**
-	* 事前分類済みの宣言から関数を収集する
-	*
-	* @param declarations - 事前分類済みの宣言配列（type: "function"）
-	* @returns exportされた関数とその使用状況の配列
-	*/
-	collect(declarations) {
-		const results = [];
-		for (const classified of declarations) {
-			const { exportName, sourceFile, declaration } = classified;
-			if (!Node.isFunctionDeclaration(declaration) && !Node.isVariableDeclaration(declaration)) continue;
-			const nameNode = declaration.getNameNode();
-			if (!nameNode || !Node.isIdentifier(nameNode)) continue;
-			const references = nameNode.findReferences().flatMap((referencedSymbol) => referencedSymbol.getReferences()).filter((ref) => !this.shouldExcludeFile(ref.getSourceFile().getFilePath()));
-			const parameters = this.getParameters(declaration);
-			const callable = {
-				name: exportName,
-				sourceFilePath: sourceFile.getFilePath(),
-				definitions: parameters,
-				declaration,
-				usages: {}
-			};
-			const groupedUsages = {};
-			for (const reference of references) {
-				const refNode = reference.getNode();
-				const parent = refNode.getParent();
-				if (!parent) continue;
-				const callExpression = parent.asKind(SyntaxKind.CallExpression);
-				if (!callExpression) continue;
-				if (callExpression.getExpression() !== refNode) continue;
-				const usages = ExtractUsages.fromCall(callExpression, callable);
-				for (const usage of usages) {
-					if (!groupedUsages[usage.name]) groupedUsages[usage.name] = [];
-					groupedUsages[usage.name].push(usage);
-				}
-			}
-			callable.usages = groupedUsages;
-			results.push(callable);
-		}
-		return results;
+	if ("target" in config) {
+		if (!VALID_TARGETS$1.includes(config.target)) throw new Error(`Invalid config: target must be one of ${VALID_TARGETS$1.join(", ")}, got ${config.target}`);
+		result.target = config.target;
 	}
-	/**
-	* 関数のパラメータ定義を取得する
-	*/
-	getParameters(declaration) {
-		return this.extractParameterDeclarations(declaration).map((param, index) => ({
-			name: param.getName(),
-			index,
-			required: !param.hasQuestionToken() && !param.hasInitializer()
-		}));
+	if ("output" in config) {
+		if (!VALID_OUTPUTS$1.includes(config.output)) throw new Error(`Invalid config: output must be one of ${VALID_OUTPUTS$1.join(", ")}, got ${config.output}`);
+		result.output = config.output;
 	}
-	/**
-	* 宣言からParameterDeclarationの配列を抽出する
-	*/
-	extractParameterDeclarations(declaration) {
-		if (Node.isFunctionDeclaration(declaration)) return declaration.getParameters();
-		if (Node.isVariableDeclaration(declaration)) {
-			const initializer = declaration.getInitializer();
-			if (initializer) {
-				if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) return initializer.getParameters();
-			}
-		}
-		return [];
+	if ("tsconfig" in config) {
+		if (typeof config.tsconfig !== "string" || config.tsconfig === "") throw new Error(`Invalid config: tsconfig must be a non-empty string, got ${config.tsconfig}`);
+		result.tsconfig = config.tsconfig;
 	}
-};
-
-//#endregion
-//#region src/analyzeFunctions.ts
-/**
-* 関数・クラスメソッドの引数使用状況を解析し、常に同じ値が渡されている引数を検出する
-*
-* @param sourceFiles - 解析対象のソースファイル配列
-* @param options - オプション設定
-* @returns 解析結果（定数引数、統計情報、exportされた関数・メソッド）
-*
-* @example
-* const project = new Project();
-* project.addSourceFilesAtPaths("src/**\/*.ts");
-* const result = analyzeFunctionsCore(project.getSourceFiles());
-*/
-function analyzeFunctionsCore(sourceFiles, options = {}) {
-	const { shouldExcludeFile = isTestOrStorybookFile, minUsages = 2 } = options;
-	const declarations = classifyDeclarations(sourceFiles);
-	const functions = declarations.filter((decl) => decl.type === "function");
-	const classes = declarations.filter((decl) => decl.type === "class");
-	const analyzerOptions = {
-		shouldExcludeFile,
-		minUsages
-	};
-	const functionResult = new FunctionAnalyzer(analyzerOptions).analyze(functions);
-	const classMethodResult = new ClassMethodAnalyzer(analyzerOptions).analyze(classes);
-	return {
-		constants: [...functionResult.constants, ...classMethodResult.constants],
-		exported: [...functionResult.exported, ...classMethodResult.exported]
-	};
+	if ("targetDir" in config) {
+		if (typeof config.targetDir !== "string" || config.targetDir === "") throw new Error(`Invalid config: targetDir must be a non-empty string, got ${config.targetDir}`);
+		result.targetDir = config.targetDir;
+	}
+	return result;
 }
 
 //#endregion
 //#region src/cli/parseCliOptions.ts
+/** デフォルトのオプション値 */
+const DEFAULT_OPTIONS = {
+	targetDir: "./src",
+	minUsages: 2,
+	target: "all",
+	output: "simple",
+	tsconfig: "./tsconfig.json"
+};
 var CliValidationError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -215,48 +117,53 @@ const VALID_TARGETS = [
 	"components",
 	"functions"
 ];
+const VALID_OUTPUTS = ["simple", "verbose"];
 /** 不明なオプションの検出に使用 */
 const VALID_OPTIONS = [
 	"--min",
 	"--target",
+	"--output",
+	"--tsconfig",
 	"--help"
 ];
 /**
 * CLIオプションをパースする
 *
+* 明示的に指定されたオプションのみを返す（デフォルト値は含まない）
+*
 * @throws {CliValidationError} オプションが無効な場合
 */
 function parseCliOptions(args) {
-	let targetDir = path.join(process.cwd(), "src");
-	let minUsages = 2;
-	let target = "all";
-	let showHelp = false;
+	const result = { showHelp: false };
 	for (const arg of args) {
 		if (arg === "--help") {
-			showHelp = true;
+			result.showHelp = true;
 			continue;
 		}
 		if (arg.startsWith("--min=")) {
 			const valueStr = arg.slice(6);
 			const value = Number.parseInt(valueStr, 10);
-			if (valueStr === "" || Number.isNaN(value)) throw new CliValidationError(`--min の値が無効です: "${valueStr}" (数値を指定してください)`);
-			if (value < 1) throw new CliValidationError(`--min の値は1以上である必要があります: ${value}`);
-			minUsages = value;
+			if (valueStr === "" || Number.isNaN(value)) throw new CliValidationError(`Invalid value for --min: "${valueStr}" (must be a number)`);
+			if (value < 1) throw new CliValidationError(`--min must be at least 1: ${value}`);
+			result.minUsages = value;
 		} else if (arg.startsWith("--target=")) {
 			const value = arg.slice(9);
-			if (!VALID_TARGETS.includes(value)) throw new CliValidationError(`--target の値が無効です: "${value}" (有効な値: ${VALID_TARGETS.join(", ")})`);
-			target = value;
+			if (!VALID_TARGETS.includes(value)) throw new CliValidationError(`Invalid value for --target: "${value}" (valid values: ${VALID_TARGETS.join(", ")})`);
+			result.target = value;
+		} else if (arg.startsWith("--output=")) {
+			const value = arg.slice(9);
+			if (!VALID_OUTPUTS.includes(value)) throw new CliValidationError(`Invalid value for --output: "${value}" (valid values: ${VALID_OUTPUTS.join(", ")})`);
+			result.output = value;
+		} else if (arg.startsWith("--tsconfig=")) {
+			const value = arg.slice(11);
+			if (value === "") throw new CliValidationError("Invalid value for --tsconfig: path cannot be empty");
+			result.tsconfig = value;
 		} else if (arg.startsWith("--")) {
 			const optionName = arg.split("=")[0];
-			if (!VALID_OPTIONS.includes(optionName)) throw new CliValidationError(`不明なオプション: ${optionName}`);
-		} else targetDir = arg;
+			if (!VALID_OPTIONS.includes(optionName)) throw new CliValidationError(`Unknown option: ${optionName}`);
+		} else result.targetDir = arg;
 	}
-	return {
-		targetDir,
-		minUsages,
-		target,
-		showHelp
-	};
+	return result;
 }
 /**
 * 対象ディレクトリの存在を検証する
@@ -264,8 +171,16 @@ function parseCliOptions(args) {
 * @throws {CliValidationError} ディレクトリが存在しない、またはディレクトリでない場合
 */
 function validateTargetDir(targetDir) {
-	if (!fs.existsSync(targetDir)) throw new CliValidationError(`ディレクトリが存在しません: ${targetDir}`);
-	if (!fs.statSync(targetDir).isDirectory()) throw new CliValidationError(`指定されたパスはディレクトリではありません: ${targetDir}`);
+	if (!fs.existsSync(targetDir)) throw new CliValidationError(`Directory does not exist: ${targetDir}`);
+	if (!fs.statSync(targetDir).isDirectory()) throw new CliValidationError(`Path is not a directory: ${targetDir}`);
+}
+/**
+* tsconfig.json の存在を検証する
+*
+* @throws {CliValidationError} ファイルが存在しない場合
+*/
+function validateTsConfig(tsConfigPath) {
+	if (!fs.existsSync(tsConfigPath)) throw new CliValidationError(`tsconfig not found: ${tsConfigPath}`);
 }
 /**
 * ヘルプメッセージを取得する
@@ -275,67 +190,70 @@ function getHelpMessage() {
 Usage: dittory [options] [directory]
 
 Options:
-  --min=<number>    最小使用箇所数 (デフォルト: 2)
-  --target=<mode>   解析対象: all, components, functions (デフォルト: all)
-  --help            このヘルプを表示
+  --min=<number>       Minimum usage count (default: 2)
+  --target=<mode>      Analysis target: all, components, functions (default: all)
+  --output=<mode>      Output mode: simple, verbose (default: simple)
+  --tsconfig=<path>    Path to tsconfig.json (default: ./tsconfig.json)
+  --help               Show this help message
 
 Arguments:
-  directory         解析対象ディレクトリ (デフォルト: ./src)
+  directory            Target directory to analyze (default: ./src)
 `;
 }
 
 //#endregion
 //#region src/output/printAnalysisResult.ts
+function bold(text) {
+	return `\x1b[1m${text}\x1b[0m`;
+}
+function green(text) {
+	return `\x1b[32m${text}\x1b[0m`;
+}
 /**
-* exportされたコンポーネントの一覧を出力
+* 値を表示用にフォーマットする
+*
+* 内部的にはenum区別のためにファイルパスを含むが、表示時は不要なので除去する
+* 例: "/path/to/file.ts:ButtonVariant.Primary=\"primary\"" → "ButtonVariant.Primary"
 */
-function printExportedComponents(exported) {
-	const lines = [
-		"1. exportされたコンポーネントを収集中...",
-		`   → ${exported.length}個のコンポーネントを検出`,
-		...exported.map((comp) => `      - ${comp.name} (${path.relative(process.cwd(), comp.sourceFilePath)})`),
-		""
-	];
-	console.log(lines.join("\n"));
+function formatValueForDisplay(value) {
+	const enumMatch = value.match(/^.+:(\w+\.\w+)=.+$/);
+	if (enumMatch) return enumMatch[1];
+	return value;
 }
 /**
-* 常に同じ値が渡されているpropsを出力
+* Constant[]を関数/コンポーネント単位でグループ化する
 */
-function printConstantProps(constants) {
-	console.log("=== 常に同じ値が渡されているprops ===\n");
-	if (constants.length === 0) {
-		console.log("常に同じ値が渡されているpropsは見つかりませんでした。");
-		return;
-	}
-	for (const prop of constants) {
-		const relativeComponentPath = path.relative(process.cwd(), prop.targetSourceFile);
-		console.log(`コンポーネント: ${prop.targetName}`);
-		console.log(`  定義: ${relativeComponentPath}`);
-		console.log(`  prop: ${prop.paramName}`);
-		console.log(`  常に渡される値: ${prop.value}`);
-		console.log(`  使用箇所: ${prop.usages.length}箇所`);
-		for (const usage of prop.usages) {
-			const relativePath = path.relative(process.cwd(), usage.usageFilePath);
-			console.log(`    - ${relativePath}:${usage.usageLine}`);
+function groupConstantsByTarget(constants) {
+	const groupMap = /* @__PURE__ */ new Map();
+	for (const constant of constants) {
+		const key = `${constant.targetSourceFile}:${constant.targetName}`;
+		let group = groupMap.get(key);
+		if (!group) {
+			group = {
+				targetName: constant.targetName,
+				targetSourceFile: constant.targetSourceFile,
+				targetLine: constant.targetLine,
+				params: []
+			};
+			groupMap.set(key, group);
 		}
-		console.log("");
+		group.params.push({
+			paramName: constant.paramName,
+			value: constant.value,
+			usageCount: constant.usages.length,
+			usages: constant.usages
+		});
 	}
-}
-/**
-* 解析結果を全て出力
-*/
-function printAnalysisResult(result) {
-	printExportedComponents(result.exported);
-	printConstantProps(result.constants);
+	return Array.from(groupMap.values());
 }
 /**
 * exportされた関数の一覧を出力
 */
 function printExportedFunctions(exported) {
 	const lines = [
-		"2. exportされた関数を収集中...",
-		`   → ${exported.length}個の関数を検出`,
-		...exported.map((fn) => `      - ${fn.name} (${path.relative(process.cwd(), fn.sourceFilePath)})`),
+		"Collecting exported functions...",
+		`   → Found ${exported.length} function(s)`,
+		...exported.map((fn) => `      - ${bold(green(fn.name))} (${path.relative(process.cwd(), fn.sourceFilePath)})`),
 		""
 	];
 	console.log(lines.join("\n"));
@@ -344,31 +262,40 @@ function printExportedFunctions(exported) {
 * 常に同じ値が渡されている引数を出力
 */
 function printConstantArguments(constants) {
-	console.log("=== 常に同じ値が渡されている引数 ===\n");
-	if (constants.length === 0) {
-		console.log("常に同じ値が渡されている引数は見つかりませんでした。");
-		return;
-	}
-	for (const arg of constants) {
-		const relativeFunctionPath = path.relative(process.cwd(), arg.targetSourceFile);
-		console.log(`関数: ${arg.targetName}`);
-		console.log(`  定義: ${relativeFunctionPath}`);
-		console.log(`  引数: ${arg.paramName}`);
-		console.log(`  常に渡される値: ${arg.value}`);
-		console.log(`  使用箇所: ${arg.usages.length}箇所`);
-		for (const usage of arg.usages) {
-			const relativePath = path.relative(process.cwd(), usage.usageFilePath);
-			console.log(`    - ${relativePath}:${usage.usageLine}`);
+	if (constants.length === 0) return;
+	const grouped = groupConstantsByTarget(constants);
+	for (const group of grouped) {
+		const relativePath = path.relative(process.cwd(), group.targetSourceFile);
+		const usageCount = group.params[0]?.usageCount ?? 0;
+		const usages = group.params[0]?.usages ?? [];
+		console.log(`${bold(green(group.targetName))} ${relativePath}:${group.targetLine}`);
+		console.log("Constant Arguments:");
+		for (const param of group.params) console.log(`  - ${param.paramName} = ${formatValueForDisplay(param.value)}`);
+		console.log(`Usages (${usageCount}):`);
+		for (const usage of usages) {
+			const usagePath = path.relative(process.cwd(), usage.usageFilePath);
+			console.log(`  - ${usagePath}:${usage.usageLine}`);
 		}
-		console.log("");
+		console.log("\n");
 	}
 }
 /**
-* 関数解析結果を全て出力
+* 統計情報を出力
+*/
+function printStatistics(result) {
+	const totalFunctions = result.exported.length;
+	const functionsWithConstants = groupConstantsByTarget(result.constants).length;
+	console.log("---");
+	console.log(`Found ${functionsWithConstants} function(s) with constant arguments out of ${totalFunctions} function(s).`);
+}
+/**
+* 解析結果を出力
 */
-function printFunctionAnalysisResult(result) {
-	printExportedFunctions(result.exported);
-	printConstantArguments(result.constants);
+function printAnalysisResult(result, mode) {
+	if (mode === "verbose") printExportedFunctions(result.exported);
+	if (result.constants.length === 0) console.log("No arguments with constant values were found.");
+	else printConstantArguments(result.constants);
+	printStatistics(result);
 }
 
 //#endregion
@@ -376,9 +303,10 @@ function printFunctionAnalysisResult(result) {
 /**
 * プロジェクトを初期化し、フィルタリングされたソースファイルを取得する
 */
-function createFilteredSourceFiles(targetDir, shouldExcludeFile = isTestOrStorybookFile) {
+function createFilteredSourceFiles(targetDir, options = {}) {
+	const { shouldExcludeFile = isTestOrStorybookFile, tsConfigFilePath = path.join(process.cwd(), "tsconfig.json") } = options;
 	const project = new Project({
-		tsConfigFilePath: path.join(process.cwd(), "tsconfig.json"),
+		tsConfigFilePath,
 		skipAddingFilesFromTsConfig: true
 	});
 	project.addSourceFilesAtPaths(`${targetDir}/**/*.{ts,tsx,js,jsx}`);
@@ -391,36 +319,81 @@ function createFilteredSourceFiles(targetDir, shouldExcludeFile = isTestOrStoryb
 * エラーメッセージを表示してプロセスを終了する
 */
 function exitWithError(message) {
-	console.error(`エラー: ${message}`);
+	console.error(`Error: ${message}`);
 	process.exit(1);
 }
-function main() {
-	let options;
+async function main() {
+	let cliOptions;
 	try {
-		options = parseCliOptions(process.argv.slice(2));
+		cliOptions = parseCliOptions(process.argv.slice(2));
 	} catch (error) {
 		if (error instanceof CliValidationError) exitWithError(error.message);
 		throw error;
 	}
-	const { targetDir, minUsages, target, showHelp } = options;
-	if (showHelp) {
+	if (cliOptions.showHelp) {
 		console.log(getHelpMessage());
 		process.exit(0);
 	}
+	let fileConfig;
+	try {
+		fileConfig = await loadConfig();
+	} catch (error) {
+		if (error instanceof Error) exitWithError(error.message);
+		throw error;
+	}
+	const { targetDir, minUsages, target, output, tsconfig } = {
+		targetDir: path.resolve(cliOptions.targetDir ?? fileConfig.targetDir ?? DEFAULT_OPTIONS.targetDir),
+		minUsages: cliOptions.minUsages ?? fileConfig.minUsages ?? DEFAULT_OPTIONS.minUsages,
+		target: cliOptions.target ?? fileConfig.target ?? DEFAULT_OPTIONS.target,
+		output: cliOptions.output ?? fileConfig.output ?? DEFAULT_OPTIONS.output,
+		tsconfig: cliOptions.tsconfig ?? fileConfig.tsconfig ?? DEFAULT_OPTIONS.tsconfig
+	};
 	try {
 		validateTargetDir(targetDir);
 	} catch (error) {
 		if (error instanceof CliValidationError) exitWithError(error.message);
 		throw error;
 	}
-	console.log(`解析対象ディレクトリ: ${targetDir}`);
-	console.log(`最小使用箇所数: ${minUsages}`);
-	console.log(`解析対象: ${target}\n`);
-	const sourceFilesToAnalyze = createFilteredSourceFiles(targetDir);
-	if (target === "all" || target === "components") printAnalysisResult(analyzePropsCore(sourceFilesToAnalyze, { minUsages }));
-	if (target === "all" || target === "functions") printFunctionAnalysisResult(analyzeFunctionsCore(sourceFilesToAnalyze, { minUsages }));
+	try {
+		validateTsConfig(tsconfig);
+	} catch (error) {
+		if (error instanceof CliValidationError) exitWithError(error.message);
+		throw error;
+	}
+	if (output === "verbose") {
+		console.log(`Target directory: ${targetDir}`);
+		console.log(`Minimum usage count: ${minUsages}`);
+		console.log(`Analysis target: ${target}\n`);
+	}
+	const sourceFilesToAnalyze = createFilteredSourceFiles(targetDir, { tsConfigFilePath: tsconfig });
+	const callSiteMap = collectCallSites(sourceFilesToAnalyze);
+	const allExported = [];
+	const allConstants = [];
+	if (target === "all" || target === "components") {
+		const propsResult = analyzePropsCore(sourceFilesToAnalyze, {
+			minUsages,
+			callSiteMap
+		});
+		allExported.push(...propsResult.exported);
+		allConstants.push(...propsResult.constants);
+	}
+	if (target === "all" || target === "functions") {
+		const functionsResult = analyzeFunctionsCore(sourceFilesToAnalyze, {
+			minUsages,
+			callSiteMap
+		});
+		allExported.push(...functionsResult.exported);
+		allConstants.push(...functionsResult.constants);
+	}
+	printAnalysisResult({
+		exported: allExported,
+		constants: allConstants
+	}, output);
 }
-main();
+main().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
 
 //#endregion
 export {  };