gha-debug 0.1.0__py3-none-any.whl

gha_debug/__init__.py

@@ -0,0 +1,3 @@
+"""gha-debug: Debug GitHub Actions workflows locally."""
+
+__version__ = "0.1.0"

gha_debug/cli.py

@@ -0,0 +1,147 @@
+"""CLI interface for gha-debug."""
+
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from gha_debug import __version__
+from gha_debug.formatter import Formatter
+from gha_debug.parser import WorkflowParser
+from gha_debug.runner import WorkflowRunner
+from gha_debug.validator import WorkflowValidator
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__)
+def cli() -> None:
+    """Debug GitHub Actions workflows locally with step-by-step execution."""
+    pass
+
+
+@cli.command()
+@click.argument("workflow_path", type=click.Path(exists=True))
+@click.option("--job", "-j", help="Specific job to run")
+@click.option("--verbose", "-v", is_flag=True, help="Show verbose output")
+def run(workflow_path: str, job: Optional[str], verbose: bool) -> None:
+    """Run a GitHub Actions workflow locally."""
+    try:
+        path = Path(workflow_path)
+        parser = WorkflowParser(path)
+        workflow = parser.parse()
+
+        runner = WorkflowRunner(workflow, verbose=verbose)
+        formatter = Formatter()
+
+        formatter.print_workflow_header(workflow["name"], path)
+
+        result = runner.run(job_filter=job)
+
+        if result["success"]:
+            formatter.print_success(result["total_time"])
+            sys.exit(0)
+        else:
+            formatter.print_failure(result["error"])
+            sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {str(e)}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("workflow_path", type=click.Path(exists=False), default=".github/workflows")
+def list(workflow_path: str) -> None:
+    """List all workflows, jobs, and steps."""
+    try:
+        path = Path(workflow_path)
+
+        if path.is_file():
+            workflow_files = [path]
+        elif path.is_dir():
+            workflow_files = list(path.glob("*.yml")) + list(path.glob("*.yaml"))
+        else:
+            console.print(f"[yellow]Warning:[/yellow] Path not found: {workflow_path}")
+            sys.exit(1)
+
+        if not workflow_files:
+            console.print("[yellow]No workflow files found[/yellow]")
+            sys.exit(0)
+
+        formatter = Formatter()
+
+        for wf_path in sorted(workflow_files):
+            parser = WorkflowParser(wf_path)
+            workflow = parser.parse()
+            formatter.print_workflow_structure(workflow, wf_path)
+            console.print()
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {str(e)}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("workflow_path", type=click.Path(exists=True))
+@click.option("--job", "-j", help="Specific job to show environment for")
+def env(workflow_path: str, job: Optional[str]) -> None:
+    """Display environment variables and contexts for a workflow."""
+    try:
+        path = Path(workflow_path)
+        parser = WorkflowParser(path)
+        workflow = parser.parse()
+
+        formatter = Formatter()
+        formatter.print_environment(workflow, job_filter=job)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {str(e)}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("workflow_paths", nargs=-1, type=click.Path(exists=True), required=True)
+def validate(workflow_paths: tuple) -> None:
+    """Validate workflow syntax and catch common errors."""
+    try:
+        validator = WorkflowValidator()
+        all_valid = True
+
+        for workflow_path in workflow_paths:
+            path = Path(workflow_path)
+
+            if path.is_dir():
+                files = list(path.glob("*.yml")) + list(path.glob("*.yaml"))
+            else:
+                files = [path]
+
+            for file_path in files:
+                errors = validator.validate(file_path)
+
+                if errors:
+                    all_valid = False
+                    console.print(f"\n[red]✗[/red] {file_path}")
+                    for error in errors:
+                        console.print(f"  [red]•[/red] {error}")
+                else:
+                    console.print(f"[green]✓[/green] {file_path}")
+
+        if all_valid:
+            console.print("\n[green]All workflows are valid![/green]")
+            sys.exit(0)
+        else:
+            console.print("\n[red]Some workflows have errors[/red]")
+            sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {str(e)}")
+        sys.exit(1)
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

gha_debug/formatter.py

@@ -0,0 +1,102 @@
+"""Output formatting with colors and tables."""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+class Formatter:
+    """Format output for the CLI with colors and structure."""
+
+    def print_workflow_header(self, workflow_name: str, path: Path) -> None:
+        """Print workflow header.
+
+        Args:
+            workflow_name: Name of the workflow
+            path: Path to the workflow file
+        """
+        console.print(f"\n[bold cyan]Running workflow:[/bold cyan] {workflow_name}")
+        console.print(f"[dim]File: {path}[/dim]")
+        console.rule()
+
+    def print_step_success(self, step_name: str, elapsed: float) -> None:
+        """Print successful step.
+
+        Args:
+            step_name: Name of the step
+            elapsed: Time elapsed in seconds
+        """
+        console.print(f"  [green]✓[/green] {step_name} [dim]({elapsed:.1f}s)[/dim]")
+
+    def print_step_failure(self, step_name: str, elapsed: float) -> None:
+        """Print failed step.
+
+        Args:
+            step_name: Name of the step
+            elapsed: Time elapsed in seconds
+        """
+        console.print(f"  [red]✗[/red] {step_name} [dim]({elapsed:.1f}s)[/dim]")
+
+    def print_success(self, total_time: float) -> None:
+        """Print workflow success message.
+
+        Args:
+            total_time: Total execution time in seconds
+        """
+        console.print(f"\n[green]✓ Workflow completed successfully in {total_time:.1f}s[/green]")
+
+    def print_failure(self, error: str) -> None:
+        """Print workflow failure message.
+
+        Args:
+            error: Error message
+        """
+        console.print(f"\n[red]✗ Workflow failed: {error}[/red]")
+
+    def print_workflow_structure(self, workflow: Dict[str, Any], path: Path) -> None:
+        """Print workflow structure with jobs and steps.
+
+        Args:
+            workflow: Parsed workflow dictionary
+            path: Path to the workflow file
+        """
+        console.print(f"[bold]{workflow['name']}[/bold] [dim]({path.name})[/dim]")
+
+        for job in workflow["jobs"]:
+            console.print(f"  [cyan]Job:[/cyan] {job['name']} [dim](runs-on: {job['runs-on']})[/dim]")
+
+            for step in job["steps"]:
+                icon = "🔧" if step.get("uses") else "▶"
+                console.print(f"    {icon} {step['name']}")
+
+    def print_environment(self, workflow: Dict[str, Any], job_filter: Optional[str] = None) -> None:
+        """Print environment variables for workflow or job.
+
+        Args:
+            workflow: Parsed workflow dictionary
+            job_filter: Optional job ID to filter by
+        """
+        table = Table(title="Environment Variables")
+        table.add_column("Scope", style="cyan")
+        table.add_column("Variable", style="green")
+        table.add_column("Value", style="yellow")
+
+        for key, value in workflow.get("env", {}).items():
+            table.add_row("Workflow", key, str(value))
+
+        for job in workflow["jobs"]:
+            if job_filter and job["id"] != job_filter:
+                continue
+
+            for key, value in job.get("env", {}).items():
+                table.add_row(f"Job: {job['id']}", key, str(value))
+
+        table.add_row("Default", "CI", "true")
+        table.add_row("Default", "GITHUB_ACTIONS", "true")
+        table.add_row("Default", "GITHUB_WORKFLOW", workflow["name"])
+
+        console.print(table)

gha_debug/parser.py

@@ -0,0 +1,97 @@
+"""YAML parsing logic for GitHub Actions workflows."""
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+import yaml
+
+
+class WorkflowParser:
+    """Parse GitHub Actions workflow YAML files."""
+
+    def __init__(self, workflow_path: Path):
+        """Initialize the parser with a workflow file path.
+
+        Args:
+            workflow_path: Path to the workflow YAML file
+        """
+        self.workflow_path = workflow_path
+
+    def parse(self) -> Dict[str, Any]:
+        """Parse the workflow file and extract structure.
+
+        Returns:
+            Dictionary containing workflow structure with jobs and steps
+
+        Raises:
+            ValueError: If the workflow file is invalid
+            FileNotFoundError: If the workflow file doesn't exist
+        """
+        if not self.workflow_path.exists():
+            raise FileNotFoundError(f"Workflow file not found: {self.workflow_path}")
+
+        try:
+            with open(self.workflow_path, "r") as f:
+                data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in workflow file: {e}")
+
+        if not isinstance(data, dict):
+            raise ValueError("Workflow file must contain a YAML dictionary")
+
+        workflow_name = data.get("name", self.workflow_path.stem)
+        jobs = data.get("jobs", {})
+        env = data.get("env", {})
+
+        parsed_jobs = []
+        for job_id, job_data in jobs.items():
+            if not isinstance(job_data, dict):
+                continue
+
+            steps = job_data.get("steps", [])
+            parsed_steps = []
+
+            for step in steps:
+                if not isinstance(step, dict):
+                    continue
+
+                step_name = step.get("name", step.get("uses", step.get("run", "Unnamed step")))
+                parsed_steps.append({
+                    "name": step_name,
+                    "uses": step.get("uses"),
+                    "run": step.get("run"),
+                    "env": step.get("env", {}),
+                    "with": step.get("with", {}),
+                })
+
+            parsed_jobs.append({
+                "id": job_id,
+                "name": job_data.get("name", job_id),
+                "runs-on": job_data.get("runs-on", "ubuntu-latest"),
+                "env": job_data.get("env", {}),
+                "steps": parsed_steps,
+            })
+
+        return {
+            "name": workflow_name,
+            "env": env,
+            "jobs": parsed_jobs,
+        }
+
+    def get_job(self, workflow: Dict[str, Any], job_id: str) -> Dict[str, Any]:
+        """Get a specific job from the workflow.
+
+        Args:
+            workflow: Parsed workflow dictionary
+            job_id: ID of the job to retrieve
+
+        Returns:
+            Job dictionary
+
+        Raises:
+            ValueError: If job not found
+        """
+        for job in workflow["jobs"]:
+            if job["id"] == job_id:
+                return job
+        raise ValueError(f"Job '{job_id}' not found in workflow")

gha_debug/runner.py

@@ -0,0 +1,191 @@
+"""Local execution engine for workflow steps."""
+
+import os
+import subprocess
+import time
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+
+from gha_debug.formatter import Formatter
+
+console = Console()
+
+
+class WorkflowRunner:
+    """Run workflow steps locally with simulated GitHub Actions environment."""
+
+    def __init__(self, workflow: Dict[str, Any], verbose: bool = False):
+        """Initialize the runner with a parsed workflow.
+
+        Args:
+            workflow: Parsed workflow dictionary
+            verbose: Whether to show verbose output
+        """
+        self.workflow = workflow
+        self.verbose = verbose
+        self.formatter = Formatter()
+
+    def run(self, job_filter: Optional[str] = None) -> Dict[str, Any]:
+        """Run the workflow or a specific job.
+
+        Args:
+            job_filter: Optional job ID to run only that job
+
+        Returns:
+            Dictionary with success status and timing information
+        """
+        start_time = time.time()
+
+        jobs_to_run = self.workflow["jobs"]
+        if job_filter:
+            jobs_to_run = [j for j in jobs_to_run if j["id"] == job_filter]
+            if not jobs_to_run:
+                return {
+                    "success": False,
+                    "error": f"Job '{job_filter}' not found",
+                    "total_time": 0,
+                }
+
+        for job in jobs_to_run:
+            success = self._run_job(job)
+            if not success:
+                total_time = time.time() - start_time
+                return {
+                    "success": False,
+                    "error": f"Job '{job['id']}' failed",
+                    "total_time": total_time,
+                }
+
+        total_time = time.time() - start_time
+        return {
+            "success": True,
+            "total_time": total_time,
+        }
+
+    def _run_job(self, job: Dict[str, Any]) -> bool:
+        """Run a single job.
+
+        Args:
+            job: Job dictionary
+
+        Returns:
+            True if job succeeded, False otherwise
+        """
+        console.print(f"\n[bold]Job:[/bold] {job['name']}")
+
+        env = self._build_environment(job)
+
+        for step in job["steps"]:
+            success = self._run_step(step, env)
+            if not success:
+                return False
+
+        return True
+
+    def _run_step(self, step: Dict[str, Any], env: Dict[str, str]) -> bool:
+        """Run a single step.
+
+        Args:
+            step: Step dictionary
+            env: Environment variables
+
+        Returns:
+            True if step succeeded, False otherwise
+        """
+        start_time = time.time()
+
+        step_env = {**env, **step.get("env", {})}
+
+        if step.get("uses"):
+            success = self._run_action(step, step_env)
+        elif step.get("run"):
+            success = self._run_command(step, step_env)
+        else:
+            success = True
+
+        elapsed = time.time() - start_time
+
+        if success:
+            self.formatter.print_step_success(step["name"], elapsed)
+        else:
+            self.formatter.print_step_failure(step["name"], elapsed)
+
+        return success
+
+    def _run_action(self, step: Dict[str, Any], env: Dict[str, str]) -> bool:
+        """Simulate running a GitHub Action.
+
+        Args:
+            step: Step dictionary
+            env: Environment variables
+
+        Returns:
+            True (actions are simulated as successful)
+        """
+        action = step["uses"]
+
+        if self.verbose:
+            console.print(f"  [dim]Using action: {action}[/dim]")
+            if step.get("with"):
+                console.print(f"  [dim]With: {step['with']}[/dim]")
+
+        time.sleep(0.1)
+        return True
+
+    def _run_command(self, step: Dict[str, Any], env: Dict[str, str]) -> bool:
+        """Run a shell command.
+
+        Args:
+            step: Step dictionary
+            env: Environment variables
+
+        Returns:
+            True if command succeeded, False otherwise
+        """
+        command = step["run"]
+
+        if self.verbose:
+            console.print(f"  [dim]Running: {command}[/dim]")
+
+        try:
+            result = subprocess.run(
+                command,
+                shell=True,
+                env={**os.environ.copy(), **env},
+                capture_output=not self.verbose,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                return True
+            else:
+                if not self.verbose and result.stderr:
+                    console.print(f"  [red]{result.stderr.strip()}[/red]")
+                return False
+        except Exception as e:
+            console.print(f"  [red]Error: {str(e)}[/red]")
+            return False
+
+    def _build_environment(self, job: Dict[str, Any]) -> Dict[str, str]:
+        """Build environment variables for a job.
+
+        Args:
+            job: Job dictionary
+
+        Returns:
+            Dictionary of environment variables
+        """
+        env = {
+            "CI": "true",
+            "GITHUB_ACTIONS": "true",
+            "GITHUB_WORKFLOW": self.workflow["name"],
+            "GITHUB_JOB": job["id"],
+            "GITHUB_RUNNER_OS": "Linux",
+            "RUNNER_OS": "Linux",
+        }
+
+        env.update(self.workflow.get("env", {}))
+        env.update(job.get("env", {}))
+
+        return {k: str(v) for k, v in env.items()}

gha_debug/validator.py

@@ -0,0 +1,96 @@
+"""Workflow validation logic."""
+
+from pathlib import Path
+from typing import List
+
+import yaml
+
+
+class WorkflowValidator:
+    """Validate GitHub Actions workflow files."""
+
+    def validate(self, workflow_path: Path) -> List[str]:
+        """Validate a workflow file and return list of errors.
+
+        Args:
+            workflow_path: Path to the workflow YAML file
+
+        Returns:
+            List of error messages (empty if valid)
+        """
+        errors = []
+
+        if not workflow_path.exists():
+            return [f"File not found: {workflow_path}"]
+
+        # Read raw content for syntax checks
+        with open(workflow_path, "r") as f:
+            raw_content = f.read()
+
+        try:
+            data = yaml.safe_load(raw_content)
+        except yaml.YAMLError as e:
+            return [f"Invalid YAML syntax: {e}"]
+
+        if not isinstance(data, dict):
+            return ["Workflow must be a YAML dictionary"]
+
+        if "jobs" not in data:
+            errors.append("Missing required field: 'jobs'")
+            return errors
+
+        if not isinstance(data["jobs"], dict):
+            errors.append("'jobs' must be a dictionary")
+            return errors
+
+        if not data["jobs"]:
+            errors.append("Workflow must have at least one job")
+
+        for job_id, job_data in data["jobs"].items():
+            if not isinstance(job_data, dict):
+                errors.append(f"Job '{job_id}' must be a dictionary")
+                continue
+
+            if "steps" not in job_data:
+                errors.append(f"Job '{job_id}' missing required field: 'steps'")
+                continue
+
+            if not isinstance(job_data["steps"], list):
+                errors.append(f"Job '{job_id}': 'steps' must be a list")
+                continue
+
+            if not job_data["steps"]:
+                errors.append(f"Job '{job_id}' must have at least one step")
+
+            for idx, step in enumerate(job_data["steps"]):
+                if not isinstance(step, dict):
+                    errors.append(f"Job '{job_id}', step {idx}: must be a dictionary")
+                    continue
+
+                has_uses = "uses" in step
+                has_run = "run" in step
+
+                if not has_uses and not has_run:
+                    errors.append(f"Job '{job_id}', step {idx}: must have 'uses' or 'run'")
+
+                if has_uses and has_run:
+                    errors.append(f"Job '{job_id}', step {idx}: cannot have both 'uses' and 'run'")
+
+        self._validate_syntax_patterns(raw_content, data, errors)
+
+        return errors
+
+    def _validate_syntax_patterns(self, raw_content: str, data: dict, errors: List[str]) -> None:
+        """Check for common syntax mistakes.
+
+        Args:
+            raw_content: Raw YAML content as string
+            data: Parsed workflow YAML
+            errors: List to append errors to
+        """
+        # Check for malformed GitHub expressions (no space)
+        if "${{}}" in raw_content:
+            errors.append("Syntax hint: GitHub expressions use '${{ }}' not '${{}}'")
+
+        if "on" not in data and True not in data:
+            errors.append("Warning: Missing 'on:' trigger configuration")

gha_debug-0.1.0.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: gha-debug
+Version: 0.1.0
+Summary: Debug GitHub Actions workflows locally with step-by-step execution
+Author: Intellirim
+License: MIT
+Project-URL: Homepage, https://github.com/intellirim/gha-debug
+Keywords: github-actions,developer-tools,cli,ci-cd,workflow-debugging,devops
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Dynamic: license-file
+
+# gha-debug
+
+Debug GitHub Actions workflows locally with step-by-step execution
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Overview
+
+`gha-debug` is a lightweight CLI tool that helps developers test and debug GitHub Actions workflows locally before pushing to CI. Unlike heavy Docker-based solutions, it provides fast validation, clear step-by-step execution visibility, and helpful error messages.
+
+## Installation
+
+```bash
+pip install gha-debug
+```
+
+## Usage
+
+### Run a workflow locally
+
+```bash
+gha-debug run .github/workflows/test.yml
+```
+
+### Run a specific job with verbose output
+
+```bash
+gha-debug run .github/workflows/build.yml --job build --verbose
+```
+
+### List all workflows and jobs
+
+```bash
+gha-debug list
+```
+
+### Show environment variables for a job
+
+```bash
+gha-debug env .github/workflows/deploy.yml --job deploy
+```
+
+### Validate workflow syntax
+
+```bash
+gha-debug validate .github/workflows/*.yml
+```
+
+## Features
+
+- ✅ Parse and validate GitHub Actions workflow YAML files
+- ✅ List all workflows, jobs, and steps with clear formatting
+- ✅ Run workflows locally with simulated GitHub Actions environment
+- ✅ Show detailed step-by-step execution with timing information
+- ✅ Display environment variables and contexts for debugging
+- ✅ Validate workflow syntax and catch common errors before pushing
+- ✅ Colorized output for better readability
+- ✅ Support for filtering by specific job within a workflow
+
+## Why gha-debug?
+
+Debugging GitHub Actions workflows is painful:
+- Logs are hard to navigate in the web interface
+- Re-running failed jobs wastes time
+- No simple local testing that mirrors the CI environment
+
+`gha-debug` solves this by providing a fast feedback loop. It doesn't try to perfectly replicate GitHub's environment (which causes compatibility issues), but instead focuses on what developers need most: quick validation and clear error messages.
+
+## Example Output
+
+```
+$ gha-debug run .github/workflows/test.yml
+
+Running workflow: test.yml
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Job: test
+  ✓ Checkout code (1.2s)
+  ✓ Setup Python 3.11 (0.8s)
+  ✓ Install dependencies (4.5s)
+  ✓ Run tests (12.3s)
+
+✓ Workflow completed successfully in 18.8s
+```
+
+## License
+
+MIT License - Copyright (c) 2026 Intellirim

gha_debug-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+gha_debug/__init__.py,sha256=BniAhhxX-uNwkwZw22Kej3-rYFhlfoW9x3crCBhSGM0,80
+gha_debug/cli.py,sha256=Z2rOLY0UE3JStU3YKm-mP2eZYNs9VyuDCIjPCWN1ba8,4501
+gha_debug/formatter.py,sha256=ymP039W2D6oInmABZ0cRxn--jHJcRMScL5gelUw-UDc,3489
+gha_debug/parser.py,sha256=TQ4lW_KPqj9oGzOvKosSKn0nHRjsVclmJ3Ya_SLjR28,3015
+gha_debug/runner.py,sha256=z1tEjENMrrx2b_wOtV71kdFN1VuqXiqBh8zYs0DymvQ,5367
+gha_debug/validator.py,sha256=vRTP_hEofFBAxJB2dhqQxi9GiRLwZCg9-6P1OHy-gk8,3187
+gha_debug-0.1.0.dist-info/licenses/LICENSE,sha256=eZ8ricP3gTwzaY1c4vb6oib6f5K0s8Nsg2EmBJ1RACk,1067
+gha_debug-0.1.0.dist-info/METADATA,sha256=_-84NAiC9bl0DFLHIGF7i4ab1QwaHkdluIAkvRhohpw,3348
+gha_debug-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+gha_debug-0.1.0.dist-info/entry_points.txt,sha256=qvyOVxmPbWo5z0wwbsuDD7vx_DREiN1CoHr0LCt3ClI,49
+gha_debug-0.1.0.dist-info/top_level.txt,sha256=iZ8sJpbmI-IaEZoD4ldqz3i8t5Net1FPHuhhi5NQUy4,10
+gha_debug-0.1.0.dist-info/RECORD,,

gha_debug-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gha_debug-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gha-debug = gha_debug.cli:main

gha_debug-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Intellirim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gha_debug-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gha_debug