@yuu1111/quality-check 0.5.0 → 0.6.0

package/package.json

@@ -1,8 +1,7 @@
 {
 	"name": "@yuu1111/quality-check",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Integrated quality check runner",
-	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/yuu1111/configs.git",
@@ -10,7 +9,7 @@
 	},
 	"type": "module",
 	"bin": {
-		"quality-check": "src/cli.ts"
+		"quality-check": "dist/cli.js"
 	},
 	"exports": {
 		".": "./src/config.ts",
@@ -18,10 +17,18 @@
 	},
 	"files": [
 		"README.ja.md",
-		"src"
+		"src/config.ts",
+		"src/engines.ts",
+		"dist"
 	],
+	"scripts": {
+		"build": "bun build src/cli.ts --target=bun --outdir=dist"
+	},
 	"keywords": [
 		"quality",
 		"lint"
-	]
+	],
+	"devDependencies": {
+		"@yuu1111/shared": "workspace:*"
+	}
 }

package/src/config.ts

@@ -39,12 +39,20 @@ export interface TsdocCheckOptions extends EngineOptions {
 	error?: string[];
 }
 
+/**
+ * 型検査へ渡す起動条件
+ */
+export interface TypecheckOptions extends EngineOptions {
+	/** 型検査するtsconfigのpath 省略時はカレントのtsconfig.jsonを1回だけ読む */
+	projects?: string[];
+}
+
 /**
  * engine名ごとの起動条件
  */
 export interface EngineConfigMap {
 	biome: EngineOptions;
-	typecheck: EngineOptions;
+	typecheck: TypecheckOptions;
 	knip: EngineOptions;
 	"comment-check": EngineOptions;
 	"document-style-check": EngineOptions;
@@ -97,7 +105,7 @@ function isEngineName(value: string): value is EngineName {
 
 const ENGINE_OPTION_KEYS: Record<EngineName, readonly string[]> = {
 	biome: ["args", "ignore", "targets"],
-	typecheck: ["args", "ignore", "targets"],
+	typecheck: ["args", "ignore", "projects", "targets"],
 	knip: ["args", "ignore", "targets"],
 	"comment-check": ["args", "ignore", "targets"],
 	"document-style-check": ["args", "ignore", "targets"],
@@ -155,11 +163,16 @@ function parseEngines(
 	return engines;
 }
 
+type ParsedEngineOptions = EngineOptions & {
+	error?: string[];
+	projects?: string[];
+};
+
 function parseEngineOptions(
 	value: JsonObject,
 	source: string,
 	name: EngineName,
-): TsdocCheckOptions {
+): ParsedEngineOptions {
 	const unknown = Object.keys(value).filter(
 		(key) => !ENGINE_OPTION_KEYS[name].includes(key),
 	);
@@ -168,7 +181,7 @@ function parseEngineOptions(
 			`${source}: config.${name} has an unknown option: ${unknown[0]}`,
 		);
 	}
-	const options: TsdocCheckOptions = {};
+	const options: ParsedEngineOptions = {};
 	const ignore = readStringArray(
 		value.ignore,
 		`${source}: config.${name}.ignore`,
@@ -196,6 +209,18 @@ function parseEngineOptions(
 			options.error = error;
 		}
 	}
+	if (name === "typecheck") {
+		const projects = readStringArray(
+			value.projects,
+			`${source}: config.${name}.projects`,
+		);
+		if (projects !== undefined) {
+			if (projects.length === 0) {
+				throw new Error(`${source}: config.${name}.projects must not be empty`);
+			}
+			options.projects = projects;
+		}
+	}
 	return options;
 }
 

package/src/engines.ts

@@ -70,7 +70,7 @@ export const ENGINE_LIMITS: Record<
 	biome: { ignore: "biome.json holds its settings" },
 	typecheck: {
 		ignore: "tsconfig.json holds its settings",
-		targets: "tsc checks the project named by tsconfig.json",
+		targets: "tsconfig.json and projects hold its settings",
 	},
 	knip: {
 		ignore: "knip.ts holds its settings",
@@ -161,6 +161,24 @@ function colorArguments(name: EngineName, color: boolean): string[] {
 	return [];
 }
 
+/**
+ * 型検査のコマンドを組み立てる projectを渡すとそのtsconfigを読む
+ */
+function buildTypecheckCommand(
+	executable: string,
+	context: EngineCommandContext,
+	project: string | undefined,
+): string[] {
+	const options = engineConfig(context.config, "typecheck") ?? {};
+	return [
+		executable,
+		"--noEmit",
+		...(project === undefined ? [] : ["--project", project]),
+		...colorArguments("typecheck", context.color),
+		...(options.args ?? []),
+	];
+}
+
 /**
  * engineへ渡すコマンドを組み立てる
  */
@@ -194,12 +212,7 @@ export function buildEngineCommand(
 		];
 	}
 	if (name === "typecheck") {
-		return [
-			executable,
-			"--noEmit",
-			...colorArguments(name, context.color),
-			...extra,
-		];
+		return buildTypecheckCommand(executable, context, undefined);
 	}
 	if (name === "knip") {
 		return [executable, ...extra];
@@ -235,6 +248,26 @@ export function buildEngineCommand(
 	];
 }
 
+/**
+ * engineの起動コマンドを順番に返す 型検査だけはprojectsごとに起動する
+ */
+export function buildEngineCommands(
+	name: EngineName,
+	executable: string,
+	context: EngineCommandContext,
+): string[][] {
+	const projects =
+		name === "typecheck"
+			? (engineConfig(context.config, "typecheck")?.projects ?? [])
+			: [];
+	if (projects.length === 0) {
+		return [buildEngineCommand(name, executable, context)];
+	}
+	return projects.map((project) =>
+		buildTypecheckCommand(executable, context, project),
+	);
+}
+
 /**
  * Bun.spawnでengineを起動する既定のrunner
  */

package/src/baseline.ts

@@ -1,147 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import type { NormalizedFinding } from "./findings";
-
-/**
- * baselineへ記録する検出1件の識別情報と件数
- */
-export interface BaselineEntry {
-	count: number;
-	engine: string;
-	file: string;
-	rule: string;
-	text: string;
-}
-
-/**
- * baseline fileの形式
- */
-export interface BaselineFile {
-	entries: BaselineEntry[];
-	version: 1;
-}
-
-/**
- * baselineと現在の検出を比較した結果
- */
-export interface BaselineComparison {
-	added: NormalizedFinding[];
-	resolved: BaselineEntry[];
-}
-
-type JsonObject = Record<string, unknown>;
-
-/**
- * 検出をbaseline上で一意に識別するkeyに使う項目
- */
-export interface BaselineKey {
-	engine: string;
-	file: string;
-	rule: string;
-	text: string;
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isBaselineEntry(value: unknown): value is BaselineEntry {
-	if (!isJsonObject(value)) {
-		return false;
-	}
-	return (
-		typeof value.engine === "string" &&
-		typeof value.rule === "string" &&
-		typeof value.file === "string" &&
-		typeof value.text === "string" &&
-		typeof value.count === "number"
-	);
-}
-
-function entryKey(entry: BaselineKey): string {
-	return [entry.engine, entry.rule, entry.file, entry.text].join("\u0000");
-}
-
-function compareEntries(left: BaselineEntry, right: BaselineEntry): number {
-	const leftKey = entryKey(left);
-	const rightKey = entryKey(right);
-	if (leftKey === rightKey) {
-		return 0;
-	}
-	return leftKey < rightKey ? -1 : 1;
-}
-
-/**
- * 検出をengineとruleとfileと本文で集計してbaselineを作る
- */
-export function createBaseline(findings: NormalizedFinding[]): BaselineFile {
-	const entries = new Map<string, BaselineEntry>();
-	for (const finding of findings) {
-		const key = entryKey(finding);
-		const existing = entries.get(key);
-		if (existing) {
-			existing.count += 1;
-			continue;
-		}
-		entries.set(key, {
-			count: 1,
-			engine: finding.engine,
-			file: finding.file,
-			rule: finding.rule,
-			text: finding.text,
-		});
-	}
-	return { entries: [...entries.values()].sort(compareEntries), version: 1 };
-}
-
-/**
- * 現在の検出からbaseline済みを除き、解消済みentryを求める
- */
-export function compareWithBaseline(
-	findings: NormalizedFinding[],
-	baseline: BaselineFile,
-): BaselineComparison {
-	const remaining = new Map<string, number>();
-	for (const entry of baseline.entries) {
-		const key = entryKey(entry);
-		remaining.set(key, (remaining.get(key) ?? 0) + entry.count);
-	}
-	const added: NormalizedFinding[] = [];
-	for (const finding of findings) {
-		const key = entryKey(finding);
-		const count = remaining.get(key) ?? 0;
-		if (count > 0) {
-			remaining.set(key, count - 1);
-			continue;
-		}
-		added.push(finding);
-	}
-	const resolved = baseline.entries.filter(
-		(entry) => (remaining.get(entryKey(entry)) ?? 0) > 0,
-	);
-	return { added, resolved };
-}
-
-/**
- * baseline fileを読み込む 存在しない場合は空のbaselineを返す
- */
-export function readBaseline(path: string): BaselineFile {
-	if (!existsSync(path)) {
-		return { entries: [], version: 1 };
-	}
-	const value: unknown = JSON.parse(readFileSync(path, "utf8"));
-	if (
-		!isJsonObject(value) ||
-		!Array.isArray(value.entries) ||
-		!value.entries.every(isBaselineEntry)
-	) {
-		throw new Error(`${path} is not a quality baseline`);
-	}
-	return { entries: value.entries, version: 1 };
-}
-
-/**
- * baseline fileをタブ区切りのJSONで書き込む
- */
-export function writeBaseline(path: string, baseline: BaselineFile): void {
-	writeFileSync(path, `${JSON.stringify(baseline, null, "\t")}\n`);
-}

package/src/cli.ts

@@ -1,183 +0,0 @@
-#!/usr/bin/env bun
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { createBaseline, readBaseline, writeBaseline } from "./baseline";
-import { ansiPainter, colorEnabled, plainPainter } from "./color";
-import {
-	DEFAULT_BASELINE_FILE,
-	findConfigFile,
-	loadConfig,
-	type QualityConfig,
-} from "./config";
-import { formatEngineSection, formatSummary, toJsonReport } from "./report";
-import { runEngines } from "./run";
-
-const USAGE =
-	"Usage: quality-check [--config <path>] [--baseline <path>] [--ignore <path>] [--update-baseline] [--json] [path...]";
-
-interface Options {
-	baselinePath: string | undefined;
-	configPath: string | undefined;
-	ignores: string[];
-	json: boolean;
-	targets: string[];
-	update: boolean;
-}
-
-function applyFlagOption(options: Options, argument: string): boolean {
-	if (argument === "--json") {
-		options.json = true;
-		return true;
-	}
-	if (argument === "--update-baseline") {
-		options.update = true;
-		return true;
-	}
-	return false;
-}
-
-function applyValueOption(
-	options: Options,
-	argument: string,
-	argv: string[],
-	index: number,
-): number | null {
-	if (argument === "--config") {
-		options.configPath = argv[index + 1];
-		return 1;
-	}
-	if (argument.startsWith("--config=")) {
-		options.configPath = argument.slice("--config=".length);
-		return 0;
-	}
-	if (argument === "--baseline") {
-		options.baselinePath = argv[index + 1];
-		return 1;
-	}
-	if (argument.startsWith("--baseline=")) {
-		options.baselinePath = argument.slice("--baseline=".length);
-		return 0;
-	}
-	if (argument === "--ignore") {
-		const value = argv[index + 1];
-		if (value !== undefined) {
-			options.ignores.push(value);
-		}
-		return 1;
-	}
-	if (argument.startsWith("--ignore=")) {
-		options.ignores.push(argument.slice("--ignore=".length));
-		return 0;
-	}
-	return null;
-}
-
-function parseArguments(argv: string[]): Options {
-	const options: Options = {
-		baselinePath: undefined,
-		configPath: undefined,
-		ignores: [],
-		json: false,
-		targets: [],
-		update: false,
-	};
-	for (let index = 0; index < argv.length; index += 1) {
-		const argument = argv[index] ?? "";
-		const consumed = applyValueOption(options, argument, argv, index);
-		if (consumed !== null) {
-			index += consumed;
-			continue;
-		}
-		if (applyFlagOption(options, argument)) {
-			continue;
-		}
-		if (argument.startsWith("-")) {
-			throw new Error(`unknown option: ${argument}`);
-		}
-		options.targets.push(argument);
-	}
-	return options;
-}
-
-function resolveBaselinePath(
-	options: Options,
-	config: QualityConfig,
-	cwd: string,
-): string | null {
-	if (options.baselinePath !== undefined) {
-		return resolve(cwd, options.baselinePath);
-	}
-	if (config.baseline === false) {
-		return null;
-	}
-	return resolve(cwd, config.baseline ?? DEFAULT_BASELINE_FILE);
-}
-
-function resolveConfigPath(options: Options, cwd: string): string | null {
-	if (options.configPath !== undefined) {
-		return resolve(cwd, options.configPath);
-	}
-	return findConfigFile(cwd);
-}
-
-async function main(argv: string[]): Promise<number> {
-	if (argv.includes("--help") || argv.includes("-h")) {
-		console.log(USAGE);
-		return 0;
-	}
-	const options = parseArguments(argv);
-	const color = colorEnabled(process.stdout, process.env);
-	const paint = color ? ansiPainter() : plainPainter;
-	const cwd = process.cwd();
-	const configPath = resolveConfigPath(options, cwd);
-	if (configPath === null) {
-		console.error(`quality.config.ts not found in ${cwd}`);
-		return 2;
-	}
-	const config = await loadConfig(configPath);
-	const baselinePath = resolveBaselinePath(options, config, cwd);
-	const results = await runEngines({
-		baseline:
-			options.update || baselinePath === null
-				? null
-				: readBaseline(baselinePath),
-		color,
-		config,
-		cwd,
-		overrides: { ignore: options.ignores, targets: options.targets },
-		rawBaseline: join(tmpdir(), `quality-check-raw-${process.pid}.json`),
-	});
-	if (options.update) {
-		if (baselinePath === null) {
-			console.error("baseline is disabled by the configuration");
-			return 2;
-		}
-		const baseline = createBaseline(
-			results.flatMap((result) => result.detected),
-		);
-		writeBaseline(baselinePath, baseline);
-		console.log(
-			paint(
-				`Recorded ${baseline.entries.length} entries in ${baselinePath}`,
-				"pass",
-			),
-		);
-		return 0;
-	}
-	if (options.json) {
-		console.log(JSON.stringify(toJsonReport(results), null, "\t"));
-	} else {
-		for (const result of results) {
-			console.log(formatEngineSection(result, paint));
-		}
-		console.log(formatSummary(results, paint));
-	}
-	return results.some((result) => result.status !== "passed") ? 1 : 0;
-}
-
-try {
-	process.exit(await main(process.argv.slice(2)));
-} catch (error) {
-	console.error(error instanceof Error ? error.message : String(error));
-	process.exit(2);
-}

package/src/color.ts

@@ -1,47 +0,0 @@
-/**
- * 出力行へ割り当てる装飾の種類
- */
-export type Tone = "error" | "header" | "muted" | "pass" | "warn";
-
-/**
- * toneに応じて文字列を装飾する関数
- */
-export type Painter = (text: string, tone: Tone) => string;
-
-const ANSI_CODES: Record<Tone, string> = {
-	error: "31",
-	header: "36",
-	muted: "2",
-	pass: "32",
-	warn: "33",
-};
-
-/**
- * 装飾を付けずにそのまま返すpainter
- */
-export function plainPainter(text: string, _tone: Tone): string {
-	return text;
-}
-
-/**
- * ANSI escapeでtoneを色へ割り当てるpainterを作る
- */
-export function ansiPainter(): Painter {
-	return (text, tone) => `\u001b[${ANSI_CODES[tone]}m${text}\u001b[0m`;
-}
-
-/**
- * 出力先と環境変数から装飾の可否を決める
- */
-export function colorEnabled(
-	stream: { isTTY?: boolean | undefined },
-	env: Record<string, string | undefined>,
-): boolean {
-	if (env.NO_COLOR !== undefined && env.NO_COLOR !== "") {
-		return false;
-	}
-	if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "") {
-		return env.FORCE_COLOR !== "0";
-	}
-	return stream.isTTY === true;
-}

package/src/findings.ts

@@ -1,106 +0,0 @@
-import type { EngineName } from "./config";
-
-/**
- * 検出の重大度
- */
-export type FindingSeverity = "error" | "warning";
-
-/**
- * engine間の差を吸収した検出1件
- */
-export interface NormalizedFinding {
-	column: number;
-	engine: EngineName;
-	file: string;
-	line: number;
-	rule: string;
-	severity: FindingSeverity;
-	text: string;
-}
-
-/**
- * engineが--jsonで返した検出の分類
- */
-export interface ParsedFindings {
-	errors: NormalizedFinding[];
-	warnings: NormalizedFinding[];
-}
-
-type JsonObject = Record<string, unknown>;
-
-function isJsonObject(value: unknown): value is JsonObject {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function readFinding(
-	engine: EngineName,
-	value: unknown,
-	severity: FindingSeverity,
-	textField: "message" | "text",
-): NormalizedFinding {
-	if (!isJsonObject(value)) {
-		throw new Error(`${engine} printed an unexpected finding`);
-	}
-	const { column, file, line, rule } = value;
-	const text = value[textField];
-	if (
-		typeof rule !== "string" ||
-		typeof file !== "string" ||
-		typeof line !== "number" ||
-		typeof column !== "number" ||
-		typeof text !== "string"
-	) {
-		throw new Error(`${engine} printed an unexpected finding`);
-	}
-	return { column, engine, file, line, rule, severity, text };
-}
-
-function readEntries(
-	engine: EngineName,
-	value: unknown,
-	field: string,
-): unknown[] {
-	if (!Array.isArray(value)) {
-		throw new Error(`${engine} printed JSON without a ${field} array`);
-	}
-	return value;
-}
-
-function parseJson(engine: EngineName, stdout: string): JsonObject {
-	let value: unknown;
-	try {
-		value = JSON.parse(stdout);
-	} catch {
-		throw new Error(`${engine} did not print JSON`);
-	}
-	if (!isJsonObject(value)) {
-		throw new Error(`${engine} printed an unexpected JSON value`);
-	}
-	return value;
-}
-
-/**
- * engineの--json出力を検出へ変換する 解析できない出力は例外にする
- */
-export function parseFindings(
-	engine: EngineName,
-	stdout: string,
-): ParsedFindings {
-	const value = parseJson(engine, stdout);
-	if (engine === "comment-check") {
-		return {
-			errors: readEntries(engine, value.added, "added").map((entry) =>
-				readFinding(engine, entry, "error", "text"),
-			),
-			warnings: [],
-		};
-	}
-	return {
-		errors: readEntries(engine, value.errors, "errors").map((entry) =>
-			readFinding(engine, entry, "error", "message"),
-		),
-		warnings: readEntries(engine, value.warnings, "warnings").map((entry) =>
-			readFinding(engine, entry, "warning", "message"),
-		),
-	};
-}