feat: ✨ Multi-language support

.github/workflows/analyze.yml

@@ -0,0 +1,26 @@
+name: 'analyze'
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+jobs:
+  analyze:
+    runs-on: self-hosted
+    steps:
+      - name: 'Checkout sources'
+        uses: actions/checkout@v2
+      - name: 'Set up Python'
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.12
+      - name: 'Set up Poetry'
+        uses: snok/install-poetry@v1
+      - name: 'Install dependencies'
+        run: poetry install --no-interaction --no-root
+      - name: 'Checkout pl-snakebattle'
+        run: git clone https://github.com/getcodelimit/pl-battlesnake.git
+      - name: 'Run codelimit'
+        run: poetry run codelimit scan pl-battlesnake

.github/workflows/code-style.yml

@@ -0,0 +1,28 @@
+name: 'code-style'
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  code_style:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout sources'
+        uses: actions/checkout@v2
+      - name: 'Lint code with Ruff'
+        run: |
+          pip install ruff
+          ruff check --fix .
+      - name: 'Type cheking with MyPy'
+        run: |
+          pip install mypy
+          mypy --ignore-missing-imports codelimit/
+      - name: 'Format code with black'
+        run: |
+          pip install black
+          black .
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: 'Code style fixes'

.github/workflows/main.yml

@@ -10,7 +10,7 @@ jobs:
   ci:
     runs-on: ubuntu-latest
     steps:
-      - name: 'Checkout'
+      - name: 'Checkout sources'
         uses: actions/checkout@v2
       - name: 'Set up Python'
         uses: actions/setup-python@v2

.pre-commit-config.yaml

@@ -2,23 +2,6 @@ default_language_version:
   python: python3.11
 
 repos:
--   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-    - id: trailing-whitespace
--   repo: https://github.com/psf/black
-    rev: 23.7.0
-    hooks:
-    - id: black
--   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.283
-    hooks:
-    - id: ruff
-      args: [ --fix, --exit-non-zero-on-fix ]
--   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.4.1
-    hooks:
-    - id: mypy
 -   repo: https://github.com/getcodelimit/codelimit
     rev: v0.7.0
     hooks:

codelimit/__main__.py

@@ -1,55 +1,36 @@
-import os
-import sys
 from pathlib import Path
 from typing import List, Annotated, Optional
 
 import typer
+from click import Context
 from rich import print
+from typer.core import TyperGroup
 
-from codelimit.commands import github
-from codelimit.common.CheckResult import CheckResult
+from codelimit.commands import app
+from codelimit.commands.check import check_command
+from codelimit.commands.report import report_command
+from codelimit.commands.scan import scan_command
 from codelimit.common.Configuration import Configuration
-from codelimit.common.Scanner import scan_codebase, is_excluded
-from codelimit.common.report.Report import Report
-from codelimit.common.report.ReportReader import ReportReader
-from codelimit.common.report.ReportWriter import ReportWriter
-from codelimit.github_auth import get_github_token
-from codelimit.tui.CodeLimitApp import CodeLimitApp
-from codelimit.utils import upload_report, check_file, read_cached_report
+from codelimit.version import version
 
-cli = typer.Typer(no_args_is_help=True, add_completion=False)
-cli.add_typer(github.app, name="github", help="GitHub commands")
+
+class OrderCommands(TyperGroup):
+    def list_commands(self, ctx: Context):
+        return list(self.commands)
+
+
+cli = typer.Typer(cls=OrderCommands, no_args_is_help=True, add_completion=False)
+cli.add_typer(app.app, name="app", help="Code Limit GitHub App commands")
 
 
 @cli.command(help="Check file(s)")
 def check(
     paths: Annotated[List[Path], typer.Argument(exists=True)],
     quiet: Annotated[
-        bool, typer.Option("--quiet", help="Not output when successful")
+        bool, typer.Option("--quiet", help="No output when successful")
     ] = False,
 ):
-    check_result = CheckResult()
-    for path in paths:
-        if path.is_file():
-            check_file(path, check_result)
-        elif path.is_dir():
-            for root, dirs, files in os.walk(path.absolute()):
-                files = [f for f in files if not f[0] == "."]
-                dirs[:] = [d for d in dirs if not d[0] == "."]
-                for file in files:
-                    abs_path = Path(os.path.join(root, file))
-                    rel_path = abs_path.relative_to(path.absolute())
-                    if is_excluded(rel_path):
-                        continue
-                    check_file(abs_path, check_result)
-    exit_code = 1 if check_result.unmaintainable > 0 else 0
-    if (
-        not quiet
-        or check_result.hard_to_maintain > 0
-        or check_result.unmaintainable > 0
-    ):
-        check_result.report()
-    raise typer.Exit(code=exit_code)
+    check_command(paths, quiet)
 
 
 @cli.command(help="Scan a codebase")
@@ -58,83 +39,45 @@ def scan(
         Path, typer.Argument(exists=True, file_okay=False, help="Codebase root")
     ]
 ):
-    cache_dir = path.joinpath(".codelimit_cache").resolve()
-    report_path = cache_dir.joinpath("codelimit.json").resolve()
-    if report_path.exists():
-        cached_report = ReportReader.from_json(report_path.read_text())
-    else:
-        cached_report = None
-    codebase = scan_codebase(path, cached_report)
-    codebase.aggregate()
-    report = Report(codebase)
-    if not cache_dir.exists():
-        cache_dir.mkdir()
-        cache_dir_tag = cache_dir.joinpath("CACHEDIR.TAG").resolve()
-        cache_dir_tag.write_text("Signature: 8a477f597d28d172789f06886806bc55")
-        cache_dir_gitignore = cache_dir.joinpath(".gitignore").resolve()
-        cache_dir_gitignore.write_text("# Created by codelimit automatically.\n*\n")
-    report_path.write_text(ReportWriter(report).to_json())
-    if sys.stdout.isatty():
-        app = CodeLimitApp(report)
-        app.run()
-
-
-@cli.command(help="Upload report to Code Limit")
-def upload(
-    repository: Annotated[
-        str,
-        typer.Argument(
-            envvar="GITHUB_REPOSITORY", show_default=False, help="GitHub repository"
-        ),
-    ],
-    branch: Annotated[
-        str,
-        typer.Argument(envvar="GITHUB_REF", show_default=False, help="GitHub branch"),
+    scan_command(path)
+
+
+@cli.command(help="Show report for codebase")
+def report(
+    path: Annotated[
+        Path, typer.Argument(exists=True, file_okay=False, help="Codebase root")
     ],
-    report_file: Path = typer.Option(
-        None,
-        "--report",
-        exists=True,
-        dir_okay=False,
-        file_okay=True,
-        help="JSON report file",
-    ),
-    token: str = typer.Option(None, "--token", help="GitHub access token"),
-    url: str = typer.Option(
-        "https://codelimit.vercel.app/api/upload",
-        "--url",
-        help="Upload JSON report to this URL.",
-    ),
+    full: Annotated[bool, typer.Option("--full", help="Show full report")] = False,
 ):
-    if report_file:
-        report = ReportReader.from_json(report_file.read_text())
-    else:
-        cached_report = read_cached_report(Path("."))
-        if not cached_report:
-            print("[red]No cached report found in current folder[/red]")
-            raise typer.Exit(code=1)
-        else:
-            report = cached_report
-    if not token:
-        token = get_github_token()
-        if not token:
-            print("[red]Invalid or no credentials, please login or supply token[/red]")
-            raise typer.Exit(code=1)
-    try:
-        upload_report(report, repository, branch, url, token)
-        raise typer.Exit(code=0)
-    except FileNotFoundError as error:
-        typer.secho(f"File not found: {error}", fg="red")
-    raise typer.Exit(code=1) from None
+    report_command(path, full)
+
+
+def _version_callback(show: bool):
+    if show:
+        print(f"Code Limit version: {version}")
+        raise typer.Exit()
 
 
 @cli.callback()
 def main(
+    verbose: Annotated[
+        Optional[bool], typer.Option("--verbose", "-v", help="Verbose output")
+    ] = False,
     exclude: Annotated[
         Optional[list[str]], typer.Option(help="Glob patterns for exclusion")
-    ] = None
+    ] = None,
+    version: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--version", "-V", help="Show version", callback=_version_callback
+        ),
+    ] = None,
 ):
     """CodeLimit: Your refactoring alarm."""
+    if verbose:
+        Configuration.verbose = True
+    if version:
+        raise typer.Exit()
     if exclude:
         Configuration.excludes.extend(exclude)
 

codelimit/commands/app.py

@@ -0,0 +1,56 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich import print
+
+from codelimit.commands.upload import upload_command
+from codelimit.github_auth import device_flow_logout, device_flow_login
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command(help="Login to GitHub App")
+def login():
+    if device_flow_login():
+        print("[green]Logged in successfully[/green]")
+        typer.Exit(code=0)
+    else:
+        print("[red]Login failed[/red]")
+        typer.Exit(code=1)
+
+
+@app.command(help="Logout from GitHub App")
+def logout():
+    device_flow_logout()
+    print("Logged out")
+
+
+@app.command(help="Upload report to Code Limit GitHub App")
+def upload(
+    repository: Annotated[
+        str,
+        typer.Argument(
+            envvar="GITHUB_REPOSITORY", show_default=False, help="GitHub repository"
+        ),
+    ],
+    branch: Annotated[
+        str,
+        typer.Argument(envvar="GITHUB_REF", show_default=False, help="GitHub branch"),
+    ],
+    report_file: Path = typer.Option(
+        None,
+        "--report",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="JSON report file",
+    ),
+    token: str = typer.Option(None, "--token", help="GitHub access token"),
+    url: str = typer.Option(
+        "https://codelimit.vercel.app/api/upload",
+        "--url",
+        help="Upload JSON report to this URL.",
+    ),
+):
+    upload_command(repository, branch, report_file, token, url)

codelimit/commands/check.py

@@ -0,0 +1,54 @@
+import os
+from pathlib import Path
+
+import typer
+from pygments.lexers import get_lexer_for_filename
+
+from codelimit.common.CheckResult import CheckResult
+from codelimit.common.Scanner import is_excluded, scan_file
+from codelimit.common.lexer_utils import lex
+from codelimit.common.utils import load_language_by_name
+from codelimit.languages import LanguageName
+
+
+def check_command(paths: list[Path], quiet: bool):
+    check_result = CheckResult()
+    for path in paths:
+        if path.is_file():
+            check_file(path, check_result)
+        elif path.is_dir():
+            for root, dirs, files in os.walk(path.absolute()):
+                files = [f for f in files if not f[0] == "."]
+                dirs[:] = [d for d in dirs if not d[0] == "."]
+                for file in files:
+                    abs_path = Path(os.path.join(root, file))
+                    rel_path = abs_path.relative_to(path.absolute())
+                    if is_excluded(rel_path):
+                        continue
+                    check_file(abs_path, check_result)
+    exit_code = 1 if check_result.unmaintainable > 0 else 0
+    if (
+        not quiet
+        or check_result.hard_to_maintain > 0
+        or check_result.unmaintainable > 0
+    ):
+        check_result.report()
+    raise typer.Exit(code=exit_code)
+
+
+def check_file(path: Path, check_result: CheckResult):
+    lexer = get_lexer_for_filename(path)
+    language = lexer.__class__.name
+    if language in LanguageName:
+        with open(path) as f:
+            code = f.read()
+        tokens = lex(lexer, code, False)
+        language = load_language_by_name(lexer.__class__.name)
+        if language:
+            measurements = scan_file(tokens, language)
+            risks = sorted(
+                [m for m in measurements if m.value > 30],
+                key=lambda measurement: measurement.value,
+                reverse=True,
+            )
+            check_result.add(path, risks)