ccid-cli 0.1.1__tar.gz

ccid_cli-0.1.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: ccid-cli
+Version: 0.1.1
+Summary: CCID Compliance CLI - Pipeline-native compliance checking
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.9.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: websockets>=12.0

ccid_cli-0.1.1/ccid_cli/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2024-2026 Dr. Fred Mpala. All rights reserved.
+# Proprietary and confidential. Unauthorized copying, distribution,
+# or use of this file, via any medium, is strictly prohibited.
+

ccid_cli-0.1.1/ccid_cli/api.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2024-2026 Dr. Fred Mpala. All rights reserved.
+# Proprietary and confidential. Unauthorized copying, distribution,
+# or use of this file, via any medium, is strictly prohibited.
+
+"""
+CCID API Client — httpx-based client for the CCID backend API.
+
+Reads configuration from ~/.ccid/config.json and provides typed methods
+for every endpoint the CLI needs.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import httpx
+
+CONFIG_PATH = Path.home() / ".ccid" / "config.json"
+
+
+def load_config() -> dict[str, str]:
+    """Load saved configuration from ~/.ccid/config.json."""
+    if CONFIG_PATH.exists():
+        return json.loads(CONFIG_PATH.read_text())
+    return {}
+
+
+def save_config(data: dict[str, str]) -> None:
+    """Persist configuration to ~/.ccid/config.json."""
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(data, indent=2))
+
+
+class CCIDClient:
+    """Thin wrapper around the CCID REST API."""
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        cfg = load_config()
+        self.base_url = (base_url or cfg.get("api_url", "")).rstrip("/")
+        self.api_key = api_key or cfg.get("api_key", "")
+        if not self.base_url:
+            raise RuntimeError(
+                "No API URL configured. Run `ccid configure` first."
+            )
+        # `ccid analyze` blocks on a full synchronous code-analysis swarm —
+        # ~6 min even for a single resource (TRU-583: measured 376s), and the
+        # backend's Cloud Run request timeout is 3600s. A 120s client timeout
+        # made every sync analyze fail with "read operation timed out" before
+        # the swarm returned. 900s covers realistic analyses; use `--live`
+        # (WebSocket streaming) for very large repos that exceed it.
+        self._client = httpx.Client(
+            base_url=self.base_url,
+            headers=self._headers(),
+            timeout=900.0,
+        )
+
+    def _headers(self) -> dict[str, str]:
+        h: dict[str, str] = {"Content-Type": "application/json"}
+        if self.api_key:
+            # CCID API keys authenticate via X-API-Key ONLY. The
+            # Authorization: Bearer path is reserved for platform JWTs /
+            # Google ID tokens, so a ccid_ key sent there 401s (TRU-583).
+            h["X-API-Key"] = self.api_key
+        return h
+
+    # ------------------------------------------------------------------
+    # WebSocket helper
+    # ------------------------------------------------------------------
+
+    @property
+    def ws_url(self) -> str:
+        """Convert the HTTP(S) base_url to a WebSocket URL."""
+        url = self.base_url
+        if url.startswith("https://"):
+            return url.replace("https://", "wss://", 1) + "/ws"
+        if url.startswith("http://"):
+            return url.replace("http://", "ws://", 1) + "/ws"
+        return "ws://" + url + "/ws"
+
+    # ------------------------------------------------------------------
+    # Endpoints
+    # ------------------------------------------------------------------
+
+    def analyze(
+        self,
+        code: str,
+        frameworks: list[str] | None = None,
+        format: str = "json",
+    ) -> dict[str, Any]:
+        """POST /api/agents/run-code-analysis — trigger a code-analysis swarm."""
+        payload: dict[str, Any] = {
+            "terraform_code": code,
+            "trigger_source": "cli",
+        }
+        if frameworks:
+            payload["frameworks"] = frameworks
+        resp = self._client.post("/api/agents/run-code-analysis", json=payload)
+        resp.raise_for_status()
+        return resp.json()
+
+    def posture(
+        self,
+        scope: str = "system",
+        scope_id: str | None = None,
+    ) -> dict[str, Any]:
+        """GET /api/posture — compliance posture snapshot."""
+        params: dict[str, str] = {"scope": scope}
+        if scope_id:
+            params["scope_id"] = scope_id
+        resp = self._client.get("/api/posture", params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    def assignments(
+        self,
+        severity: str | None = None,
+        status: str = "open",
+    ) -> dict[str, Any]:
+        """GET /api/assignments — findings/assignments list."""
+        params: dict[str, str] = {"status": status}
+        if severity:
+            params["severity"] = severity
+        resp = self._client.get("/api/assignments", params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    def export(
+        self,
+        assessment_id: str,
+        format: str = "json",
+    ) -> str:
+        """GET /api/assessments/{id}/export/{format} — download assessment export."""
+        resp = self._client.get(
+            f"/api/assessments/{assessment_id}/export/{format}"
+        )
+        resp.raise_for_status()
+        return resp.text
+
+    def health(self) -> dict[str, Any]:
+        """GET /api/health — backend health check."""
+        resp = self._client.get("/api/health")
+        resp.raise_for_status()
+        return resp.json()
+
+    def swarm_results(self, assessment_id: str) -> dict[str, Any]:
+        """GET /api/assessments/{id}/swarm-results — swarm execution trace."""
+        resp = self._client.get(
+            f"/api/assessments/{assessment_id}/swarm-results"
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def get(self, path: str, params: dict | None = None) -> dict[str, Any]:
+        """Generic GET request."""
+        resp = self._client.get(path, params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    def post(self, path: str, json_data: dict | None = None) -> dict[str, Any]:
+        """Generic POST request."""
+        resp = self._client.post(path, json=json_data or {})
+        resp.raise_for_status()
+        return resp.json()

ccid_cli-0.1.1/ccid_cli/formatters.py

@@ -0,0 +1,480 @@
+# Copyright (c) 2024-2026 Dr. Fred Mpala. All rights reserved.
+# Proprietary and confidential. Unauthorized copying, distribution,
+# or use of this file, via any medium, is strictly prohibited.
+
+"""
+CCID Formatters — Rich-based output rendering for CLI commands.
+
+Every public function accepts the JSON dict returned by the API and
+prints a Rich renderable to the console.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+# -- Colour mappings -------------------------------------------------------
+
+_POSTURE_COLOURS = {
+    "pass": "bold green",
+    "warn": "bold yellow",
+    "block": "bold red",
+    "unknown": "dim",
+}
+
+_SEVERITY_COLOURS = {
+    "critical": "bold red",
+    "high": "red",
+    "medium": "yellow",
+    "low": "cyan",
+    "info": "dim",
+}
+
+_STATUS_ICONS = {
+    "completed": "[green]OK[/green]",
+    "running": "[yellow]...[/yellow]",
+    "failed": "[red]FAIL[/red]",
+    "pending": "[dim]--[/dim]",
+}
+
+
+# ---------------------------------------------------------------------------
+# Posture
+# ---------------------------------------------------------------------------
+
+def format_posture(data: dict[str, Any]) -> None:
+    """Render compliance posture as a Rich table + summary panel."""
+    posture = data.get("posture", "unknown")
+    score = data.get("score", 0)
+    summary = data.get("summary", "")
+    coverage = data.get("obligation_coverage", {})
+    traceability = data.get("traceability", {})
+
+    # Header panel
+    posture_style = _POSTURE_COLOURS.get(posture, "dim")
+    header = Text()
+    header.append("Posture: ", style="bold")
+    header.append(posture.upper(), style=posture_style)
+    header.append(f"   Score: {score:.0%}", style="bold")
+    header.append(f"\n{summary}")
+    header.append(
+        f"\nObligations: {coverage.get('assessed', 0)}/{coverage.get('total', 0)} assessed"
+        f"  |  Traceability links: {traceability.get('total_links', 0)}"
+    )
+    console.print(Panel(header, title="Compliance Posture", border_style=posture_style))
+
+    # Framework breakdown table
+    frameworks = data.get("frameworks", [])
+    if frameworks:
+        tbl = Table(title="Framework Breakdown", show_lines=True)
+        tbl.add_column("Framework", style="bold")
+        tbl.add_column("Compliant", justify="right")
+        tbl.add_column("Total", justify="right")
+        tbl.add_column("Critical", justify="right", style="red")
+        tbl.add_column("High", justify="right", style="yellow")
+        tbl.add_column("Last Assessed")
+        for fw in frameworks:
+            tbl.add_row(
+                fw.get("code", ""),
+                str(fw.get("obligations_compliant", 0)),
+                str(fw.get("obligations_total", 0)),
+                str(fw.get("critical_findings", 0)),
+                str(fw.get("high_findings", 0)),
+                fw.get("last_assessed", "--") or "--",
+            )
+        console.print(tbl)
+
+    # Top findings
+    top = data.get("top_findings", [])
+    if top:
+        tbl = Table(title="Top Findings", show_lines=True)
+        tbl.add_column("Severity", justify="center")
+        tbl.add_column("Title")
+        tbl.add_column("Resource")
+        tbl.add_column("Status")
+        for f in top:
+            sev = f.get("severity", "medium")
+            tbl.add_row(
+                Text(sev.upper(), style=_SEVERITY_COLOURS.get(sev, "")),
+                f.get("title", ""),
+                f.get("affected_resource", ""),
+                f.get("status", "open"),
+            )
+        console.print(tbl)
+
+
+# ---------------------------------------------------------------------------
+# Assignments
+# ---------------------------------------------------------------------------
+
+def format_assignments(data: dict[str, Any]) -> None:
+    """Render findings/assignments as a Rich table."""
+    items = data.get("items", [])
+    total = data.get("total", len(items))
+
+    tbl = Table(title=f"Assignments ({total} total)", show_lines=True)
+    tbl.add_column("Severity", justify="center", width=10)
+    tbl.add_column("Title", max_width=40)
+    tbl.add_column("Status", width=10)
+    tbl.add_column("Framework", width=14)
+    tbl.add_column("Resource", max_width=30)
+    tbl.add_column("Remediation", max_width=40)
+
+    for item in items:
+        sev = item.get("severity", "medium")
+        fw = ""
+        if item.get("obligation"):
+            fw = item["obligation"].get("framework", "")
+        tbl.add_row(
+            Text(sev.upper(), style=_SEVERITY_COLOURS.get(sev, "")),
+            item.get("title", ""),
+            item.get("status", "open"),
+            fw,
+            item.get("affected_resource", "") or "",
+            item.get("remediation", "") or "",
+        )
+
+    console.print(tbl)
+
+
+# ---------------------------------------------------------------------------
+# Analysis result
+# ---------------------------------------------------------------------------
+
+def format_analysis_result(data: dict[str, Any]) -> None:
+    """Render a code-analysis response as a panel with gate decision + findings."""
+    gate = data.get("gate_decision", "unknown")
+    confidence = data.get("confidence_score", 0) or 0
+    assessment_id = data.get("id", "")
+    findings = data.get("findings", [])
+
+    gate_style = _POSTURE_COLOURS.get(gate, "dim")
+
+    # Gate decision panel
+    header = Text()
+    header.append("Gate: ", style="bold")
+    header.append(gate.upper(), style=gate_style)
+    header.append(f"   Confidence: {confidence:.0%}", style="bold")
+    header.append(f"\nAssessment: {assessment_id}")
+    header.append(f"\nFindings: {len(findings)}")
+    console.print(Panel(header, title="Code Analysis Result", border_style=gate_style))
+
+    if not findings:
+        console.print("[green]No findings - code looks compliant.[/green]")
+        return
+
+    tbl = Table(title="Findings", show_lines=True)
+    tbl.add_column("Severity", justify="center", width=10)
+    tbl.add_column("Title", max_width=40)
+    tbl.add_column("Resource", max_width=30)
+    tbl.add_column("Remediation", max_width=50)
+
+    for f in findings:
+        sev = f.get("severity", "medium")
+        tbl.add_row(
+            Text(sev.upper(), style=_SEVERITY_COLOURS.get(sev, "")),
+            f.get("title", ""),
+            f.get("affected_resource", "") or "",
+            f.get("remediation", "") or "",
+        )
+
+    console.print(tbl)
+
+    # Show remediation code blocks if present
+    for f in findings:
+        if f.get("remediation_code"):
+            console.print(
+                Panel(
+                    f["remediation_code"],
+                    title=f"Fix: {f.get('title', '')}",
+                    border_style="green",
+                )
+            )
+
+    # Show pattern recommendations if present
+    recs = data.get("pattern_recommendations", [])
+    if recs:
+        format_pattern_recommendations(recs)
+
+
+# ---------------------------------------------------------------------------
+# Swarm replay
+# ---------------------------------------------------------------------------
+
+def format_swarm_replay(data: dict[str, Any]) -> None:
+    """Render swarm execution nodes as sequential reasoning panels with timing."""
+    execution = data.get("execution", {})
+    nodes = data.get("nodes", [])
+
+    # Execution summary header
+    swarm_type = execution.get("swarm_type", "unknown")
+    status = execution.get("status", "unknown")
+    total_tokens = execution.get("total_llm_tokens", 0)
+    total_duration = execution.get("total_duration_ms", 0)
+    total_nodes = execution.get("total_nodes", 0)
+    completed_nodes = execution.get("completed_nodes", 0)
+
+    header = Text()
+    header.append("Swarm: ", style="bold")
+    header.append(swarm_type, style="cyan bold")
+    header.append(f"   Status: ", style="bold")
+    header.append(status.upper(), style=_POSTURE_COLOURS.get(status, "dim"))
+    header.append(f"\nNodes: {completed_nodes}/{total_nodes}")
+    header.append(f"   Tokens: {total_tokens:,}")
+    if total_duration:
+        header.append(f"   Duration: {total_duration / 1000:.1f}s")
+    console.print(
+        Panel(header, title="Swarm Execution Replay", border_style="cyan")
+    )
+
+    if not nodes:
+        console.print("[dim]No node results to replay.[/dim]")
+        return
+
+    for i, node in enumerate(nodes, 1):
+        name = node.get("name", f"node-{i}")
+        node_status = node.get("status", "unknown")
+        reasoning = node.get("reasoning", "")
+        tokens = node.get("llm_tokens_used", 0)
+        duration = node.get("duration_ms", 0)
+
+        # Status indicator
+        status_indicator = _STATUS_ICONS.get(node_status, f"[dim]{node_status}[/dim]")
+
+        # Build subtitle with timing
+        subtitle_parts = [f"{status_indicator}"]
+        if tokens:
+            subtitle_parts.append(f"{tokens:,} tokens")
+        if duration:
+            subtitle_parts.append(f"{duration / 1000:.1f}s")
+        subtitle = "  |  ".join(subtitle_parts)
+
+        # Reasoning content
+        content = Text()
+        if reasoning:
+            # Truncate very long reasoning but keep it readable
+            display_reasoning = reasoning if len(reasoning) <= 1000 else reasoning[:997] + "..."
+            content.append(display_reasoning)
+        else:
+            content.append("(no reasoning captured)", style="dim")
+
+        # Output data summary if present
+        output = node.get("output_data")
+        if output and isinstance(output, dict):
+            content.append("\n\nOutput keys: ", style="bold")
+            content.append(", ".join(output.keys()), style="dim")
+
+        border = "green" if node_status == "completed" else "red" if node_status == "failed" else "yellow"
+        console.print(
+            Panel(
+                content,
+                title=f"[{i}/{len(nodes)}] {name}",
+                subtitle=subtitle,
+                border_style=border,
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# Pattern Recommendations
+# ---------------------------------------------------------------------------
+
+def format_pattern_recommendations(
+    patterns: list[dict[str, Any]],
+    framework: str | None = None,
+    control: str | None = None,
+) -> None:
+    """Render pattern recommendations as Rich panels with reasoning chains."""
+    if not patterns:
+        console.print("[dim]No matching golden patterns found.[/dim]")
+        return
+
+    title = "Golden Pattern Recommendations"
+    if framework and control:
+        title += f" for {framework}/{control}"
+
+    tbl = Table(title=title, show_lines=True)
+    tbl.add_column("Pattern", style="bold", max_width=30)
+    tbl.add_column("Type", width=12)
+    tbl.add_column("Satisfaction", justify="center", width=14)
+    tbl.add_column("Confidence", justify="right", width=12)
+    tbl.add_column("Controls", max_width=30)
+
+    for p in patterns:
+        # Handle both search results and recommendation results
+        name = p.get("pattern_name", p.get("name", ""))
+        ptype = p.get("pattern_type", "")
+        sat = p.get("satisfaction_level", "")
+        conf = p.get("confidence", 0)
+
+        controls = p.get("controls_satisfied", [])
+        ctrl_str = ", ".join(c.get("control_id", "") for c in controls[:4]) if controls else ""
+
+        conf_style = "green" if conf >= 0.8 else "yellow" if conf >= 0.5 else "red"
+        tbl.add_row(
+            name, ptype, sat,
+            Text(f"{conf:.0%}" if conf else "", style=conf_style),
+            ctrl_str,
+        )
+
+    console.print(tbl)
+
+    # Show reasoning chains for top recommendations
+    for p in patterns[:3]:
+        chain = p.get("reasoning_chain", {})
+        if not chain:
+            continue
+
+        steps = chain.get("steps", [])
+        if not steps:
+            continue
+
+        content = Text()
+        for step in steps[:5]:
+            content.append(f"\n{step.get('step', '?')}. [{step.get('phase', '')}] ", style="bold")
+            content.append(step.get("reasoning", "")[:200])
+            content.append(f"\n   → {step.get('output', '')[:150]}", style="dim")
+
+        conclusion = chain.get("final_conclusion", "")
+        if conclusion:
+            content.append(f"\n\nConclusion: ", style="bold green")
+            content.append(conclusion[:200])
+
+        console.print(Panel(
+            content,
+            title=f"Reasoning: {p.get('pattern_name', p.get('name', ''))}",
+            border_style="cyan",
+        ))
+
+
+# ---------------------------------------------------------------------------
+# Review Queue
+# ---------------------------------------------------------------------------
+
+_PRIORITY_COLOURS = {
+    "critical": "bold red",
+    "high": "red",
+    "medium": "yellow",
+    "low": "cyan",
+}
+
+
+def format_review_queue(items: list[dict[str, Any]]) -> None:
+    """Render pending review queue items as a Rich table."""
+    if not items:
+        console.print("[green]Review queue is empty — nothing pending.[/green]")
+        return
+
+    tbl = Table(title=f"Review Queue ({len(items)} pending)", show_lines=True)
+    tbl.add_column("Priority", justify="center", width=10)
+    tbl.add_column("Type", width=18)
+    tbl.add_column("Control", width=14)
+    tbl.add_column("Reason", max_width=25)
+    tbl.add_column("Status", width=12)
+    tbl.add_column("Assigned To", max_width=20)
+    tbl.add_column("Created", width=16)
+
+    for item in items:
+        p = item.get("priority", "medium")
+        tbl.add_row(
+            Text(p.upper(), style=_PRIORITY_COLOURS.get(p, "")),
+            item.get("target_type", ""),
+            item.get("control_id", "") or "",
+            item.get("queue_reason", ""),
+            item.get("status", "pending"),
+            item.get("assigned_to", "") or "--",
+            (item.get("created_at", "") or "")[:16],
+        )
+
+    console.print(tbl)
+
+
+def format_review_queue_stats(data: dict[str, Any]) -> None:
+    """Render review queue statistics."""
+    total = data.get("total", 0)
+    by_status = data.get("by_status", {})
+    by_target = data.get("by_target_type", {})
+    by_priority = data.get("by_priority", {})
+    avg_time = data.get("avg_time_to_review_hours")
+
+    header = Text()
+    header.append(f"Total items: {total}\n", style="bold")
+    if avg_time is not None:
+        header.append(f"Avg time to review: {avg_time:.1f} hours\n")
+
+    header.append("\nBy Status: ", style="bold")
+    for s, c in by_status.items():
+        header.append(f"  {s}: {c}")
+
+    header.append("\nBy Priority: ", style="bold")
+    for p, c in sorted(by_priority.items()):
+        header.append(f"  {p}: {c}")
+
+    header.append("\nBy Type: ", style="bold")
+    for t, c in by_target.items():
+        header.append(f"  {t}: {c}")
+
+    console.print(Panel(header, title="Review Queue Statistics"))
+
+
+# ---------------------------------------------------------------------------
+# Pattern Validation
+# ---------------------------------------------------------------------------
+
+_VALIDATION_COLOURS = {
+    "passed": "bold green",
+    "partial": "yellow",
+    "failed": "bold red",
+    "needs_policy": "magenta",
+    "pending": "dim",
+    "validating": "cyan",
+}
+
+
+def format_pattern_validation(data: dict[str, Any]) -> None:
+    """Render pattern validation results."""
+    pattern_name = data.get("pattern_name", "Unknown")
+    status = data.get("validation_status", "unknown")
+    summary = data.get("summary", {})
+
+    status_style = _VALIDATION_COLOURS.get(status, "dim")
+    header = Text()
+    header.append("Pattern: ", style="bold")
+    header.append(pattern_name, style="cyan")
+    header.append(f"\nValidation: ", style="bold")
+    header.append(status.upper(), style=status_style)
+    header.append(f"\nClaims: {summary.get('total_claims', 0)}")
+    header.append(f"  Passed: {summary.get('passed', 0)}")
+    header.append(f"  Failed: {summary.get('failed', 0)}")
+    if summary.get("needs_policy", 0):
+        header.append(f"  Needs Policy: {summary.get('needs_policy', 0)}", style="magenta")
+
+    console.print(Panel(header, title="Pattern Validation Result", border_style=status_style))
+
+    # Detail per validation
+    validations = data.get("validations", [])
+    for v in validations:
+        v_status = v.get("overall_status", "unknown")
+        v_style = _VALIDATION_COLOURS.get(v_status, "dim")
+
+        content = Text()
+        content.append(f"Type: {v.get('claim_type', '')}\n")
+        content.append(f"Claim: {v.get('claim_description', '')}\n")
+        content.append(f"Status: ", style="bold")
+        content.append(v_status.upper(), style=v_style)
+        content.append(f"   Confidence: {v.get('confidence', 0):.0%}\n")
+
+        steps = v.get("steps", [])
+        for s in steps:
+            step_status = s.get("status", "")
+            icon = {"passed": "[green]PASS[/green]", "failed": "[red]FAIL[/red]", "warning": "[yellow]WARN[/yellow]"}.get(step_status, step_status)
+            content.append(f"\n  Step {s.get('step', '?')}: [{s.get('type', '')}] {icon}")
+
+        console.print(Panel(content, border_style=v_style))