agentic-ci 0.1.0__py3-none-any.whl

agentic_ci/cli.py

@@ -0,0 +1,91 @@
+"""CLI entry point for agentic-ci."""
+
+import argparse
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="agentic-ci",
+        description="Tooling for running AI coding agents in CI/CD environments",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # setup
+    p_setup = sub.add_parser("setup", help="Bootstrap CI container")
+    p_setup.add_argument("--workspace", default=None)
+    p_setup.add_argument("--user", default="claude-ci")
+
+    # run
+    p_run = sub.add_parser("run", help="Run Claude Code with telemetry")
+    p_run.add_argument("prompt")
+    p_run.add_argument("workdir", nargs="?", default=".")
+    p_run.add_argument("--model", default=None)
+
+    # stream
+    p_stream = sub.add_parser("stream", help="Parse stream-json from stdin")
+    p_stream.add_argument("--wrap", type=int, default=0, metavar="COLS")
+    p_stream.add_argument("--no-color", action="store_true")
+    p_stream.add_argument("--claude-pid", type=int, default=0)
+
+    # otel-collect
+    sub.add_parser("otel-collect", help="Start OTLP metrics collector")
+
+    # otel-summary
+    p_summary = sub.add_parser("otel-summary", help="Print token/cost summary")
+    p_summary.add_argument("log_file", nargs="?", default="/tmp/claude-otel.jsonl")
+
+    # extract
+    p_extract = sub.add_parser("extract", help="Extract JSON result from stream output")
+    p_extract.add_argument("stream_file")
+    p_extract.add_argument("output_dir")
+
+    args = parser.parse_args()
+
+    if args.command == "setup":
+        from agentic_ci.setup import setup
+        setup(workspace=args.workspace, user=args.user)
+
+    elif args.command == "run":
+        from agentic_ci.runner import run
+        sys.exit(run(args.prompt, args.workdir, model=args.model))
+
+    elif args.command == "stream":
+        from agentic_ci.stream import StreamProcessor
+        processor = StreamProcessor(
+            color=not args.no_color,
+            wrap=args.wrap,
+            claude_pid=args.claude_pid,
+        )
+        processor.process(sys.stdin)
+        print()
+
+    elif args.command == "otel-collect":
+        from agentic_ci.otel_collector import main as collector_main
+        collector_main()
+
+    elif args.command == "otel-summary":
+        from agentic_ci.otel_summary import print_summary
+        print_summary(args.log_file)
+
+    elif args.command == "extract":
+        from agentic_ci.extract import extract_text_from_stream, parse_result, write_outputs
+        import json
+        text = extract_text_from_stream(args.stream_file)
+        if not text:
+            print("Error: no text content found", file=sys.stderr)
+            sys.exit(1)
+        try:
+            result = parse_result(text)
+        except json.JSONDecodeError as e:
+            print(f"Error: could not parse JSON: {e}", file=sys.stderr)
+            sys.exit(1)
+        write_outputs(result, args.output_dir)
+
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

agentic_ci/extract.py

@@ -0,0 +1,114 @@
+"""Extract structured JSON result from Claude's stream-json output.
+
+Reads the stream-json capture file, extracts the final text content,
+parses it as JSON, and writes individual fields to an output directory.
+"""
+
+import json
+import os
+import re
+import sys
+
+
+def extract_text_from_stream(stream_file):
+    """Reassemble the full text content from stream-json deltas."""
+    text = ""
+    with open(stream_file) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                msg = json.loads(line)
+            except (json.JSONDecodeError, ValueError):
+                continue
+
+            if msg.get("type") != "stream_event":
+                continue
+
+            event = msg.get("event", {})
+            if event.get("type") == "content_block_delta":
+                delta = event.get("delta", {})
+                if delta.get("type") == "text_delta":
+                    text += delta.get("text", "")
+
+    return text
+
+
+def parse_result(text):
+    """Parse the JSON result from Claude's text output.
+
+    Claude may output explanatory text before/after the JSON, and may
+    wrap the JSON in markdown code fences.
+    """
+    fence_match = re.search(r"```(?:json)?\s*\n(.*?)\n\s*```", text, re.DOTALL)
+    if fence_match:
+        try:
+            return json.loads(fence_match.group(1).strip())
+        except json.JSONDecodeError:
+            pass
+
+    brace_start = text.find("{")
+    if brace_start >= 0:
+        depth = 0
+        for i in range(brace_start, len(text)):
+            if text[i] == "{":
+                depth += 1
+            elif text[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    try:
+                        return json.loads(text[brace_start:i + 1])
+                    except json.JSONDecodeError:
+                        pass
+                    break
+
+    return json.loads(text.strip())
+
+
+def write_outputs(result, output_dir):
+    """Write structured fields to individual files in output_dir."""
+    os.makedirs(output_dir, exist_ok=True)
+
+    fields = {
+        "recommendation": str(result.get("recommendation", "unknown")),
+        "confidence": str(result.get("confidence", 0.0)),
+        "severity": str(result.get("severity", "unknown")),
+        "manipulation_detected": str(result.get("manipulation_detected", False)).lower(),
+        "analysis": str(result.get("analysis", "")),
+    }
+
+    for field, value in fields.items():
+        with open(os.path.join(output_dir, field), "w") as f:
+            f.write(value)
+
+    with open(os.path.join(output_dir, "result.json"), "w") as f:
+        json.dump(result, f, indent=2)
+
+
+def main(args=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Extract JSON result from Claude stream output")
+    parser.add_argument("stream_file", help="Path to stream-json capture file")
+    parser.add_argument("output_dir", help="Directory to write extracted fields")
+    parsed = parser.parse_args(args)
+
+    text = extract_text_from_stream(parsed.stream_file)
+    if not text:
+        print("Error: no text content found in stream output", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        result = parse_result(text)
+    except json.JSONDecodeError as e:
+        print(f"Error: could not parse JSON from Claude output: {e}", file=sys.stderr)
+        print(f"Raw text:\n{text[:500]}", file=sys.stderr)
+        sys.exit(1)
+
+    write_outputs(result, parsed.output_dir)
+    print(f"Result extracted to {parsed.output_dir}/", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

agentic_ci/otel_collector.py

@@ -0,0 +1,104 @@
+"""Lightweight OTLP HTTP/JSON receiver that writes payloads to a log file.
+
+Listens on localhost and accepts OTLP HTTP/JSON exports for metrics
+and logs, writing them to a structured log file for later analysis.
+
+Also tracks token usage over time and writes a rate file for live
+tokens/sec display.
+"""
+
+import json
+import os
+import signal
+import sys
+import time
+from datetime import datetime, timezone
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+_token_samples = []
+_WINDOW_SECS = 60
+
+
+class OTLPHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        length = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(length) if length else b""
+        try:
+            payload = json.loads(body) if body else {}
+        except json.JSONDecodeError:
+            payload = {"raw": body.decode("utf-8", errors="replace")}
+
+        record = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "path": self.path,
+            "payload": payload,
+        }
+        log_file = os.environ.get("OTEL_LOG_FILE", "/tmp/claude-otel.jsonl")
+        with open(log_file, "a") as f:
+            f.write(json.dumps(record) + "\n")
+
+        if "/v1/metrics" in self.path:
+            _update_token_rate(payload)
+
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(b'{"partialSuccess":{}}')
+
+    def log_message(self, format, *args):
+        pass
+
+
+def _update_token_rate(payload):
+    global _token_samples
+    now = time.monotonic()
+    total = 0
+    for rm in payload.get("resourceMetrics", []):
+        for sm in rm.get("scopeMetrics", []):
+            for metric in sm.get("metrics", []):
+                if metric.get("name") == "claude_code.token.usage":
+                    data = metric.get("sum", metric.get("gauge", {}))
+                    for dp in data.get("dataPoints", []):
+                        total += dp.get("asDouble", dp.get("asInt", 0))
+    if total <= 0:
+        return
+
+    _token_samples.append((now, total))
+    cutoff = now - _WINDOW_SECS
+    _token_samples = [(t, v) for t, v in _token_samples if t >= cutoff]
+
+    rate = 0.0
+    if len(_token_samples) >= 2:
+        dt = _token_samples[-1][0] - _token_samples[0][0]
+        dv = _token_samples[-1][1] - _token_samples[0][1]
+        if dt > 0:
+            rate = dv / dt
+
+    rate_file = os.environ.get("OTEL_RATE_FILE", "/tmp/claude-otel-rate.json")
+    tmp = rate_file + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump({"total": total, "rate": rate, "ts": time.time()}, f)
+    os.replace(tmp, rate_file)
+
+
+def main(args=None):
+    port = int(os.environ.get("OTEL_COLLECTOR_PORT", "4318"))
+    server = HTTPServer(("127.0.0.1", port), OTLPHandler)
+    actual_port = server.server_address[1]
+    port_file = os.environ.get("OTEL_PORT_FILE")
+    if port_file:
+        with open(port_file, "w") as f:
+            f.write(str(actual_port))
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+    log_file = os.environ.get("OTEL_LOG_FILE", "/tmp/claude-otel.jsonl")
+    print(f"OTLP collector listening on 127.0.0.1:{actual_port}, writing to {log_file}",
+          file=sys.stderr)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    server.server_close()
+
+
+if __name__ == "__main__":
+    main()

agentic_ci/otel_summary.py

@@ -0,0 +1,139 @@
+"""Parse OTLP JSONL log and print a human-readable token/cost summary."""
+
+import json
+import sys
+from collections import defaultdict
+
+
+def parse_metrics(records):
+    token_totals = defaultdict(float)
+    cost_totals = defaultdict(float)
+    api_requests = []
+    active_time = defaultdict(float)
+
+    for rec in records:
+        path = rec.get("path", "")
+        payload = rec.get("payload", {})
+
+        if "/v1/metrics" in path:
+            for rm in payload.get("resourceMetrics", []):
+                for sm in rm.get("scopeMetrics", []):
+                    for metric in sm.get("metrics", []):
+                        name = metric.get("name", "")
+                        data = metric.get("sum", metric.get("gauge", metric.get("histogram", {})))
+                        for dp in data.get("dataPoints", []):
+                            attrs = {
+                                a["key"]: a["value"].get(
+                                    "stringValue",
+                                    a["value"].get("intValue", a["value"].get("doubleValue")),
+                                )
+                                for a in dp.get("attributes", [])
+                            }
+                            value = dp.get("asDouble", dp.get("asInt", 0))
+
+                            if name == "claude_code.token.usage":
+                                model = attrs.get("model", "unknown")
+                                token_type = attrs.get("type", "unknown")
+                                token_totals[(model, token_type)] += value
+                            elif name == "claude_code.cost.usage":
+                                model = attrs.get("model", "unknown")
+                                cost_totals[model] += value
+                            elif name == "claude_code.active_time.total":
+                                time_type = attrs.get("type", "unknown")
+                                active_time[time_type] += value
+
+        elif "/v1/logs" in path:
+            for rl in payload.get("resourceLogs", []):
+                for sl in rl.get("scopeLogs", []):
+                    for lr in sl.get("logRecords", []):
+                        event_name = ""
+                        event_attrs = {}
+                        for a in lr.get("attributes", []):
+                            key = a["key"]
+                            val = a["value"]
+                            v = val.get("stringValue", val.get("intValue", val.get("doubleValue")))
+                            event_attrs[key] = v
+                            if key == "event.name":
+                                event_name = v
+                        if event_name == "claude_code.api_request":
+                            api_requests.append(event_attrs)
+
+    return token_totals, cost_totals, api_requests, active_time
+
+
+def print_summary(log_file):
+    records = []
+    try:
+        with open(log_file) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    records.append(json.loads(line))
+    except FileNotFoundError:
+        print("No OTEL data collected (log file not found).")
+        return
+    except json.JSONDecodeError as e:
+        print(f"Error parsing OTEL log: {e}")
+        return
+
+    if not records:
+        print("No OTEL data collected.")
+        return
+
+    token_totals, cost_totals, api_requests, active_time = parse_metrics(records)
+
+    print("=" * 60)
+    print("  CLAUDE TOKEN & COST SUMMARY (OpenTelemetry)")
+    print("=" * 60)
+
+    if token_totals:
+        models = sorted(set(m for m, _ in token_totals.keys()))
+        for model in models:
+            print(f"\n  Model: {model}")
+            print(f"  {'Token Type':<20} {'Count':>12}")
+            print(f"  {'-'*20} {'-'*12}")
+            model_tokens = {t: c for (m, t), c in token_totals.items() if m == model}
+            for token_type in ["input", "cacheRead", "cacheCreation", "output"]:
+                if token_type in model_tokens:
+                    print(f"  {token_type:<20} {model_tokens[token_type]:>12,.0f}")
+            total = sum(model_tokens.values())
+            print(f"  {'TOTAL':<20} {total:>12,.0f}")
+
+    if cost_totals:
+        print(f"\n  {'Model':<30} {'Cost (USD)':>12}")
+        print(f"  {'-'*30} {'-'*12}")
+        grand_total = 0.0
+        for model in sorted(cost_totals.keys()):
+            cost = cost_totals[model]
+            grand_total += cost
+            print(f"  {model:<30} ${cost:>11.4f}")
+        if len(cost_totals) > 1:
+            print(f"  {'TOTAL':<30} ${grand_total:>11.4f}")
+
+    if active_time:
+        print(f"\n  Active Time:")
+        for time_type, seconds in sorted(active_time.items()):
+            mins, secs = divmod(int(seconds), 60)
+            print(f"    {time_type}: {mins}m {secs}s")
+
+    if api_requests:
+        print(f"\n  API Requests: {len(api_requests)}")
+        total_duration = sum(float(r.get("duration_ms", 0)) for r in api_requests)
+        if total_duration:
+            print(f"  Total API time: {total_duration/1000:.1f}s")
+
+    print("=" * 60)
+
+
+def main(args=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Print Claude OTEL token/cost summary")
+    parser.add_argument("log_file", nargs="?", default="/tmp/claude-otel.jsonl",
+                        help="Path to OTEL JSONL log file")
+    parsed = parser.parse_args(args)
+    print_summary(parsed.log_file)
+
+
+if __name__ == "__main__":
+    main()

agentic_ci/runner.py

@@ -0,0 +1,190 @@
+"""Run Claude Code in CI with streaming output and telemetry.
+
+Starts an OTEL collector, runs Claude with stream-json output,
+displays human-readable progress, and prints a token/cost summary.
+
+When run as root, re-execs itself as a non-root user.
+"""
+
+import os
+import signal
+import subprocess
+import sys
+import time
+
+from agentic_ci.otel_collector import main as collector_main
+from agentic_ci.otel_summary import print_summary
+from agentic_ci.stream import StreamProcessor
+
+
+def run(prompt, workdir=".", model=None, user="claude-ci"):
+    """Run Claude Code with telemetry and streaming output.
+
+    Returns the exit code (0 for success).
+    """
+    if os.getuid() == 0:
+        os.execvp("runuser", [
+            "runuser", "-u", user, "--",
+            sys.executable, "-m", "agentic_ci.runner",
+            prompt, workdir,
+            *(["--model", model] if model else []),
+        ])
+
+    if model is None:
+        model = os.environ.get("CLAUDE_MODEL", "claude-opus-4-6")
+
+    os.environ["PATH"] = os.path.expanduser("~/.local/bin") + ":" + os.environ.get("PATH", "")
+
+    print("--- Preflight checks ---", flush=True)
+    subprocess.run(["claude", "--version"], check=True)
+
+    os.chdir(workdir)
+
+    workspace = os.environ.get("WORKSPACE_DIR")
+    if workspace:
+        run_tmp = os.path.join(workspace, "_run")
+    else:
+        import tempfile
+        run_tmp = tempfile.mkdtemp(prefix="agentic-ci-run.")
+    os.makedirs(run_tmp, exist_ok=True)
+
+    otel_log = os.path.join(run_tmp, "claude-otel.jsonl")
+    otel_rate = os.path.join(run_tmp, "claude-otel-rate.json")
+    otel_port_file = os.path.join(run_tmp, "otel-port")
+    stderr_log = os.path.join(run_tmp, "claude-stderr.log")
+    stream_capture = os.environ.get(
+        "STREAM_CAPTURE_FILE",
+        os.path.join(run_tmp, "claude-stream-capture.jsonl"),
+    )
+
+    for f in [otel_log, otel_port_file]:
+        try:
+            os.unlink(f)
+        except FileNotFoundError:
+            pass
+
+    # Start OTEL collector with OS-assigned port
+    collector_env = {
+        **os.environ,
+        "OTEL_LOG_FILE": otel_log,
+        "OTEL_RATE_FILE": otel_rate,
+        "OTEL_COLLECTOR_PORT": "0",
+        "OTEL_PORT_FILE": otel_port_file,
+    }
+    collector_proc = subprocess.Popen(
+        [sys.executable, "-m", "agentic_ci.otel_collector"],
+        env=collector_env,
+    )
+
+    # Wait for collector to write its port
+    for _ in range(50):
+        if os.path.exists(otel_port_file):
+            break
+        time.sleep(0.1)
+    else:
+        print("Error: OTEL collector did not write port file", file=sys.stderr)
+        collector_proc.kill()
+        return 1
+
+    with open(otel_port_file) as f:
+        otel_port = f.read().strip()
+    print(f"--- OTEL collector started (pid {collector_proc.pid}, port {otel_port}) ---",
+          flush=True)
+
+    # Configure Claude to export OTEL data
+    os.environ["CLAUDE_CODE_ENABLE_TELEMETRY"] = "1"
+    os.environ["OTEL_METRICS_EXPORTER"] = "otlp"
+    os.environ["OTEL_LOGS_EXPORTER"] = "otlp"
+    os.environ["OTEL_EXPORTER_OTLP_PROTOCOL"] = "http/json"
+    os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = f"http://127.0.0.1:{otel_port}"
+    os.environ["OTEL_METRIC_EXPORT_INTERVAL"] = "10000"
+    os.environ["OTEL_RATE_FILE"] = otel_rate
+
+    # Run Claude
+    with open(stderr_log, "w") as stderr_f, open(stream_capture, "w") as capture_f:
+        claude_proc = subprocess.Popen(
+            [
+                "claude", "-p", prompt,
+                "--model", model,
+                "--dangerously-skip-permissions",
+                "--output-format", "stream-json",
+                "--include-partial-messages",
+                "--verbose",
+            ],
+            stdout=subprocess.PIPE,
+            stderr=stderr_f,
+        )
+
+        processor = StreamProcessor(claude_pid=claude_proc.pid)
+        stream_complete = False
+
+        for line in claude_proc.stdout:
+            text = line.decode("utf-8", errors="replace")
+            capture_f.write(text)
+            capture_f.flush()
+            if processor.process_line(text):
+                stream_complete = True
+                break
+
+    # Ensure Claude is terminated
+    try:
+        claude_proc.kill()
+    except OSError:
+        pass
+    claude_proc.wait()
+    rc = claude_proc.returncode
+
+    # SIGTERM produces 143 (128+15). Treat as success when stream detected completion.
+    if stream_complete and rc != 0:
+        print(f"--- stream processor detected run complete (claude rc={rc}), treating as success ---",
+              flush=True)
+        rc = 0
+
+    # Wait for Claude's final OTEL flush
+    time.sleep(7)
+
+    # Stop OTEL collector
+    collector_proc.terminate()
+    try:
+        collector_proc.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        collector_proc.kill()
+        collector_proc.wait()
+
+    print(f"--- Claude exit code: {rc} ---", flush=True)
+    print("--- stderr log ---", flush=True)
+    with open(stderr_log) as f:
+        sys.stderr.write(f.read())
+
+    print("\n--- OTEL Token/Cost Summary ---", flush=True)
+    print_summary(otel_log)
+
+    # Copy artifacts for CI upload
+    artifact_dir = os.environ.get("GITHUB_WORKSPACE") or os.environ.get("CI_PROJECT_DIR")
+    if artifact_dir:
+        import shutil
+        for src in [otel_log, stderr_log]:
+            try:
+                shutil.copy2(src, artifact_dir)
+            except (OSError, FileNotFoundError):
+                pass
+
+    return rc
+
+
+def main(args=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Run Claude Code in CI with telemetry")
+    parser.add_argument("prompt", help="Prompt to send to Claude")
+    parser.add_argument("workdir", nargs="?", default=".",
+                        help="Working directory (default: .)")
+    parser.add_argument("--model", default=None,
+                        help="Claude model (default: $CLAUDE_MODEL or claude-opus-4-6)")
+    parsed = parser.parse_args(args)
+
+    sys.exit(run(parsed.prompt, parsed.workdir, model=parsed.model))
+
+
+if __name__ == "__main__":
+    main()