hegelion 0.4.0__py3-none-any.whl

hegelion/scripts/hegelion_agent_cli.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+"""CLI for the adversarial Hegelion agent (thesis → antithesis → synthesis before acting)."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Optional, Sequence
+
+if __package__ is None or __package__ == "":  # pragma: no cover - direct execution fallback
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from hegelion.core.agent import HegelionAgent
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Adversarial reflexion agent: critiques plans before acting."
+    )
+    parser.add_argument("observation", help="Current observation/state to act on")
+    parser.add_argument("--goal", help="Optional high-level goal", default=None)
+    parser.add_argument("--personas", help="Critic persona preset (e.g., council)")
+    parser.add_argument("--iterations", type=int, default=1, help="Refinement loops")
+    parser.add_argument("--use-search", action="store_true", help="Allow search in critique")
+    parser.add_argument("--coding", action="store_true", help="Use coding-focused guidance")
+    parser.add_argument("--format", choices=["json", "text"], default="text")
+    parser.add_argument("--debug", action="store_true", help="Include debug output")
+    parser.add_argument("--log-file", help="Path to append raw agent traces (JSONL)", default=None)
+    return parser
+
+
+def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
+    return build_parser().parse_args(argv)
+
+
+async def run(args: argparse.Namespace) -> int:
+    agent = (
+        HegelionAgent.for_coding(
+            goal=args.goal,
+            personas=args.personas,
+            iterations=args.iterations,
+            use_search=args.use_search,
+            debug=args.debug,
+        )
+        if args.coding
+        else HegelionAgent(
+            goal=args.goal,
+            personas=args.personas,
+            iterations=args.iterations,
+            use_search=args.use_search,
+            debug=args.debug,
+        )
+    )
+
+    step = await agent.act(args.observation)
+
+    if args.log_file:
+        try:
+            log_path = Path(args.log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(json.dumps(step.result.to_dict(), ensure_ascii=False) + "\n")
+        except Exception as e:
+            print(f"Warning: Failed to write to log file {args.log_file}: {e}", file=sys.stderr)
+
+    if args.format == "json":
+        payload = {"action": step.action, "result": step.result.to_dict()}
+        print(json.dumps(payload, indent=2, ensure_ascii=False))
+    else:
+        print(f"Action: {step.action}\n")
+        print("=== THESIS ===")
+        print(step.result.thesis)
+        print("\n=== ANTITHESIS ===")
+        print(step.result.antithesis)
+        print("\n=== SYNTHESIS ===")
+        print(step.result.synthesis)
+
+    return 0
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:  # pragma: no cover - CLI entrypoint
+    args = parse_args(argv)
+    return asyncio.run(run(args))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hegelion/scripts/hegelion_bench.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+"""Benchmark CLI for Hegelion dialectical reasoning."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Optional, Sequence
+
+if __package__ is None or __package__ == "":  # pragma: no cover - direct execution fallback
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from hegelion import run_benchmark
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Run Hegelion dialectical reasoning on multiple prompts."
+    )
+    parser.add_argument(
+        "prompts_file",
+        type=Path,
+        help="Path to JSONL file containing prompts (one JSON object per line)",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Optional path to write results as JSONL",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Include debug information and internal diagnostics",
+    )
+    parser.add_argument(
+        "--summary",
+        action="store_true",
+        help="Print aggregate statistics to stdout after the run",
+    )
+    return parser
+
+
+def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
+    return build_parser().parse_args(argv)
+
+
+def _safe_time(result, key: str) -> float:
+    metadata = result.metadata if isinstance(result.metadata, dict) else {}
+    value = metadata.get(key)
+    if isinstance(value, (int, float)):
+        return float(value)
+    return 0.0
+
+
+def print_summary(results: list) -> None:
+    """Print a summary of benchmark results."""
+    if not results:
+        print("No results to summarize")
+        return
+
+    total = len(results)
+    total_contradictions = sum(len(r.contradictions) for r in results)
+    total_proposals = sum(len(r.research_proposals) for r in results)
+    total_time = sum(_safe_time(r, "total_time_ms") for r in results)
+    thesis_time = sum(_safe_time(r, "thesis_time_ms") for r in results)
+    antithesis_time = sum(_safe_time(r, "antithesis_time_ms") for r in results)
+    synthesis_time = sum(_safe_time(r, "synthesis_time_ms") for r in results)
+
+    def _avg(total_value: float) -> float:
+        return total_value / total if total else 0.0
+
+    print("HEGELION BENCHMARK SUMMARY")
+    print(f"Total queries processed: {total}")
+    print(f"Contradictions: {total_contradictions} (avg: {_avg(total_contradictions):.1f})")
+    print(f"Research proposals: {total_proposals} (avg: {_avg(total_proposals):.1f})")
+    print(f"Total time: {total_time:.0f}ms (avg: {_avg(total_time):.0f}ms per query)")
+    print(f"Thesis time total/avg: {thesis_time:.0f}ms / {_avg(thesis_time):.0f}ms")
+    print(f"Antithesis time total/avg: {antithesis_time:.0f}ms / {_avg(antithesis_time):.0f}ms")
+    print(f"Synthesis time total/avg: {synthesis_time:.0f}ms / {_avg(synthesis_time):.0f}ms")
+    print("")
+
+
+async def _run(args: argparse.Namespace) -> None:
+    if not args.prompts_file.exists():
+        raise FileNotFoundError(f"Prompts file not found: {args.prompts_file}")
+
+    results = await run_benchmark(
+        prompts=args.prompts_file,
+        output_file=args.output,
+        debug=args.debug,
+    )
+
+    if args.summary:
+        print_summary(results)
+
+    if not args.output:
+        for result in results:
+            print(json.dumps(result.to_dict(), ensure_ascii=False))
+
+    print(f"Processed {len(results)} queries", file=sys.stderr)
+
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    args = parse_args(argv)
+    try:
+        asyncio.run(_run(args))
+    except Exception as exc:  # pragma: no cover - CLI error surface
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":  # pragma: no cover - CLI entrypoint
+    main()