ghlang 2.2.0__py3-none-any.whl

ghlang/__init__.py

@@ -0,0 +1,3 @@
+"""Language statistics analyzer for GitHub repositories and local files"""
+
+__version__ = "2.2.0"

ghlang/cli/__init__.py

@@ -0,0 +1,35 @@
+import typer
+
+from ghlang import __version__
+from ghlang.cli.config import config
+from ghlang.cli.github import github
+from ghlang.cli.local import local
+
+
+app = typer.Typer(help="See what languages you've been coding in", add_completion=True)
+app.command()(config)
+app.command()(github)
+app.command()(local)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"ghlang v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Show version and exit",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    pass
+
+
+if __name__ == "__main__":
+    app()

ghlang/cli/config.py

@@ -0,0 +1,154 @@
+import os
+from pathlib import Path
+import platform
+import subprocess
+
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.table import Table
+import typer
+
+from ghlang.config import create_default_config
+from ghlang.config import get_config_path
+from ghlang.config import load_config
+
+
+def _open_in_editor(path: Path) -> None:
+    """Open file in default editor"""
+    editor = os.environ.get("EDITOR")
+
+    if editor:
+        subprocess.run([editor, str(path)], check=False)
+    elif platform.system() == "Darwin":
+        subprocess.run(["open", str(path)], check=False)
+    elif platform.system() == "Windows":
+        os.startfile(str(path))  # type: ignore[attr-defined]
+    else:
+        subprocess.run(["xdg-open", str(path)], check=False)
+
+
+def _format_value(value: object) -> str:
+    """Format a config value for display"""
+    if isinstance(value, bool):
+        return "[green]true[/green]" if value else "[red]false[/red]"
+
+    if isinstance(value, list):
+        if not value:
+            return "[dim][][/dim]"
+
+        return ", ".join(str(v) for v in value)
+
+    if isinstance(value, Path):
+        return str(value)
+
+    return str(value)
+
+
+def _print_config_table(config_path: Path) -> None:
+    """Print config as a formatted table"""
+    console = Console()
+
+    try:
+        cfg = load_config(config_path=config_path, require_token=False)
+
+    except Exception as e:
+        console.print(f"[red]Error loading config:[/red] {e}")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]Config:[/bold] {config_path}\n")
+
+    # GitHub section
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+
+    console.print("[bold yellow]GitHub[/bold yellow]")
+    table.add_row("token", cfg.token if cfg.token else "[dim]not set[/dim]")
+    table.add_row("affiliation", cfg.affiliation)
+    table.add_row("visibility", cfg.visibility)
+    table.add_row("ignored_repos", _format_value(cfg.ignored_repos))
+    console.print(table)
+    console.print()
+
+    # Cloc section
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+
+    console.print("[bold yellow]Cloc[/bold yellow]")
+    table.add_row("ignored_dirs", _format_value(cfg.ignored_dirs))
+    console.print(table)
+    console.print()
+
+    # Output section
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+
+    console.print("[bold yellow]Output[/bold yellow]")
+    table.add_row("directory", str(cfg.output_dir))
+    table.add_row("save_json", _format_value(cfg.save_json))
+    table.add_row("save_repos", _format_value(cfg.save_repos))
+    table.add_row("top_n_languages", str(cfg.top_n_languages))
+    console.print(table)
+    console.print()
+
+    # Preferences section
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+
+    console.print("[bold yellow]Preferences[/bold yellow]")
+    table.add_row("verbose", _format_value(cfg.verbose))
+    table.add_row("theme", cfg.theme)
+    console.print(table)
+    console.print()
+
+
+def config(
+    show: bool = typer.Option(
+        False,
+        "--show",
+        help="Print config as formatted table",
+    ),
+    path: bool = typer.Option(
+        False,
+        "--path",
+        help="Print config file path",
+    ),
+    raw: bool = typer.Option(
+        False,
+        "--raw",
+        help="Print raw config file contents",
+    ),
+) -> None:
+    """Manage config file"""
+    config_path = get_config_path()
+
+    if path:
+        print(config_path)
+        return
+
+    if raw:
+        if not config_path.exists():
+            typer.echo(f"Config file doesn't exist yet: {config_path}")
+            raise typer.Exit(1)
+
+        console = Console()
+        syntax = Syntax(config_path.read_text(), "toml", theme="ansi_dark", line_numbers=True)
+        console.print(syntax)
+        return
+
+    if show:
+        if not config_path.exists():
+            typer.echo(f"Config file doesn't exist yet: {config_path}")
+            raise typer.Exit(1)
+
+        _print_config_table(config_path)
+        return
+
+    if not config_path.exists():
+        create_default_config(config_path)
+        typer.echo(f"Created config at {config_path}")
+
+    _open_in_editor(config_path)

ghlang/cli/github.py

@@ -0,0 +1,147 @@
+import json
+from pathlib import Path
+
+import typer
+
+from ghlang.cli.utils import generate_charts
+from ghlang.config import load_config
+from ghlang.exceptions import ConfigError
+from ghlang.github_client import GitHubClient
+from ghlang.logging import logger
+
+
+def github(
+    config_path: Path | None = typer.Option(
+        None,
+        "--config",
+        help="Use a different config file",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        readable=True,
+        path_type=Path,
+    ),
+    output_dir: Path | None = typer.Option(
+        None,
+        "--output-dir",
+        help="Where to save the charts",
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        path_type=Path,
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Custom output path/filename",
+        path_type=Path,
+    ),
+    title: str | None = typer.Option(
+        None,
+        "--title",
+        "-t",
+        help="Custom chart title",
+    ),
+    top_n: int | None = typer.Option(
+        None,
+        "--top-n",
+        help="How many languages to show in the bar chart",
+    ),
+    json_only: bool = typer.Option(
+        False,
+        "--json-only",
+        help="Output JSON only, skip chart generation",
+    ),
+    stdout: bool = typer.Option(
+        False,
+        "--stdout",
+        help="Output stats to stdout instead of files (implies --json-only --quiet)",
+    ),
+    quiet: bool = typer.Option(
+        False,
+        "--quiet",
+        "-q",
+        help="Suppress log output (only show errors)",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show more details",
+    ),
+    theme: str | None = typer.Option(
+        None,
+        "--theme",
+        help="Chart theme (default: light)",
+    ),
+    fmt: str | None = typer.Option(
+        None,
+        "--format",
+        "-f",
+        help="Output format, overrides --output extension (png or svg)",
+    ),
+) -> None:
+    """Analyze your GitHub repos"""
+    if stdout:
+        quiet = True
+        json_only = True
+
+    logger.configure(verbose, quiet=quiet)
+
+    try:
+        cli_overrides = {
+            "output_dir": output_dir,
+            "top_n_languages": top_n,
+            "verbose": verbose or None,
+            "theme": theme,
+        }
+        cfg = load_config(config_path=config_path, cli_overrides=cli_overrides, require_token=True)
+
+    except ConfigError as e:
+        logger.error(str(e))
+        raise typer.Exit(1)
+
+    if not stdout:
+        cfg.output_dir.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Saving to {cfg.output_dir}")
+
+    try:
+        client = GitHubClient(
+            token=cfg.token,
+            affiliation=cfg.affiliation,
+            visibility=cfg.visibility,
+            ignored_repos=cfg.ignored_repos,
+        )
+
+        language_stats = client.get_all_language_stats(
+            repos_output=(
+                cfg.output_dir / "repositories.json" if cfg.save_repos and not stdout else None
+            ),
+            stats_output=(
+                cfg.output_dir / "language_stats.json" if cfg.save_json and not stdout else None
+            ),
+        )
+
+        if not language_stats:
+            logger.error("No language statistics found, nothing to visualize")
+            raise typer.Exit(1)
+
+        if stdout:
+            print(json.dumps(language_stats, indent=2))
+        elif json_only:
+            stats_file = cfg.output_dir / "language_stats.json"
+
+            with stats_file.open("w") as f:
+                json.dump(language_stats, f, indent=2)
+
+            logger.success(f"Saved stats to {stats_file}")
+        else:
+            chart_title = title if title else "GitHub Language Stats"
+            generate_charts(language_stats, cfg, title=chart_title, output=output, fmt=fmt)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.exception(f"Something went wrong: {e}")
+        raise typer.Exit(1)

ghlang/cli/local.py

@@ -0,0 +1,183 @@
+import json
+from pathlib import Path
+import sys
+
+import typer
+
+from ghlang.cli.utils import generate_charts
+from ghlang.cloc_client import ClocClient
+from ghlang.config import load_config
+from ghlang.exceptions import ClocNotFoundError
+from ghlang.exceptions import ConfigError
+from ghlang.logging import logger
+from ghlang.visualizers import normalize_language_stats
+
+
+def local(
+    path: Path = typer.Argument(
+        ".",
+        exists=True,
+        file_okay=True,
+        dir_okay=True,
+        readable=True,
+        path_type=Path,
+    ),
+    config_path: Path | None = typer.Option(
+        None,
+        "--config",
+        help="Use a different config file",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        readable=True,
+        path_type=Path,
+    ),
+    output_dir: Path | None = typer.Option(
+        None,
+        "--output-dir",
+        help="Where to save the charts",
+        file_okay=False,
+        dir_okay=True,
+        writable=True,
+        path_type=Path,
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Custom output path/filename",
+        path_type=Path,
+    ),
+    title: str | None = typer.Option(
+        None,
+        "--title",
+        "-t",
+        help="Custom chart title",
+    ),
+    top_n: int | None = typer.Option(
+        None,
+        "--top-n",
+        help="How many languages to show in the bar chart",
+    ),
+    json_only: bool = typer.Option(
+        False,
+        "--json-only",
+        help="Output JSON only, skip chart generation",
+    ),
+    stdout: bool = typer.Option(
+        False,
+        "--stdout",
+        help="Output stats to stdout instead of files (implies --json-only --quiet)",
+    ),
+    quiet: bool = typer.Option(
+        False,
+        "--quiet",
+        "-q",
+        help="Suppress log output (only show errors)",
+    ),
+    verbose: bool = typer.Option(
+        False,
+        "--verbose",
+        "-v",
+        help="Show more details",
+    ),
+    follow_links: bool = typer.Option(
+        False,
+        "--follow-links",
+        help="Follow symlinks when analyzing (unix only)",
+    ),
+    theme: str | None = typer.Option(
+        None,
+        "--theme",
+        help="Chart theme (default: light)",
+    ),
+    fmt: str | None = typer.Option(
+        None,
+        "--format",
+        "-f",
+        help="Output format, overrides --output extension (png or svg)",
+    ),
+) -> None:
+    """Analyze local files with cloc"""
+    if stdout:
+        quiet = True
+        json_only = True
+
+    logger.configure(verbose, quiet=quiet)
+
+    try:
+        cli_overrides = {
+            "output_dir": output_dir,
+            "top_n_languages": top_n,
+            "verbose": verbose or None,
+            "theme": theme,
+        }
+        cfg = load_config(config_path=config_path, cli_overrides=cli_overrides, require_token=False)
+
+    except ConfigError as e:
+        logger.error(str(e))
+        raise typer.Exit(1)
+
+    if follow_links and sys.platform == "win32":
+        logger.warning("--follow-links is not supported on Windows, ignoring")
+        follow_links = False
+
+    try:
+        cloc = ClocClient(ignored_dirs=cfg.ignored_dirs, follow_links=follow_links)
+
+    except ClocNotFoundError as e:
+        logger.error(str(e))
+        raise typer.Exit(1)
+
+    if not stdout:
+        cfg.output_dir.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Saving to {cfg.output_dir}")
+
+    try:
+        detailed_stats = cloc.get_language_stats(
+            path,
+            stats_output=(
+                cfg.output_dir / "cloc_stats.json" if cfg.save_json and not stdout else None
+            ),
+        )
+        raw_stats = {
+            lang: data["code"]
+            for lang, data in detailed_stats.items()
+            if lang != "_summary" and data["code"] > 0
+        }
+        language_stats = normalize_language_stats(raw_stats)
+
+        if not language_stats:
+            logger.error("No code found to analyze, nothing to visualize")
+            raise typer.Exit(1)
+
+        if stdout:
+            print(json.dumps(language_stats, indent=2))
+        elif json_only:
+            stats_file = cfg.output_dir / "language_stats.json"
+
+            with stats_file.open("w") as f:
+                json.dump(language_stats, f, indent=2)
+
+            logger.success(f"Saved stats to {stats_file}")
+        else:
+            if title:
+                chart_title = title
+            else:
+                resolved = path.expanduser().resolve()
+                chart_title = f"Local: {resolved.name}"
+
+            generate_charts(
+                language_stats,
+                cfg,
+                colors_required=False,
+                title=chart_title,
+                output=output,
+                fmt=fmt,
+            )
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        logger.exception(f"Something went wrong: {e}")
+        raise typer.Exit(1)

ghlang/cli/utils.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+
+from ghlang.logging import logger
+from ghlang.visualizers import generate_bar
+from ghlang.visualizers import generate_pie
+from ghlang.visualizers import load_github_colors
+
+
+if TYPE_CHECKING:
+    from ghlang.config import Config
+
+
+def generate_charts(
+    language_stats: dict[str, int],
+    cfg: "Config",
+    colors_required: bool = True,
+    title: str | None = None,
+    output: Path | None = None,
+    fmt: str | None = None,
+) -> None:
+    """Load colors and generate pie/bar charts with progress"""
+    with logger.progress() as progress:
+        task = progress.add_task("Generating charts", total=3)
+
+        progress.update(task, description="Loading language colors...")
+        colors_file = cfg.output_dir / "github_colors.json" if cfg.save_json else None
+        colors = load_github_colors(output_file=colors_file)
+        progress.advance(task)
+
+        if not colors:
+            if colors_required:
+                logger.error("Couldn't load GitHub colors, can't continue without them")
+                raise typer.Exit(1)
+
+            logger.warning("Couldn't load GitHub colors, charts will be gray")
+            colors = {}
+
+        # determine output format
+        # priority: --format > --output suffix > default png
+        if fmt:
+            if fmt not in ("png", "svg"):
+                logger.warning(f"We only support png and svg, not '{fmt}', using png instead")
+                suffix = ".png"
+            else:
+                suffix = f".{fmt}"
+        elif output and output.suffix:
+            suffix = output.suffix
+        else:
+            suffix = ".png"
+
+        if output:
+            if output.is_absolute():
+                parent = output.parent
+            elif str(output.parent) != ".":
+                parent = cfg.output_dir / output.parent
+            else:
+                parent = cfg.output_dir
+
+            stem = output.stem
+            pie_output = parent / f"{stem}_pie{suffix}"
+            bar_output = parent / f"{stem}_bar{suffix}"
+        else:
+            pie_output = cfg.output_dir / f"language_pie{suffix}"
+            bar_output = cfg.output_dir / f"language_bar{suffix}"
+
+        progress.update(task, description="Generating pie chart...")
+        generate_pie(language_stats, colors, pie_output, title=title, theme=cfg.theme)
+        progress.advance(task)
+
+        progress.update(task, description="Generating bar chart...")
+        generate_bar(
+            language_stats,
+            colors,
+            bar_output,
+            top_n=cfg.top_n_languages,
+            title=title,
+            theme=cfg.theme,
+        )
+        progress.advance(task)