ci-parity-cli 0.1.0__tar.gz

ci_parity_cli-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI Parity Test
+on: [push]
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+    services:
+      postgres:
+        image: postgres:16
+    env:
+      DATABASE_URL: "postgres://user:pass@localhost:5432/db"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22.4"

ci_parity_cli-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+# Python Virtual Environments
+.venv/
+env/
+venv/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Packaging
+build/
+dist/
+*.egg-info/
+
+# IDEs and Secrets
+.vscode/
+.env

ci_parity_cli-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.5
+Name: ci-parity-cli
+Version: 0.1.0
+Summary: Compare your local environment to CI workflows to prevent 'works on my machine' errors.
+Author-email: Braveen R <your.email@example.com>
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0

ci_parity_cli-0.1.0/ci_parity/compare/versions.py

@@ -0,0 +1,19 @@
+def evaluate_mismatch(ci_val, local_val, item_type):
+    if ci_val == "unknown" or local_val == "not installed":
+        return "[danger]❌ missing[/danger]"
+    
+    if item_type == "os":
+        if ci_val.split("-")[0].lower() not in local_val.lower():
+            return "[warning]⚠ different[/warning]"
+        return "[success]✅ match[/success]"
+        
+    # Semantic versioning comparison (e.g., 22.4 vs 26.12.1)
+    ci_parts = ci_val.split(".")
+    local_parts = local_val.split(".")
+    
+    if ci_parts[0] != local_parts[0]:
+        return "[danger]❌ major differs[/danger]"
+    elif len(ci_parts) > 1 and len(local_parts) > 1 and ci_parts[1] != local_parts[1]:
+        return "[warning]⚠ minor differs[/warning]"
+        
+    return "[success]✅ match[/success]"

ci_parity_cli-0.1.0/ci_parity/explain/analyzer.py

@@ -0,0 +1,17 @@
+def analyze_log(log_text):
+    """Scans a CI log for common environment-related failure signatures."""
+    insights = []
+    
+    if "Cannot find module" in log_text or "MODULE_NOT_FOUND" in log_text:
+        insights.append("[danger]Node.js Mismatch:[/danger] CI failed to resolve a module. This often happens if the CI Node version is older than your local version and lacks support for newer built-in packages.")
+        
+    if "psql: error: connection to server" in log_text or "Connection refused" in log_text:
+        insights.append("[danger]Database Missing:[/danger] The CI pipeline attempted to connect to a database service, but it was either not defined in the workflow's `services:` block or failed to start.")
+        
+    if "KeyError:" in log_text or "undefined" in log_text.lower():
+        insights.append("[danger]Missing Env Var:[/danger] The application crashed trying to read an environment variable that wasn't exposed to the CI runner.")
+        
+    if not insights:
+        insights.append("[info]No obvious environment-related crashes found in the log snippet.[/info]")
+        
+    return insights

ci_parity_cli-0.1.0/ci_parity/fixes/suggestions.py

@@ -0,0 +1,12 @@
+def generate_fixes(ci_reqs, local_state):
+    fixes = []
+    
+    # Python fix using uv
+    if ci_reqs["python"] != "unknown" and not local_state["python"].startswith(ci_reqs["python"]):
+        fixes.append(f"uv python install {ci_reqs['python']} && uv venv --python {ci_reqs['python']}")
+        
+    # Node fix using nvm
+    if ci_reqs["node"] != "unknown" and not local_state["node"].startswith(ci_reqs["node"]):
+        fixes.append(f"nvm install {ci_reqs['node']} && nvm use {ci_reqs['node']}")
+        
+    return fixes

ci_parity_cli-0.1.0/ci_parity/main.py

@@ -0,0 +1,80 @@
+import typer
+from rich.console import Console
+from rich.theme import Theme
+from rich.table import Table
+from rich.panel import Panel
+from ci_parity.parsers.workflows import get_ci_requirements
+from ci_parity.probes.local import get_local_state
+from ci_parity.compare.versions import evaluate_mismatch
+from ci_parity.fixes.suggestions import generate_fixes
+from ci_parity.explain.analyzer import analyze_log
+
+custom_theme = Theme({
+    "info": "dim cyan",
+    "warning": "magenta",
+    "danger": "bold #B21318",
+    "success": "bold green"
+})
+console = Console(theme=custom_theme)
+
+app = typer.Typer(help="ci-parity: Sync your local dev environment with CI.", no_args_is_help=True)
+
+@app.command()
+def check():
+    console.print("[info]Scanning .github/workflows...[/info]\n")
+    ci_reqs = get_ci_requirements()
+    local_state = get_local_state(ci_reqs)
+    
+    table = Table(header_style="info", border_style="dim cyan")
+    table.add_column("ITEM")
+    table.add_column("CI")
+    table.add_column("YOU")
+    table.add_column("RESULT")
+    
+    table.add_row("OS", ci_reqs["os"], local_state["os"], evaluate_mismatch(ci_reqs["os"], local_state["os"], "os"))
+    table.add_row("Python", ci_reqs["python"], local_state["python"], evaluate_mismatch(ci_reqs["python"], local_state["python"], "version"))
+    table.add_row("Node", ci_reqs["node"], local_state["node"], evaluate_mismatch(ci_reqs["node"], local_state["node"], "version"))
+    
+    for svc, img in ci_reqs["services"].items():
+        is_running = local_state["services"].get(svc, False)
+        table.add_row(f"{svc.capitalize()} (service)", img, "running" if is_running else "not running", "[success]✅ match[/success]" if is_running else "[danger]❌ missing[/danger]")
+
+    for env_var in ci_reqs["env"]:
+        is_set = local_state["env"].get(env_var, False)
+        table.add_row(env_var, "required", "set" if is_set else "not set", "[success]✅ match[/success]" if is_set else "[danger]❌ missing[/danger]")
+    
+    console.print(table)
+    
+    fixes = generate_fixes(ci_reqs, local_state)
+    if not local_state["services"].get("postgres", True):
+        fixes.append("docker run -d --name postgres -e POSTGRES_PASSWORD=pass -p 5432:5432 postgres:16")
+    if not local_state["env"].get("DATABASE_URL", True):
+        fixes.append("export DATABASE_URL='postgres://...' (add to .env)")
+
+    if fixes:
+        console.print("\n[warning]Likely cause:[/warning] Code using newer language features, or missing database/env vars.")
+        fix_text = "\n".join([f"• {f}" for f in fixes])
+        console.print(Panel(fix_text, title="[info]Recommended Fixes[/info]", border_style="dim cyan", expand=False))
+    else:
+        console.print("\n[success]Environments are perfectly synced![/success]")
+
+@app.command()
+def explain(run_url: str):
+    console.print(f"[info]Connecting to GitHub API for:[/info] {run_url}\n")
+    
+    # Simulating a fetched failed log containing a Node version error
+    dummy_log = """
+    Step 4: Run tests
+    Error: Cannot find module 'node:test'
+    Require stack:
+    - /home/runner/work/app/app/test.js
+    """
+    
+    console.print(Panel(dummy_log.strip(), title="[warning]Extracted CI Log Snippet[/warning]", border_style="dim magenta", expand=False))
+    
+    insights = analyze_log(dummy_log)
+    for insight in insights:
+        console.print(f"💡 {insight}")
+
+if __name__ == "__main__":
+    app()

ci_parity_cli-0.1.0/ci_parity/parsers/workflows.py

@@ -0,0 +1,38 @@
+import yaml
+from pathlib import Path
+
+def get_ci_requirements(directory=".github/workflows"):
+    requirements = {"os": "unknown", "python": "unknown", "node": "unknown", "services": {}, "env": []}
+    
+    path = Path(directory)
+    if not path.exists():
+        return requirements
+
+    for yml_file in path.glob("*.yml"):
+        with open(yml_file, "r") as f:
+            try:
+                data = yaml.safe_load(f)
+                jobs = data.get("jobs", {})
+                for job_name, job_data in jobs.items():
+                    if "runs-on" in job_data:
+                        requirements["os"] = job_data["runs-on"]
+                        
+                    # Extract Environment Variables
+                    if "env" in job_data:
+                        requirements["env"].extend(job_data["env"].keys())
+                        
+                    # Extract Services (like Postgres/Redis)
+                    if "services" in job_data:
+                        for svc_name, svc_details in job_data["services"].items():
+                            requirements["services"][svc_name] = svc_details.get("image", "unknown")
+                    
+                    for step in job_data.get("steps", []):
+                        with_block = step.get("with", {})
+                        if "python-version" in with_block:
+                            requirements["python"] = str(with_block["python-version"])
+                        if "node-version" in with_block:
+                            requirements["node"] = str(with_block["node-version"])
+            except Exception:
+                continue
+                
+    return requirements

ci_parity_cli-0.1.0/ci_parity/probes/local.py

@@ -0,0 +1,49 @@
+import platform
+import subprocess
+import os
+
+def get_local_os():
+    try:
+        with open("/etc/os-release") as f:
+            for line in f:
+                if line.startswith("PRETTY_NAME="):
+                    return line.split("=")[1].strip().strip('"')
+    except FileNotFoundError:
+        pass
+    return platform.system()
+
+def get_local_python():
+    return platform.python_version()
+
+def get_local_node():
+    try:
+        result = subprocess.run(["node", "-v"], capture_output=True, text=True, check=True)
+        return result.stdout.strip().lstrip("v")
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return "not installed"
+
+def check_local_env(env_vars):
+    """Checks if required CI env vars are set locally."""
+    return {var: (var in os.environ) for var in env_vars}
+
+def check_local_services(services):
+    """Checks if docker containers for required services are running."""
+    status = {}
+    try:
+        result = subprocess.run(["docker", "ps", "--format", "{{.Names}} {{.Image}}"], capture_output=True, text=True)
+        running_containers = result.stdout.lower()
+        for svc in services:
+            status[svc] = svc.lower() in running_containers
+    except Exception:
+        for svc in services:
+            status[svc] = False
+    return status
+
+def get_local_state(ci_reqs):
+    return {
+        "os": get_local_os(),
+        "python": get_local_python(),
+        "node": get_local_node(),
+        "env": check_local_env(ci_reqs.get("env", [])),
+        "services": check_local_services(ci_reqs.get("services", {}))
+    }

ci_parity_cli-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ci-parity-cli"
+version = "0.1.0"
+description = "Compare your local environment to CI workflows to prevent 'works on my machine' errors."
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "Braveen R", email = "your.email@example.com" }]
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.7.0",
+    "pyyaml>=6.0.1",
+]
+
+[project.scripts]
+ci-parity-cli = "ci_parity.main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ci_parity"]