github-traffic-tracker 0.2.8a0__py3-none-any.whl

ghtraf/config.py

@@ -0,0 +1,182 @@
+"""Configuration management for ghtraf.
+
+Three-layer config resolution (highest priority wins):
+  1. CLI flags — explicit on the command line
+  2. Project config — .ghtraf.json in the repo directory
+  3. Global config — ~/.ghtraf/config.json
+
+This means once you run `ghtraf create --owner myorg --repo myproject`,
+the project config remembers it. Future commands need zero flags.
+"""
+
+import json
+import os
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# Config file locations
+# ---------------------------------------------------------------------------
+def get_global_config_dir():
+    """Return the global config directory (~/.ghtraf/)."""
+    return Path.home() / ".ghtraf"
+
+
+def get_global_config_path():
+    """Return path to the global config file."""
+    return get_global_config_dir() / "config.json"
+
+
+def find_project_config(start_dir=None):
+    """Walk up from start_dir looking for .ghtraf.json.
+
+    Returns the path if found, None otherwise.
+    """
+    current = Path(start_dir or os.getcwd()).resolve()
+    for _ in range(20):  # safety limit
+        candidate = current / ".ghtraf.json"
+        if candidate.is_file():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Config loading
+# ---------------------------------------------------------------------------
+def load_json(path):
+    """Load a JSON file, returning empty dict on error."""
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def load_global_config():
+    """Load the global config file."""
+    return load_json(get_global_config_path())
+
+
+def load_project_config(start_dir=None):
+    """Load the nearest .ghtraf.json walking upward from start_dir."""
+    path = find_project_config(start_dir)
+    if path:
+        return load_json(path), path
+    return {}, None
+
+
+# ---------------------------------------------------------------------------
+# Config resolution
+# ---------------------------------------------------------------------------
+def resolve_config(args, keys=None):
+    """Resolve config values using three-layer precedence.
+
+    For each key in `keys`, checks (in order):
+      1. CLI args (from argparse namespace)
+      2. Project .ghtraf.json
+      3. Global ~/.ghtraf/config.json
+
+    Returns a dict with resolved values.
+    """
+    if keys is None:
+        keys = ["owner", "repo", "repo_dir"]
+
+    project_cfg, _ = load_project_config(
+        getattr(args, "repo_dir", None)
+    )
+    global_cfg = load_global_config()
+
+    # If global config tracks repos, find matching repo config
+    repo_key = None
+    if hasattr(args, "owner") and hasattr(args, "repo"):
+        cli_owner = getattr(args, "owner", None)
+        cli_repo = getattr(args, "repo", None)
+        if cli_owner and cli_repo:
+            repo_key = f"{cli_owner}/{cli_repo}"
+    global_repo_cfg = {}
+    if repo_key:
+        global_repo_cfg = global_cfg.get("repos", {}).get(repo_key, {})
+
+    resolved = {}
+    for key in keys:
+        # Normalize key: argparse uses underscores, JSON may use either
+        arg_key = key.replace("-", "_")
+        json_key = key.replace("_", "-") if "_" in key else key
+        alt_json_key = key.replace("-", "_") if "-" in key else key
+
+        # Layer 1: CLI
+        cli_val = getattr(args, arg_key, None)
+        if cli_val is not None:
+            resolved[arg_key] = cli_val
+            continue
+
+        # Layer 2: Project config
+        proj_val = project_cfg.get(json_key) or project_cfg.get(alt_json_key)
+        if proj_val is not None:
+            resolved[arg_key] = proj_val
+            continue
+
+        # Layer 3: Global config (repo-specific section)
+        global_val = (global_repo_cfg.get(json_key)
+                      or global_repo_cfg.get(alt_json_key))
+        if global_val is not None:
+            resolved[arg_key] = global_val
+            continue
+
+        resolved[arg_key] = None
+
+    return resolved
+
+
+# ---------------------------------------------------------------------------
+# Config writing
+# ---------------------------------------------------------------------------
+def save_project_config(data, repo_dir=None):
+    """Write .ghtraf.json to the repo directory."""
+    target = Path(repo_dir or os.getcwd()) / ".ghtraf.json"
+    with open(target, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    return target
+
+
+def save_global_config(data):
+    """Write the global config file."""
+    config_dir = get_global_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_path = get_global_config_path()
+    with open(config_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    return config_path
+
+
+def register_repo_globally(owner, repo, badge_gist_id=None,
+                           archive_gist_id=None, repo_dir=None,
+                           display_name=None, created=None):
+    """Add or update a repo entry in the global config."""
+    config = load_global_config()
+    config.setdefault("version", 1)
+    config.setdefault("repos", {})
+
+    repo_key = f"{owner}/{repo}"
+    entry = config["repos"].get(repo_key, {})
+
+    if badge_gist_id:
+        entry["badge_gist_id"] = badge_gist_id
+    if archive_gist_id:
+        entry["archive_gist_id"] = archive_gist_id
+    if repo_dir:
+        entry["repo_dir"] = str(repo_dir)
+    if display_name:
+        entry["display_name"] = display_name
+    if created:
+        entry["created"] = created
+
+    config["repos"][repo_key] = entry
+    save_global_config(config)
+    return config

ghtraf/configure.py

@@ -0,0 +1,215 @@
+"""File configuration for ghtraf.
+
+Handles updating dashboard HTML, README, and workflow YAML files
+with project-specific values via regex replacement.
+"""
+
+import json
+import re
+from pathlib import Path
+
+from ghtraf.output import print_dry, print_ok, print_skip, print_warn
+
+
+def apply_replacements(filepath, replacements, config, dry_run=False):
+    """Apply a list of (pattern, template, description) replacements to a file.
+
+    Args:
+        filepath: Path to the file to modify.
+        replacements: List of (regex_pattern, format_template, description) tuples.
+        config: Dict of values to substitute into templates.
+        dry_run: If True, only print what would happen.
+
+    Returns:
+        Count of successful replacements.
+    """
+    filepath = Path(filepath)
+    if not filepath.exists():
+        print_warn(f"File not found: {filepath}")
+        return 0
+
+    content = filepath.read_text(encoding="utf-8")
+    original = content
+    success = 0
+
+    for pattern, template, desc in replacements:
+        formatted = template.format(**config)
+        new_content, count = re.subn(pattern, formatted, content, count=1)
+        if count > 0:
+            content = new_content
+            success += 1
+            if dry_run:
+                print_dry(f"{desc}")
+            else:
+                print_ok(f"{desc}")
+        else:
+            print_skip(f"{desc} (pattern not found)")
+
+    if not dry_run and content != original:
+        filepath.write_text(content, encoding="utf-8")
+
+    return success
+
+
+def configure_dashboard(config, dashboard_path, dry_run=False):
+    """Update the dashboard HTML file with project-specific values.
+
+    Args:
+        config: Dict with owner, repo, display_name_html, gh_username,
+                badge_gist_id, archive_gist_id, created.
+        dashboard_path: Path to docs/stats/index.html.
+        dry_run: If True, only print what would happen.
+
+    Returns:
+        Count of successful replacements.
+    """
+    print(f"  Updating {dashboard_path}...")
+
+    replacements = [
+        # HTML title
+        (r'<title>.*?- Project Statistics</title>',
+         '<title>{display_name_html} - Project Statistics</title>',
+         "HTML title"),
+        # Banner link href
+        (r'href="https://github\.com/[^"]+?" class="banner-link"',
+         'href="https://github.com/{owner}/{repo}" class="banner-link"',
+         "Banner link URL"),
+        # Banner title text
+        (r'<p class="banner-title">.*?</p>',
+         '<p class="banner-title">{display_name_html}</p>',
+         "Banner title"),
+        # Footer repository link
+        (r'<a href="https://github\.com/[^"]+?">Repository</a>',
+         '<a href="https://github.com/{owner}/{repo}">Repository</a>',
+         "Footer repo link"),
+        # Footer releases link
+        (r'<a href="https://github\.com/[^"]+?/releases">Releases</a>',
+         '<a href="https://github.com/{owner}/{repo}/releases">Releases</a>',
+         "Footer releases link"),
+        # JS config: GIST_RAW_BASE
+        (r"const GIST_RAW_BASE = '[^']+';",
+         "const GIST_RAW_BASE = 'https://gist.githubusercontent.com/"
+         "{gh_username}/{badge_gist_id}/raw';",
+         "Gist raw base URL"),
+        # JS config: ARCHIVE_GIST_ID
+        (r"const ARCHIVE_GIST_ID = '[^']+';",
+         "const ARCHIVE_GIST_ID = '{archive_gist_id}';",
+         "Archive gist ID"),
+        # JS config: REPO_OWNER
+        (r"const REPO_OWNER = '[^']+';",
+         "const REPO_OWNER = '{owner}';",
+         "Repo owner"),
+        # JS config: REPO_NAME
+        (r"const REPO_NAME = '[^']+';",
+         "const REPO_NAME = '{repo}';",
+         "Repo name"),
+        # JS config: REPO_CREATED
+        (r"const REPO_CREATED = '[^']+';",
+         "const REPO_CREATED = '{created}';",
+         "Repo creation date"),
+    ]
+
+    return apply_replacements(dashboard_path, replacements, config, dry_run)
+
+
+def configure_readme(config, readme_path, dry_run=False):
+    """Update the dashboard README.md with project-specific values.
+
+    Args:
+        config: Dict with owner, repo, display_name, gh_username,
+                badge_gist_id.
+        readme_path: Path to docs/stats/README.md.
+        dry_run: If True, only print what would happen.
+
+    Returns:
+        Count of successful replacements.
+    """
+    print(f"  Updating {readme_path}...")
+
+    config = dict(config)  # copy to avoid mutating caller's dict
+    config["owner_lower"] = config["owner"].lower()
+
+    replacements = [
+        # Project name and link
+        (r'\[.*?\]\(https://github\.com/[^)]+\)\.',
+         '[{display_name}](https://github.com/{owner}/{repo}).',
+         "Project link"),
+        # Badge gist link
+        (r'\[Badge Gist\]\(https://gist\.github\.com/[^)]+\)',
+         '[Badge Gist](https://gist.github.com/{gh_username}/{badge_gist_id})',
+         "Badge gist link"),
+        # Dashboard URL
+        (r'\*\*https://[^*]+/stats/\*\*',
+         '**https://{owner_lower}.github.io/{repo}/stats/**',
+         "Dashboard URL"),
+    ]
+
+    return apply_replacements(readme_path, replacements, config, dry_run)
+
+
+def configure_workflow(config, workflow_path, dry_run=False):
+    """Update the traffic-badges.yml workflow.
+
+    Args:
+        config: Dict with optional 'ci_workflows' list.
+        workflow_path: Path to .github/workflows/traffic-badges.yml.
+        dry_run: If True, only print what would happen.
+
+    Returns:
+        Count of changes made.
+    """
+    print(f"  Updating {workflow_path}...")
+
+    workflow_path = Path(workflow_path)
+    if not workflow_path.exists():
+        print_warn(f"File not found: {workflow_path}")
+        return 0
+
+    content = workflow_path.read_text(encoding="utf-8")
+    original = content
+    changes = 0
+
+    # Handle workflow_run trigger
+    if config.get("ci_workflows"):
+        names = json.dumps(config["ci_workflows"])
+        new_content = re.sub(
+            r'workflows: \[.*?\]',
+            f'workflows: {names}',
+            content
+        )
+        if new_content != content:
+            content = new_content
+            changes += 1
+            msg = f"workflow_run trigger: {names}"
+            print_dry(msg) if dry_run else print_ok(msg)
+    else:
+        new_content = re.sub(
+            r'  workflow_run:.*?\n    workflows:.*?\n    types:.*?\n',
+            '  # workflow_run:            # Uncomment and set your CI workflow'
+            ' name to run after CI\n'
+            '  #   workflows: ["CI"]\n'
+            '  #   types: [completed]\n',
+            content
+        )
+        if new_content != content:
+            content = new_content
+            changes += 1
+            msg = "workflow_run trigger: commented out (no CI workflows specified)"
+            print_dry(msg) if dry_run else print_ok(msg)
+
+    # Update archive version string
+    new_content = re.sub(
+        r'version: "[^"]+",',
+        'version: "0.1.0",',
+        content
+    )
+    if new_content != content:
+        content = new_content
+        changes += 1
+        msg = "Archive version: 0.1.0"
+        print_dry(msg) if dry_run else print_ok(msg)
+
+    if not dry_run and content != original:
+        workflow_path.write_text(content, encoding="utf-8")
+
+    return changes

ghtraf/gh.py

@@ -0,0 +1,183 @@
+"""GitHub CLI (gh) wrapper utilities.
+
+Provides authenticated access to the GitHub API via the gh CLI tool.
+All ghtraf operations that touch GitHub go through this module.
+"""
+
+import shutil
+import subprocess
+import sys
+
+
+def run_gh(args, input_data=None, check=True):
+    """Run a gh CLI command, return stdout.
+
+    Args:
+        args: List of arguments to pass to gh.
+        input_data: Optional string to pipe to stdin.
+        check: If True (default), exit on failure.
+
+    Returns:
+        Stripped stdout string.
+
+    Raises:
+        SystemExit: If check=True and the command fails.
+    """
+    result = subprocess.run(
+        ["gh"] + args,
+        capture_output=True, text=True, encoding="utf-8",
+        input=input_data
+    )
+    if check and result.returncode != 0:
+        print(f"  ERROR: gh {' '.join(args[:3])}...", file=sys.stderr)
+        print(f"  {result.stderr.strip()}", file=sys.stderr)
+        sys.exit(1)
+    return result.stdout.strip()
+
+
+def check_gh_installed():
+    """Verify gh CLI exists on PATH.
+
+    Returns:
+        Version string if found.
+
+    Raises:
+        SystemExit: If gh is not installed.
+    """
+    if shutil.which("gh") is None:
+        print("ERROR: gh CLI not found.")
+        print()
+        print("  Install it from: https://cli.github.com")
+        print("  Or via package manager:")
+        print("    Windows:  winget install GitHub.cli")
+        print("    macOS:    brew install gh")
+        print("    Linux:    See https://github.com/cli/cli/blob/trunk/docs/install_linux.md")
+        sys.exit(1)
+
+    version = subprocess.run(
+        ["gh", "--version"], capture_output=True, text=True, encoding="utf-8"
+    ).stdout.strip().split("\n")[0]
+    return version
+
+
+def check_gh_authenticated():
+    """Verify gh auth status.
+
+    Returns:
+        Raw auth output string (for scope checking).
+
+    Raises:
+        SystemExit: If not authenticated.
+    """
+    result = subprocess.run(
+        ["gh", "auth", "status"],
+        capture_output=True, text=True, encoding="utf-8"
+    )
+    output = result.stdout + result.stderr
+    if result.returncode != 0:
+        print("ERROR: Not authenticated with GitHub CLI.")
+        print()
+        print("  Run: gh auth login")
+        print("  Then re-run this command.")
+        sys.exit(1)
+    return output
+
+
+def check_gh_scopes(auth_output):
+    """Check if the gh token has gist scope.
+
+    Returns:
+        True if gist scope is available.
+    """
+    result = subprocess.run(
+        ["gh", "api", "gists", "--method", "GET", "-q", ".[0].id"],
+        capture_output=True, text=True, encoding="utf-8"
+    )
+    if result.returncode != 0 and "403" in result.stderr:
+        return False
+    return True
+
+
+def resolve_github_username():
+    """Get the authenticated user's GitHub username."""
+    return run_gh(["api", "user", "--jq", ".login"])
+
+
+def set_repo_variable(name, value, gh_repo, dry_run=False):
+    """Set a GitHub repository variable.
+
+    Args:
+        name: Variable name.
+        value: Variable value.
+        gh_repo: Repository in owner/repo format.
+        dry_run: If True, only print what would happen.
+
+    Returns:
+        True if successful (or dry run), False on failure.
+    """
+    if dry_run:
+        return True
+
+    result = subprocess.run(
+        ["gh", "variable", "set", name, "--body", value, "-R", gh_repo],
+        capture_output=True, text=True, encoding="utf-8"
+    )
+    if result.returncode != 0:
+        return False
+    return True
+
+
+def set_repo_secret(name, value, gh_repo):
+    """Set a GitHub repository secret.
+
+    Args:
+        name: Secret name.
+        value: Secret value.
+        gh_repo: Repository in owner/repo format.
+
+    Returns:
+        True if successful, False on failure.
+    """
+    result = subprocess.run(
+        ["gh", "secret", "set", name, "-R", gh_repo],
+        capture_output=True, text=True, encoding="utf-8",
+        input=value
+    )
+    return result.returncode == 0
+
+
+def check_repo_exists(gh_repo):
+    """Check if a repository exists on GitHub.
+
+    Returns:
+        The repo full_name if it exists, None otherwise.
+    """
+    result = subprocess.run(
+        ["gh", "api", f"repos/{gh_repo}", "--jq", ".full_name"],
+        capture_output=True, text=True, encoding="utf-8"
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def get_repo_created_date(gh_repo):
+    """Get the creation date of a repository.
+
+    Returns:
+        Date string (YYYY-MM-DD) or None.
+    """
+    try:
+        result = subprocess.run(
+            ["gh", "api", f"repos/{gh_repo}", "--jq", ".created_at"],
+            capture_output=True, text=True, encoding="utf-8",
+        )
+        if result.returncode != 0:
+            return None
+        raw = result.stdout.strip()
+        # Validate it looks like a date (YYYY-MM-DD...)
+        if raw and len(raw) >= 10 and raw[4] == "-" and raw[7] == "-":
+            return raw[:10]
+    except Exception:
+        pass
+    return None