@litfamily/litcodex 1.0.0

package/node_modules/@litcodex/lit-loop/skills/lit-code/scripts/rust/check-no-excuse-rules.sh

@@ -0,0 +1,158 @@
+#!/usr/bin/env bash
+# No-excuse rule checker for Rust files.
+# Mirrors the philosophy of python-programmer / typescript-programmer scripts:
+# only rules that can be enforced via pure text matching live here.
+# Everything semantic is on clippy + miri + nextest.
+
+set -euo pipefail
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 <file.rs> [file.rs ...]" >&2
+    exit 2
+fi
+
+violations=0
+report() {
+    local file="$1"
+    local line="$2"
+    local rule="$3"
+    local detail="$4"
+    echo "::error file=${file},line=${line}::[${rule}] ${detail}" >&2
+    violations=$((violations + 1))
+}
+
+is_test_path() {
+    local path="$1"
+    case "$path" in
+        */tests/*|*/benches/*|*/examples/*|*/build.rs|*_test.rs|tests/*|benches/*|examples/*) return 0 ;;
+    esac
+    # In-file #[cfg(test)] modules are handled per-line below.
+    return 1
+}
+
+for file in "$@"; do
+    [ -f "$file" ] || continue
+    case "$file" in
+        *.rs) ;;
+        *) continue ;;
+    esac
+
+    if is_test_path "$file"; then
+        # Test files are exempt from unwrap/expect/todo rules.
+        # Still enforce unsafe-comment, allow-comment, panic-in-lib rules below
+        # by setting a marker - keeping the loop unified.
+        in_test_file=1
+    else
+        in_test_file=0
+    fi
+
+    # Track #[cfg(test)] regions for per-line exemptions.
+    in_cfg_test=0
+    cfg_test_brace_depth=0
+    line_no=0
+
+    while IFS= read -r raw_line || [ -n "$raw_line" ]; do
+        line_no=$((line_no + 1))
+        line="$raw_line"
+
+        # Crude #[cfg(test)] region tracker: when we see #[cfg(test)] on a
+        # line followed by a mod with `{`, count braces until depth returns
+        # to zero. This is approximate but matches typical formatting.
+        if [[ "$line" =~ \#\[cfg\(test\)\] ]]; then
+            in_cfg_test=1
+            cfg_test_brace_depth=0
+        fi
+        if [ "$in_cfg_test" -eq 1 ]; then
+            opens=$(printf '%s' "$line" | tr -cd '{' | wc -c)
+            closes=$(printf '%s' "$line" | tr -cd '}' | wc -c)
+            cfg_test_brace_depth=$((cfg_test_brace_depth + opens - closes))
+            if [ "$cfg_test_brace_depth" -le 0 ] && [[ ! "$line" =~ \#\[cfg\(test\)\] ]]; then
+                in_cfg_test=0
+            fi
+        fi
+
+        exempt=0
+        [ "$in_test_file" -eq 1 ] && exempt=1
+        [ "$in_cfg_test" -eq 1 ] && exempt=1
+
+        # Strip line comments before pattern checks - so doc comments and
+        # explanatory prose do not trip the regexes.
+        code_only="${line%%//*}"
+
+        if [ "$exempt" -eq 0 ]; then
+            # .unwrap()
+            if [[ "$code_only" =~ \.unwrap\(\) ]]; then
+                # Allow if previous line had // SAFE-UNWRAP: comment
+                prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
+                if [[ ! "$prev_line" =~ //[[:space:]]*SAFE-UNWRAP: ]]; then
+                    report "$file" "$line_no" "unwrap" ".unwrap() outside tests - use ? / ok_or / pattern match or annotate previous line with // SAFE-UNWRAP: <reason>"
+                fi
+            fi
+
+            # .expect("...")
+            if [[ "$code_only" =~ \.expect\( ]]; then
+                prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
+                if [[ ! "$prev_line" =~ //[[:space:]]*SAFE-EXPECT: ]]; then
+                    report "$file" "$line_no" "expect" ".expect() outside tests - use ? or annotate previous line with // SAFE-EXPECT: <reason>"
+                fi
+            fi
+
+            # todo!() / unimplemented!() / unreachable!()
+            if [[ "$code_only" =~ (todo!|unimplemented!|unreachable!|unreachable_unchecked!) ]]; then
+                report "$file" "$line_no" "placeholder-macro" "todo!/unimplemented!/unreachable! in committed code"
+            fi
+
+            # Box<dyn Error
+            if [[ "$code_only" =~ Box\<dyn[[:space:]]+Error ]]; then
+                report "$file" "$line_no" "box-dyn-error" "Box<dyn Error> in non-test code - use anyhow::Error (apps) or thiserror enum (libs)"
+            fi
+
+            # panic!( in lib
+            if [[ "$file" == */src/lib.rs || "$file" == */src/*/mod.rs || ( "$file" == */src/*.rs && "$file" != */src/main.rs && "$file" != */src/bin/* ) ]]; then
+                if [[ "$code_only" =~ panic!\( ]]; then
+                    report "$file" "$line_no" "lib-panic" "panic!() in library code - return Result"
+                fi
+            fi
+        fi
+
+        # unsafe { without preceding // SAFETY: in the last 5 lines (always enforced)
+        if [[ "$code_only" =~ unsafe[[:space:]]*\{ ]]; then
+            start=$((line_no > 5 ? line_no - 5 : 1))
+            window=$(sed -n "${start},${line_no}p" "$file" 2>/dev/null || true)
+            if [[ ! "$window" =~ //[[:space:]]*SAFETY: ]]; then
+                report "$file" "$line_no" "unsafe-no-safety-comment" "unsafe block without // SAFETY: comment in preceding 5 lines"
+            fi
+        fi
+
+        # #[allow(clippy::...)] without preceding // CLIPPY-ALLOW: justification
+        if [[ "$code_only" =~ \#\[allow\(clippy:: ]]; then
+            prev_line=$(sed -n "$((line_no - 1))p" "$file" 2>/dev/null || true)
+            if [[ ! "$prev_line" =~ //[[:space:]]*CLIPPY-ALLOW: ]]; then
+                report "$file" "$line_no" "unjustified-clippy-allow" "#[allow(clippy::...)] without // CLIPPY-ALLOW: <reason> on previous line"
+            fi
+        fi
+
+        # Narrowing numeric `as` casts - heuristic flag for human review.
+        # Catches the common shapes; precise type analysis belongs to clippy::cast_possible_truncation.
+        if [[ "$code_only" =~ as[[:space:]]+(u8|u16|u32|i8|i16|i32) ]] && \
+           [[ "$code_only" =~ (u16|u32|u64|u128|usize|i16|i32|i64|i128|isize)[[:space:]]+as[[:space:]]+(u8|u16|u32|i8|i16|i32) ]]; then
+            report "$file" "$line_no" "narrowing-as-cast" "possible narrowing 'as' cast - use TryFrom / try_into() for fallible conversion"
+        fi
+    done < "$file"
+done
+
+if [ "$violations" -gt 0 ]; then
+    echo "" >&2
+    echo "rust-programmer: ${violations} violation(s). Fix before declaring work done." >&2
+    echo "" >&2
+    echo "Then run the full toolchain gate:" >&2
+    echo "  cargo +stable fmt --all -- --check" >&2
+    echo "  cargo +stable clippy --all-targets --all-features -- -D warnings" >&2
+    echo "  cargo nextest run --all-targets --all-features" >&2
+    echo "  cargo +nightly miri nextest run --all-features    # if unsafe touched" >&2
+    echo "  cargo machete" >&2
+    echo "  cargo deny check" >&2
+    exit 1
+fi
+
+echo "rust-programmer: no-excuse rules passed for $# file(s)."

package/node_modules/@litcodex/lit-loop/skills/lit-code/scripts/rust/new-project.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "typer",
+#     "rich",
+# ]
+# ///
+
+# ─── How to run ───
+# 1. Install uv (if not installed):
+#      curl -LsSf https://astral.sh/uv/install.sh | sh
+# 2. Run:
+#      uv run new-project.py myproject
+#      uv run new-project.py myproject --path ./workspace
+# ──────────────────
+#
+# Creates a new Rust project with strict lints, deny.toml, rustfmt.toml,
+# rust-toolchain.toml, and .cargo/config.toml pre-configured.
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console(stderr=True)
+
+# ── Embedded config contents ─────────────────────────────────────────────
+
+RUST_TOOLCHAIN_TOML = """\
+[toolchain]
+channel = "stable"
+components = ["rustfmt", "clippy", "rust-src"]
+profile = "default"
+"""
+
+CARGO_TOML_LINTS = """
+[lints.rust]
+unsafe_op_in_unsafe_fn = "deny"
+missing_docs = "warn"
+missing_debug_implementations = "warn"
+unreachable_pub = "warn"
+unused_must_use = "deny"
+elided_lifetimes_in_paths = "warn"
+non_ascii_idents = "deny"
+trivial_numeric_casts = "warn"
+unused_lifetimes = "warn"
+single_use_lifetimes = "warn"
+
+[lints.clippy]
+all = { level = "deny", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+cargo = { level = "warn", priority = -1 }
+undocumented_unsafe_blocks = "deny"
+multiple_unsafe_ops_per_block = "deny"
+unwrap_used = "deny"
+expect_used = "deny"
+panic = "deny"
+todo = "deny"
+unimplemented = "deny"
+dbg_macro = "deny"
+print_stdout = "warn"
+print_stderr = "warn"
+module_name_repetitions = { level = "allow" }
+must_use_candidate = { level = "allow" }
+missing_errors_doc = { level = "allow" }
+missing_panics_doc = { level = "allow" }
+"""
+
+CARGO_CONFIG_TOML = """\
+[build]
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+
+[target.x86_64-unknown-linux-gnu]
+linker = "clang"
+rustflags = ["-C", "link-arg=-fuse-ld=lld"]
+
+[target.aarch64-apple-darwin]
+rustflags = []
+"""
+
+DENY_TOML = """\
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+
+[licenses]
+unlicensed = "deny"
+allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unicode-3.0", "Zlib"]
+
+[bans]
+multiple-versions = "warn"
+wildcards = "deny"
+
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"
+"""
+
+RUSTFMT_TOML = """\
+edition = "2024"
+max_width = 100
+use_field_init_shorthand = true
+use_try_shorthand = true
+"""
+
+# ── Main ─────────────────────────────────────────────────────────────────
+
+app = typer.Typer(add_completion=False)
+
+
+@app.command()
+def main(
+    name: str = typer.Argument(help="Name of the new Rust project"),
+    path: Path = typer.Option(
+        Path.cwd(),
+        "--path",
+        "-p",
+        help="Parent directory where the project folder is created",
+    ),
+) -> None:
+    """Scaffold a new Rust project with strict lints and tooling configs."""
+    project_dir = path / name
+
+    # ── cargo init ───────────────────────────────────────────────────
+    console.print(f"[bold green]Creating[/] project [cyan]{name}[/] at [dim]{project_dir}[/]")
+    try:
+        subprocess.run(
+            ["cargo", "init", str(project_dir), "--name", name],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except FileNotFoundError:
+        console.print("[bold red]Error:[/] cargo not found. Install Rust via https://rustup.rs")
+        sys.exit(1)
+    except subprocess.CalledProcessError as exc:
+        console.print(f"[bold red]cargo init failed:[/]\n{exc.stderr}")
+        sys.exit(1)
+
+    # ── rust-toolchain.toml ──────────────────────────────────────────
+    (project_dir / "rust-toolchain.toml").write_text(RUST_TOOLCHAIN_TOML)
+    console.print("  [dim]wrote[/] rust-toolchain.toml")
+
+    # ── Append [lints] to Cargo.toml ─────────────────────────────────
+    cargo_toml = project_dir / "Cargo.toml"
+    with cargo_toml.open("a") as f:
+        f.write(CARGO_TOML_LINTS)
+    console.print("  [dim]appended[/] [lints] to Cargo.toml")
+
+    # ── .cargo/config.toml ───────────────────────────────────────────
+    cargo_config_dir = project_dir / ".cargo"
+    cargo_config_dir.mkdir(parents=True, exist_ok=True)
+    (cargo_config_dir / "config.toml").write_text(CARGO_CONFIG_TOML)
+    console.print("  [dim]wrote[/] .cargo/config.toml")
+
+    # ── deny.toml ────────────────────────────────────────────────────
+    (project_dir / "deny.toml").write_text(DENY_TOML)
+    console.print("  [dim]wrote[/] deny.toml")
+
+    # ── rustfmt.toml ─────────────────────────────────────────────────
+    (project_dir / "rustfmt.toml").write_text(RUSTFMT_TOML)
+    console.print("  [dim]wrote[/] rustfmt.toml")
+
+    console.print(f"\n[bold green]Done![/] cd {project_dir} && cargo check")
+
+
+if __name__ == "__main__":
+    app()

package/node_modules/@litcodex/lit-loop/skills/lit-code/scripts/typescript/check-no-excuse-rules.ts

@@ -0,0 +1,344 @@
+#!/usr/bin/env bun
+/**
+ * Check TypeScript files for no-excuse violations.
+ *
+ * Rules:
+ *   no-any-assertion       - `as any`
+ *   no-unknown-assertion    - `as unknown`
+ *   no-ts-ignore            - `@ts-expect-error` comments
+ *   no-ts-expect-error      - `@ts-expect-error` comments
+ *   no-enum                 - `enum` declarations
+ *   no-non-null-assertion   - `x!` postfix operator
+ *   no-throw-literal        - `throw "string"` / `throw 123`
+ *   no-mutable-export       - `export let` / `export var`
+ *   no-any-annotation       - `: any` in annotations (opt out: `// no-excuse-ok: any`)
+ *   no-explicit-any-return  - `(): any` return types (opt out: `// no-excuse-ok: any`)
+ *   empty-catch             - `catch { }` or `catch (e) { }` with empty body
+ *   catch-without-narrowing - catch block that uses error without instanceof narrowing
+ *
+ * Usage:
+ *   bun run scripts/check-no-excuse-rules.ts <file-or-dir>...
+ *
+ * Exit codes:
+ *   0 - no violations
+ *   1 - violations found
+ *   2 - input error
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import ts from "typescript";
+
+type RuleId =
+	| "no-any-assertion"
+	| "no-unknown-assertion"
+	| "no-ts-ignore"
+	| "no-ts-expect-error"
+	| "no-enum"
+	| "no-non-null-assertion"
+	| "no-throw-literal"
+	| "no-mutable-export"
+	| "no-any-annotation"
+	| "no-explicit-any-return"
+	| "empty-catch"
+	| "catch-without-narrowing";
+
+type Violation = {
+	readonly ruleId: RuleId;
+	readonly filePath: string;
+	readonly line: number;
+	readonly column: number;
+	readonly message: string;
+};
+
+const INCLUDED_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+const IGNORED_DIRECTORIES = new Set([
+	".git",
+	".next",
+	".nuxt",
+	".turbo",
+	".yarn",
+	"coverage",
+	"dist",
+	"build",
+	"node_modules",
+]);
+
+const OPT_OUT_RE = /\/\/\s*no-excuse-ok:\s*any/;
+const CATCH_OK_RE = /\/\/\s*no-excuse-ok:\s*catch/;
+
+function isIncludedFile(filePath: string): boolean {
+	return INCLUDED_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+function isDeclarationFile(filePath: string): boolean {
+	return filePath.endsWith(".d.ts") || filePath.endsWith(".d.mts") || filePath.endsWith(".d.cts");
+}
+
+function discoverFiles(inputs: string[]): string[] {
+	const files: string[] = [];
+	for (const input of inputs) {
+		const resolved = path.resolve(input);
+		if (!fs.existsSync(resolved)) {
+			console.error(`Path does not exist: ${resolved}`);
+			process.exit(2);
+		}
+		if (fs.statSync(resolved).isFile()) {
+			if (isIncludedFile(resolved) && !isDeclarationFile(resolved)) files.push(resolved);
+			continue;
+		}
+		const walk = (dir: string): void => {
+			for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+				if (entry.isDirectory()) {
+					if (!IGNORED_DIRECTORIES.has(entry.name)) walk(path.join(dir, entry.name));
+				} else if (isIncludedFile(entry.name) && !isDeclarationFile(entry.name)) {
+					files.push(path.join(dir, entry.name));
+				}
+			}
+		};
+		walk(resolved);
+	}
+	return files;
+}
+
+function getLineText(sourceFile: ts.SourceFile, line: number): string {
+	const lineStarts = sourceFile.getLineStarts();
+	const start = lineStarts[line];
+	const end = line + 1 < lineStarts.length ? lineStarts[line + 1] : sourceFile.getEnd();
+	return sourceFile.text.slice(start, end);
+}
+
+function analyzeFile(filePath: string): Violation[] {
+	const source = fs.readFileSync(filePath, "utf-8");
+	const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+	const violations: Violation[] = [];
+
+	function pos(node: ts.Node): { line: number; column: number } {
+		const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+		return { line: line + 1, column: character + 1 };
+	}
+
+	function lineHasOptOut(node: ts.Node): boolean {
+		const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+		return OPT_OUT_RE.test(getLineText(sourceFile, line));
+	}
+
+	function visit(node: ts.Node): void {
+		// ── as any / as unknown ──
+		if (ts.isAsExpression(node)) {
+			const typeText = node.type.getText(sourceFile);
+			if (typeText === "any") {
+				const p = pos(node);
+				violations.push({
+					ruleId: "no-any-assertion",
+					filePath,
+					...p,
+					message: "`as any` — narrow with type guards or redesign the types",
+				});
+			}
+			if (typeText === "unknown") {
+				const p = pos(node);
+				violations.push({
+					ruleId: "no-unknown-assertion",
+					filePath,
+					...p,
+					message: "`as unknown` — redesign the types",
+				});
+			}
+		}
+
+		// ── enum ──
+		if (ts.isEnumDeclaration(node)) {
+			const p = pos(node);
+			violations.push({
+				ruleId: "no-enum",
+				filePath,
+				...p,
+				message: "`enum` — use `as const` object + literal union type",
+			});
+		}
+
+		// ── x! non-null assertion ──
+		if (ts.isNonNullExpression(node)) {
+			const p = pos(node);
+			violations.push({
+				ruleId: "no-non-null-assertion",
+				filePath,
+				...p,
+				message: "`x!` — use narrowing or optional chaining",
+			});
+		}
+
+		// ── throw "literal" ──
+		if (ts.isThrowStatement(node) && node.expression) {
+			const expr = node.expression;
+			if (ts.isStringLiteral(expr) || ts.isNumericLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) {
+				const p = pos(node);
+				violations.push({
+					ruleId: "no-throw-literal",
+					filePath,
+					...p,
+					message: "`throw literal` — throw an Error subclass",
+				});
+			}
+			if (ts.isTemplateExpression(expr)) {
+				const p = pos(node);
+				violations.push({
+					ruleId: "no-throw-literal",
+					filePath,
+					...p,
+					message: "`throw template` — throw an Error subclass",
+				});
+			}
+		}
+
+		// ── export let / export var ──
+		if (ts.isVariableStatement(node)) {
+			const hasExport = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+			if (hasExport) {
+				const flags = node.declarationList.flags;
+				if (!(flags & ts.NodeFlags.Const)) {
+					const p = pos(node);
+					violations.push({
+						ruleId: "no-mutable-export",
+						filePath,
+						...p,
+						message: "`export let/var` — use `export const`",
+					});
+				}
+			}
+		}
+
+		// ── : any in annotations ──
+		if (ts.isTypeReferenceNode(node) || node.kind === ts.SyntaxKind.AnyKeyword) {
+			if (node.kind === ts.SyntaxKind.AnyKeyword && !lineHasOptOut(node)) {
+				const parent = node.parent;
+				// Skip `as any` — already caught by no-any-assertion
+				if (parent && ts.isAsExpression(parent)) {
+					// already handled
+				} else if (
+					parent &&
+					(ts.isParameter(parent) ||
+						ts.isVariableDeclaration(parent) ||
+						ts.isPropertyDeclaration(parent) ||
+						ts.isPropertySignature(parent))
+				) {
+					const p = pos(node);
+					violations.push({
+						ruleId: "no-any-annotation",
+						filePath,
+						...p,
+						message: "`: any` annotation — use `unknown` and narrow",
+					});
+				} else if (
+					parent &&
+					(ts.isFunctionDeclaration(parent) ||
+						ts.isMethodDeclaration(parent) ||
+						ts.isArrowFunction(parent) ||
+						ts.isFunctionExpression(parent))
+				) {
+					const p = pos(node);
+					violations.push({
+						ruleId: "no-explicit-any-return",
+						filePath,
+						...p,
+						message: "`(): any` return — use a specific type",
+					});
+				}
+			}
+		}
+
+		// ── empty catch / catch without narrowing ──
+		if (ts.isCatchClause(node)) {
+			const catchLine = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
+			const catchLineText = getLineText(sourceFile, catchLine);
+			if (!CATCH_OK_RE.test(catchLineText)) {
+				const body = node.block;
+				const stmts = body.statements;
+
+				if (stmts.length === 0) {
+					// Empty catch — swallows everything silently
+					const p = pos(node);
+					violations.push({
+						ruleId: "empty-catch",
+						filePath,
+						...p,
+						message: "empty `catch` block — handle, re-throw, or remove the try/catch",
+					});
+				} else if (node.variableDeclaration) {
+					// Has a bound variable — check if it's narrowed with instanceof
+					const varName = node.variableDeclaration.name.getText(sourceFile);
+					const blockText = body.getText(sourceFile);
+					const hasInstanceof = blockText.includes(`instanceof`);
+					const hasRethrow = blockText.includes(`throw ${varName}`) || blockText.includes(`throw new`);
+					if (!hasInstanceof && !hasRethrow) {
+						const p = pos(node);
+						violations.push({
+							ruleId: "catch-without-narrowing",
+							filePath,
+							...p,
+							message: "`catch` without `instanceof` narrowing or re-throw — narrow the error type or re-throw",
+						});
+					}
+				}
+			}
+		}
+
+		ts.forEachChild(node, visit);
+	}
+
+	visit(sourceFile);
+
+	// ── @ts-expect-error / @ts-expect-error in comments ──
+	const commentRanges = [...(ts.getLeadingCommentRanges(source, 0) ?? [])];
+	// Scan all comments via regex for reliability
+	const commentRegex = /\/\/\s*@ts-(ignore|expect-error)/g;
+	let match: RegExpExecArray | null;
+	while ((match = commentRegex.exec(source)) !== null) {
+		const { line, character } = sourceFile.getLineAndCharacterOfPosition(match.index);
+		const kind = match[1];
+		violations.push({
+			ruleId: kind === "ignore" ? "no-ts-ignore" : "no-ts-expect-error",
+			filePath,
+			line: line + 1,
+			column: character + 1,
+			message: `\`@ts-${kind}\` — fix the underlying type`,
+		});
+	}
+
+	return violations;
+}
+
+function formatViolation(v: Violation): string {
+	return `${v.filePath}:${v.line}:${v.column}: [${v.ruleId}] ${v.message}`;
+}
+
+function main(): void {
+	const args = process.argv.slice(2);
+	if (args.length === 0) {
+		console.error("usage: check-no-excuse-rules.ts <file-or-dir>...");
+		process.exit(2);
+	}
+
+	const files = discoverFiles(args);
+	if (files.length === 0) {
+		console.error("No TypeScript files found.");
+		process.exit(2);
+	}
+
+	const violations = files.flatMap((f) => analyzeFile(f));
+
+	if (violations.length === 0) {
+		console.log(`No violations in ${files.length} file(s).`);
+		return;
+	}
+
+	for (const v of violations) {
+		console.error(formatViolation(v));
+	}
+	console.error(`\n${violations.length} violation(s) in ${files.length} file(s).`);
+	process.exit(1);
+}
+
+main();