infini-cli 0.1.0__py3-none-any.whl

infini/engine.py

@@ -0,0 +1,191 @@
+"""INFINI Reference Engine.
+
+Executes a Loopfile: runs the STEPS DAG, enforces BUDGET, runs VERIFY,
+and emits a trace. In mock mode (default for V1), uses the mock LLM
+engine so no API key is required.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from .parse import Loopfile, Step
+from .trace import Trace, add_step, add_verification, finalize_trace, save_trace, new_trace
+from .mock import mock_execute, mock_verify
+
+
+class BudgetExceeded(Exception):
+    pass
+
+
+def run(
+    loopfile: Loopfile,
+    output_dir: str | Path = "runs/latest",
+    mock: bool = True,
+    max_iterations: int = 5,
+    verbose: bool = True,
+) -> Trace:
+    """Execute a Loopfile. Returns the completed Trace.
+
+    Args:
+        loopfile: Parsed Loopfile to run.
+        output_dir: Where to save the trace (run.json).
+        mock: If True, use mock LLM (no API key needed).
+        max_iterations: Hard cap on iterations (overrides STOP_WHEN if lower).
+        verbose: Print progress to stdout.
+    """
+    trace = new_trace(loopfile.name, _serialize(loopfile))
+
+    if verbose:
+        _log(f"▶ engine: infini-reference {'(mock)' if mock else '(live)'}")
+        _log(f"▶ reading state... none found, starting fresh")
+        _log(f"▶ objective: {loopfile.objective}")
+        _log(f"▶ budget: ${loopfile.budget.dollars} / {loopfile.budget.minutes}m")
+
+    outcome = "unverified"
+    lessons: list[str] = []
+
+    for iteration in range(1, max_iterations + 1):
+        trace.iterations = iteration
+        if verbose:
+            _log(f"▶ iteration {iteration}")
+
+        # Execute all steps
+        for step in loopfile.steps:
+            result = _execute_step(loopfile, step, iteration, mock)
+
+            if result.status == "failed" and step.retry:
+                # Retry
+                for attempt in range(1, step.retry.get("max", 3) + 1):
+                    if verbose:
+                        _log(f"  ⚠ {step.id} {step.name} failed, retry {attempt}/{step.retry.get('max', 3)}")
+                    result = _execute_step(loopfile, step, iteration, mock, retry_attempt=attempt)
+                    if result.status == "ok":
+                        break
+
+            add_step(
+                trace, step.id, step.name,
+                agent=step.uses, action=step.action,
+                artifacts=result.artifacts,
+                cost_dollars=result.cost_dollars,
+                cost_minutes=result.cost_minutes,
+                tokens_in=result.tokens_in,
+                tokens_out=result.tokens_out,
+                status=result.status,
+                retry_attempt=result.retry_attempt,
+            )
+
+            if verbose:
+                status_icon = "✓" if result.status == "ok" else "⚠"
+                _log(f"  {status_icon} {step.id} {step.name}  ${result.cost_dollars:.2f} · {result.cost_minutes:.1f}m")
+
+            # Check budget
+            if trace.budget["spent_dollars"] >= loopfile.budget.dollars:
+                outcome = "budget_exceeded"
+                if verbose:
+                    _log(f"  ✗ budget exceeded (${trace.budget['spent_dollars']:.2f} / ${loopfile.budget.dollars})")
+                finalize_trace(trace, outcome, lessons)
+                save_trace(trace, Path(output_dir) / "run.json")
+                return trace
+
+            if trace.budget["spent_minutes"] >= loopfile.budget.minutes:
+                outcome = "budget_exceeded"
+                if verbose:
+                    _log(f"  ✗ budget exceeded ({trace.budget['spent_minutes']:.1f}m / {loopfile.budget.minutes}m)")
+                finalize_trace(trace, outcome, lessons)
+                save_trace(trace, Path(output_dir) / "run.json")
+                return trace
+
+        # Run verification
+        if verbose:
+            _log(f"▶ verification:")
+        all_passed = True
+        confidences: list[float] = []
+
+        for check in loopfile.verify.syntactic:
+            passed, _ = mock_verify(check, loopfile.name, iteration, loopfile.verify.confidence_threshold) if mock else (True, None)
+            add_verification(trace, check, passed, confidence=None)
+            if verbose:
+                _log(f"  {'✓' if passed else '✗'} {check}")
+            if not passed:
+                all_passed = False
+
+        for check in loopfile.verify.semantic:
+            passed, conf = mock_verify(check, loopfile.name, iteration, loopfile.verify.confidence_threshold) if mock else (True, 90.0)
+            add_verification(trace, check, passed, confidence=conf)
+            if conf is not None:
+                confidences.append(conf)
+            if verbose:
+                _log(f"  {'✓' if passed else '✗'} {check} (conf {conf})" if conf else f"  {'✓' if passed else '✗'} {check}")
+            if not passed:
+                all_passed = False
+
+        # Check confidence threshold
+        if confidences:
+            mean_conf = sum(confidences) / len(confidences)
+            if mean_conf < loopfile.verify.confidence_threshold:
+                all_passed = False
+                if verbose:
+                    _log(f"  ✗ mean confidence {mean_conf:.1f} < threshold {loopfile.verify.confidence_threshold}")
+
+        if all_passed:
+            outcome = "verified"
+            lesson = f"{loopfile.name} shipped at iteration {iteration} with mean confidence {sum(confidences)/len(confidences):.1f}." if confidences else f"{loopfile.name} shipped at iteration {iteration}."
+            lessons.append(lesson)
+            if verbose:
+                _log(f"✓ shipped. state saved. lessons appended.")
+            break
+
+        # Check stop conditions
+        if "iterations>=" + str(max_iterations) in loopfile.stop_when:
+            break
+        if iteration >= max_iterations:
+            break
+
+    finalize_trace(trace, outcome, lessons)
+    save_trace(trace, Path(output_dir) / "run.json")
+
+    if verbose:
+        _log(f"▶ cost: ${trace.budget['spent_dollars']:.2f} / ${loopfile.budget.dollars} · {trace.budget['spent_minutes']:.1f}m / {loopfile.budget.minutes}m")
+        _log(f"▶ outcome: {outcome}")
+        _log(f"▶ trace: {Path(output_dir) / 'run.json'}")
+
+    return trace
+
+
+def _execute_step(
+    loopfile: Loopfile,
+    step: Step,
+    iteration: int,
+    mock: bool,
+    retry_attempt: int = 0,
+):
+    """Execute a single step. Returns a MockResult (or equivalent)."""
+    if mock:
+        # Find the agent
+        agent = next((a for a in loopfile.agents if a.name == step.uses), None)
+        model_tier = agent.model_tier if agent else "sonnet"
+        role = agent.role if agent else "builder"
+        return mock_execute(
+            step_id=step.id, step_name=step.name, action=step.action,
+            agent_role=role, model_tier=model_tier, produces=step.produces,
+            loopfile_name=loopfile.name, iteration=iteration,
+            retry_attempt=retry_attempt,
+        )
+    else:
+        # Live mode: not implemented in V1 (requires adapter)
+        raise NotImplementedError(
+            "Live execution requires an engine adapter. Use --mock for now, "
+            "or install infini-cli[hermes] / infini-cli[openclaw] when adapters ship."
+        )
+
+
+def _serialize(loopfile: Loopfile) -> str:
+    """Serialize a Loopfile back to YAML for hashing."""
+    import yaml
+    from .parse import to_dict
+    return yaml.dump(to_dict(loopfile), sort_keys=False, default_flow_style=False)
+
+
+def _log(msg: str) -> None:
+    """Print to stdout."""
+    print(msg)

infini/inspect.py

@@ -0,0 +1,102 @@
+"""Trace inspector — `infini inspect`.
+
+Prints a human-readable summary of a trace to the terminal.
+The Observatory UI (infini ui) provides the full visual experience.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+from .trace import load_trace
+
+console = Console()
+
+
+def inspect(run_dir: str | Path) -> None:
+    """Inspect a run trace. Prints a summary to stdout."""
+    run_dir = Path(run_dir)
+    trace_path = run_dir / "run.json" if (run_dir / "run.json").exists() else run_dir
+    trace = load_trace(trace_path)
+
+    # Header
+    console.print(Panel.fit(
+        f"[bold]{trace.get('loopfile', 'unknown')}[/bold]\n"
+        f"engine: {trace.get('engine', {}).get('type', '?')}  ·  "
+        f"outcome: {_outcome_color(trace.get('outcome', '?'))}  ·  "
+        f"iterations: {trace.get('iterations', 0)}",
+        border_style="bright_blue",
+    ))
+
+    # Budget
+    budget = trace.get("budget", {})
+    console.print(f"\n[bold]Budget[/bold]")
+    console.print(f"  dollars: ${budget.get('spent_dollars', 0):.2f}")
+    console.print(f"  minutes: {budget.get('spent_minutes', 0):.1f}m")
+
+    # Steps
+    steps = trace.get("steps", [])
+    if steps:
+        table = Table(title="\nSteps", show_lines=False)
+        table.add_column("ID", style="dim")
+        table.add_column("Name", style="bold")
+        table.add_column("Status")
+        table.add_column("Cost", justify="right")
+        table.add_column("Time", justify="right")
+        table.add_column("Artifacts", style="dim")
+
+        for s in steps:
+            status = s.get("status", "?")
+            status_str = f"[green]✓ {status}[/green]" if status == "ok" else f"[yellow]⚠ {status}[/yellow]"
+            cost = s.get("cost", {})
+            table.add_row(
+                s.get("id", ""),
+                s.get("name", ""),
+                status_str,
+                f"${cost.get('dollars', 0):.2f}",
+                f"{cost.get('minutes', 0):.1f}m",
+                ", ".join(s.get("artifacts", [])) or "—",
+            )
+        console.print(table)
+
+    # Verifications
+    verifs = trace.get("verifications", [])
+    if verifs:
+        vtable = Table(title="\nVerification")
+        vtable.add_column("Check", style="bold")
+        vtable.add_column("Status")
+        vtable.add_column("Confidence", justify="right")
+        for v in verifs:
+            status = v.get("status", "?")
+            status_str = f"[green]PASS[/green]" if status == "pass" else f"[red]FAIL[/red]"
+            conf = v.get("confidence")
+            conf_str = f"{conf:.0f}" if conf is not None else "—"
+            vtable.add_row(v.get("check", ""), status_str, conf_str)
+        console.print(vtable)
+
+    # Lessons
+    lessons = trace.get("lessons", [])
+    if lessons:
+        console.print(f"\n[bold]Lessons[/bold]")
+        for l in lessons:
+            console.print(f"  • {l}")
+
+    # Footer
+    console.print(f"\n[dim]Trace: {trace_path}[/dim]")
+    console.print(f"[dim]Open in Observatory: infini ui {trace_path}[/dim]")
+
+
+def _outcome_color(outcome: str) -> str:
+    colors = {
+        "verified": "[green]verified[/green]",
+        "unverified": "[red]unverified[/red]",
+        "budget_exceeded": "[red]budget_exceeded[/red]",
+        "escalated": "[yellow]escalated[/yellow]",
+        "error": "[red]error[/red]",
+        "running": "[blue]running[/blue]",
+    }
+    return colors.get(outcome, outcome)

infini/mock.py

@@ -0,0 +1,108 @@
+"""Mock LLM engine.
+
+Simulates agent execution without calling any real model. This is what
+makes `infini run --mock` work without an API key — users can see the
+full loop execute, produce artifacts, emit traces, and pass/fail
+verification, all deterministically.
+
+The mock is deterministic: same Loopfile + same seed = same output.
+This is essential for replay fidelity and for the conformance suite.
+"""
+from __future__ import annotations
+
+import hashlib
+import random
+from dataclasses import dataclass
+
+
+@dataclass
+class MockResult:
+    """The result of a mocked step execution."""
+    artifacts: list[str]
+    cost_dollars: float
+    cost_minutes: float
+    tokens_in: int
+    tokens_out: int
+    status: str = "ok"
+    retry_attempt: int | None = None
+
+
+def _seed_from(loopfile_name: str, step_id: str, iteration: int) -> int:
+    """Deterministic seed from loop name + step + iteration."""
+    h = hashlib.sha256(f"{loopfile_name}:{step_id}:{iteration}".encode()).hexdigest()
+    return int(h[:8], 16)
+
+
+def mock_execute(
+    step_id: str,
+    step_name: str,
+    action: str,
+    agent_role: str,
+    model_tier: str,
+    produces: list[str],
+    loopfile_name: str,
+    iteration: int,
+    retry_attempt: int = 0,
+) -> MockResult:
+    """Execute a step in mock mode. Returns a MockResult."""
+    rng = random.Random(_seed_from(loopfile_name, step_id, iteration + retry_attempt))
+
+    # Cost model (rough, model-tier-based)
+    tier_multipliers = {"haiku": 0.5, "sonnet": 1.0, "opus": 3.0, "gpt-4o": 1.2}
+    mult = tier_multipliers.get(model_tier, 1.0)
+
+    tokens_in = rng.randint(800, 3000)
+    tokens_out = rng.randint(200, 1200)
+    cost_dollars = round((tokens_in * 0.000003 + tokens_out * 0.000015) * mult, 4)
+    cost_minutes = round(rng.uniform(0.3, 1.8), 2)
+
+    # Artifacts: produce what the step declares
+    artifacts = list(produces)
+
+    # Status: mostly ok, occasionally retried
+    status = "ok"
+    if retry_attempt == 0 and rng.random() < 0.15:
+        # 15% chance of a transient failure on first attempt
+        status = "failed"
+    elif retry_attempt > 0:
+        status = "ok"  # retries usually succeed
+
+    return MockResult(
+        artifacts=artifacts,
+        cost_dollars=cost_dollars,
+        cost_minutes=cost_minutes,
+        tokens_in=tokens_in,
+        tokens_out=tokens_out,
+        status=status,
+        retry_attempt=retry_attempt if retry_attempt > 0 else None,
+    )
+
+
+def mock_verify(
+    check: str,
+    loopfile_name: str,
+    iteration: int,
+    confidence_threshold: int,
+) -> tuple[bool, float | None]:
+    """Mock a verification check. Returns (passed, confidence).
+
+    Syntactic checks (no 'judge:' prefix) mostly pass.
+    Semantic checks return a confidence score; iteration 1 is usually
+    below threshold, iteration 2+ usually passes.
+    """
+    rng = random.Random(_seed_from(loopfile_name, check, iteration))
+
+    if check.startswith("judge:") or check.startswith("rubric:"):
+        # Semantic check
+        if iteration == 1:
+            # First iteration: likely below threshold
+            conf = rng.randint(max(0, confidence_threshold - 15), confidence_threshold - 1)
+        else:
+            # Subsequent iterations: likely above threshold
+            conf = rng.randint(confidence_threshold, min(100, confidence_threshold + 12))
+        passed = conf >= confidence_threshold
+        return passed, float(conf)
+    else:
+        # Syntactic check: 95% pass rate
+        passed = rng.random() < 0.95
+        return passed, None

infini/parse.py

@@ -0,0 +1,207 @@
+"""Loopfile parser and validator.
+
+Reads a YAML Loopfile, validates it against the INFINI JSON Schema,
+and returns a structured Loopfile object.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+from jsonschema import Draft202012Validator
+
+_SCHEMA_PATH = Path(__file__).parent / "schema.json"
+
+
+@dataclass
+class Agent:
+    name: str
+    role: str
+    model_tier: str
+    tools: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Step:
+    id: str
+    name: str
+    action: str
+    uses: str
+    produces: list[str] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+    retry: dict | None = None
+
+
+@dataclass
+class Verify:
+    syntactic: list[str]
+    semantic: list[str]
+    confidence_threshold: int
+
+
+@dataclass
+class Budget:
+    dollars: float
+    minutes: float
+    tokens: int | None = None
+
+
+@dataclass
+class Loopfile:
+    spec_version: str
+    name: str
+    version: str
+    description: str | None
+    objective: str
+    agents: list[Agent]
+    steps: list[Step]
+    verify: Verify
+    budget: Budget
+    stop_when: list[str]
+    lessons: dict | None = None
+    state: dict | None = None
+    engine: dict | None = None
+    raw: dict = field(default_factory=dict, repr=False)
+
+
+class ParseError(Exception):
+    """Raised when a Loopfile is invalid."""
+
+    def __init__(self, message: str, errors: list[dict] | None = None):
+        super().__init__(message)
+        self.errors = errors or []
+
+
+def _load_schema() -> dict:
+    with open(_SCHEMA_PATH) as f:
+        return json.load(f)
+
+
+def parse(yaml_str: str) -> Loopfile:
+    """Parse a YAML string into a Loopfile. Raises ParseError on invalid input."""
+    try:
+        raw = yaml.safe_load(yaml_str)
+    except yaml.YAMLError as e:
+        raise ParseError(f"YAML parse error: {e}")
+
+    if not isinstance(raw, dict):
+        raise ParseError("Loopfile must be a YAML mapping at the top level.")
+
+    # Validate against JSON Schema
+    schema = _load_schema()
+    validator = Draft202012Validator(schema)
+    errors = sorted(validator.iter_errors(raw), key=lambda e: list(e.absolute_path))
+    if errors:
+        msgs = []
+        for err in errors:
+            path = ".".join(str(p) for p in err.absolute_path) or "<root>"
+            msgs.append(f"  {path}: {err.message}")
+        raise ParseError(
+            f"Loopfile failed schema validation ({len(errors)} error(s)):\n" + "\n".join(msgs),
+            errors=[{"path": list(e.absolute_path), "message": e.message} for e in errors],
+        )
+
+    # Build structured object
+    return _build_loopfile(raw)
+
+
+def parse_file(path: str | Path) -> Loopfile:
+    """Parse a Loopfile from a file path."""
+    path = Path(path)
+    if not path.exists():
+        raise ParseError(f"File not found: {path}")
+    return parse(path.read_text())
+
+
+def _build_loopfile(raw: dict) -> Loopfile:
+    agents = [
+        Agent(
+            name=a["name"],
+            role=a["role"],
+            model_tier=a["model_tier"],
+            tools=a.get("tools", []),
+        )
+        for a in raw["AGENTS"]
+    ]
+
+    steps = []
+    for s in raw["STEPS"]:
+        steps.append(
+            Step(
+                id=s["id"],
+                name=s["name"],
+                action=s["action"],
+                uses=s["uses"],
+                produces=s.get("produces", []),
+                depends_on=s.get("depends_on", []),
+                retry=s.get("retry"),
+            )
+        )
+
+    verify = Verify(
+        syntactic=raw["VERIFY"]["syntactic"],
+        semantic=raw["VERIFY"]["semantic"],
+        confidence_threshold=raw["VERIFY"]["confidence_threshold"],
+    )
+
+    budget = Budget(
+        dollars=raw["BUDGET"]["dollars"],
+        minutes=raw["BUDGET"]["minutes"],
+        tokens=raw["BUDGET"].get("tokens"),
+    )
+
+    return Loopfile(
+        spec_version=raw["LOOPFILE"],
+        name=raw["name"],
+        version=raw["version"],
+        description=raw.get("description"),
+        objective=raw["OBJECTIVE"],
+        agents=agents,
+        steps=steps,
+        verify=verify,
+        budget=budget,
+        stop_when=raw["STOP_WHEN"],
+        lessons=raw.get("LESSONS"),
+        state=raw.get("STATE"),
+        engine=raw.get("ENGINE"),
+        raw=raw,
+    )
+
+
+def to_dict(loopfile: Loopfile) -> dict:
+    """Serialize a Loopfile back to a dict (for trace emission)."""
+    return {
+        "LOOPFILE": loopfile.spec_version,
+        "name": loopfile.name,
+        "version": loopfile.version,
+        "description": loopfile.description,
+        "OBJECTIVE": loopfile.objective,
+        "AGENTS": [
+            {"name": a.name, "role": a.role, "model_tier": a.model_tier, "tools": a.tools}
+            for a in loopfile.agents
+        ],
+        "STEPS": [
+            {
+                "id": s.id, "name": s.name, "action": s.action, "uses": s.uses,
+                "produces": s.produces, "depends_on": s.depends_on, "retry": s.retry,
+            }
+            for s in loopfile.steps
+        ],
+        "VERIFY": {
+            "syntactic": loopfile.verify.syntactic,
+            "semantic": loopfile.verify.semantic,
+            "confidence_threshold": loopfile.verify.confidence_threshold,
+        },
+        "BUDGET": {
+            "dollars": loopfile.budget.dollars,
+            "minutes": loopfile.budget.minutes,
+            "tokens": loopfile.budget.tokens,
+        },
+        "STOP_WHEN": loopfile.stop_when,
+        "LESSONS": loopfile.lessons,
+        "STATE": loopfile.state,
+        "ENGINE": loopfile.engine,
+    }