oh-my-opencode 4.5.1 → 4.5.12

package/packages/omo-codex/plugin/skills/programming/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/packages/omo-codex/plugin/skills/programming/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/packages/omo-codex/plugin/skills/programming/scripts/typescript/check-no-excuse-rules.ts

@@ -0,0 +1,282 @@
+#!/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-ignore` 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-ignore / @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()