infini-cli 0.1.0__py3-none-any.whl

infini/replay.py

@@ -0,0 +1,137 @@
+"""Replay engine — `infini replay`.
+
+Replays a run from a specific step. In V1 (mock mode), this re-executes
+from the named step using the same mock engine. The original trace is
+preserved; the replay produces a new trace with `replay_of` pointing
+back to the original.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rich.console import Console
+
+from .parse import parse_file
+from .trace import load_trace, save_trace, new_trace, add_step, add_verification, finalize_trace
+from .mock import mock_execute, mock_verify
+
+console = Console()
+
+
+def replay(
+    run_dir: str | Path,
+    from_step: str | None = None,
+    mutations: dict | None = None,
+    output_dir: str | Path | None = None,
+    freeze_model_calls: bool = False,
+) -> dict:
+    """Replay a run from a specific step.
+
+    Args:
+        run_dir: Path to the original run directory (containing run.json).
+        from_step: Step ID to replay from. If None, replays the whole run.
+        mutations: Optional dict of input mutations.
+        output_dir: Where to save the replay trace. Defaults to runs/replay-<timestamp>/.
+        freeze_model_calls: If True, reuse the original model responses (bit-exact).
+
+    Returns:
+        The replay trace as a dict.
+    """
+    run_dir = Path(run_dir)
+    trace_path = run_dir / "run.json" if (run_dir / "run.json").exists() else run_dir
+    original = load_trace(trace_path)
+
+    if from_step is None:
+        from_step = original["steps"][0]["id"] if original.get("steps") else "s1"
+
+    console.print(f"[bold]▶ replay[/bold] {original.get('loopfile', '?')} from step [cyan]{from_step}[/cyan]")
+
+    if freeze_model_calls:
+        console.print("[dim]  --freeze-model-calls: using cached model responses[/dim]")
+
+    if mutations:
+        console.print("[dim]  input mutations:[/dim]")
+        for k, v in mutations.items():
+            console.print(f"[dim]    {k}: {v}[/dim]")
+
+    # In V1 mock mode: re-execute from the named step
+    # A real implementation would restore state and resume; the mock just re-runs.
+    replay_steps = []
+    found_step = False
+    for s in original.get("steps", []):
+        if s["id"] == from_step:
+            found_step = True
+        if found_step:
+            replay_steps.append(s)
+
+    if not found_step:
+        console.print(f"[red]Step {from_step} not found in trace[/red]")
+        return {}
+
+    # Create replay trace
+    replay_trace = new_trace(
+        original.get("loopfile", "replay"),
+        json.dumps(original, default=str),
+        engine_type="infini-reference-replay",
+    )
+    replay_trace.replay_of = str(trace_path)
+    replay_trace.replay_from_step = from_step
+
+    console.print(f"[dim]  re-executing {len(replay_steps)} step(s)[/dim]")
+    for s in replay_steps:
+        # In freeze mode, copy the original step's result
+        if freeze_model_calls:
+            from .trace import StepTrace
+            replay_trace.steps.append(StepTrace(
+                id=s["id"], name=s["name"], status=s.get("status", "ok"),
+                started_at=s.get("started_at", ""), ended_at=s.get("ended_at", ""),
+                cost=s.get("cost", {}),
+                artifacts=s.get("artifacts", []),
+                agent=s.get("agent", "builder"),
+                action=s.get("action", ""),
+                retry_attempt=s.get("retry_attempt"),
+            ))
+            replay_trace.budget["spent_dollars"] += s.get("cost", {}).get("dollars", 0)
+            replay_trace.budget["spent_minutes"] += s.get("cost", {}).get("minutes", 0)
+        else:
+            # Re-execute (mock)
+            result = mock_execute(
+                step_id=s["id"], step_name=s["name"], action=s.get("action", ""),
+                agent_role="builder", model_tier="sonnet",
+                produces=s.get("artifacts", []),
+                loopfile_name=original.get("loopfile", "replay"),
+                iteration=original.get("iterations", 1),
+            )
+            add_step(
+                replay_trace, s["id"], s["name"],
+                agent=s.get("agent", "builder"), action=s.get("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_icon = "✓" if s.get("status") == "ok" else "⚠"
+        console.print(f"  {status_icon} {s['id']} {s['name']}")
+
+    # Copy verifications
+    for v in original.get("verifications", []):
+        from .trace import CheckResult
+        replay_trace.verifications.append(CheckResult(
+            check=v.get("check", ""), status=v.get("status", "pass"),
+            confidence=v.get("confidence"), detail=v.get("detail"),
+        ))
+
+    finalize_trace(replay_trace, original.get("outcome", "verified"))
+    replay_trace.iterations = 1
+
+    # Save
+    if output_dir is None:
+        output_dir = f"runs/replay-{from_step}"
+    out_path = save_trace(replay_trace, Path(output_dir) / "run.json")
+    console.print(f"\n[green]✓ replay complete[/green]")
+    console.print(f"[dim]  original: {trace_path}[/dim]")
+    console.print(f"[dim]  replay:   {out_path}[/dim]")
+    console.print(f"[dim]  diff:     infini diff {trace_path} {out_path}[/dim]")
+
+    return replay_trace

infini/schema.json

@@ -0,0 +1,181 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://infini.dev/spec/loopfile-v1.schema.json",
+  "title": "Loopfile v1.0",
+  "description": "JSON Schema for Loopfile v1.0. Used by `infini validate`. INFINI runs Loopfiles.",
+  "type": "object",
+  "required": [
+    "LOOPFILE",
+    "name",
+    "version",
+    "OBJECTIVE",
+    "AGENTS",
+    "STEPS",
+    "VERIFY",
+    "BUDGET",
+    "STOP_WHEN"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "LOOPFILE": {
+      "type": "string",
+      "const": "1.0",
+      "description": "Spec version. Must be exactly '1.0' for v1.0 Loopfiles."
+    },
+    "name": {
+      "type": "string",
+      "pattern": "^[a-z0-9][a-z0-9-]{0,62}$",
+      "description": "Slug identifier. Lowercase, digits, hyphens. Unique within a registry namespace."
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)$",
+      "description": "Semver version of this Loopfile, independent of spec version."
+    },
+    "description": {
+      "type": "string",
+      "maxLength": 280
+    },
+    "OBJECTIVE": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 1000,
+      "description": "Single sentence the loop is trying to satisfy."
+    },
+    "AGENTS": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/agent" }
+    },
+    "STEPS": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/step" }
+    },
+    "VERIFY": { "$ref": "#/$defs/verify" },
+    "BUDGET": { "$ref": "#/$defs/budget" },
+    "STOP_WHEN": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "LESSONS": { "$ref": "#/$defs/lessons" },
+    "STATE":   { "$ref": "#/$defs/state" },
+    "ENGINE":  { "$ref": "#/$defs/engine" }
+  },
+
+  "$defs": {
+    "agent": {
+      "type": "object",
+      "required": ["name", "role", "model_tier"],
+      "additionalProperties": false,
+      "properties": {
+        "name":       { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+        "role": {
+          "type": "string",
+          "enum": ["builder", "verifier", "critic", "researcher", "planner"]
+        },
+        "model_tier": {
+          "type": "string",
+          "description": "Engine-resolved model tier. Common values: haiku, sonnet, opus, gpt-4o, but engines may define their own."
+        },
+        "tools": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    },
+
+    "step": {
+      "type": "object",
+      "required": ["id", "name", "action", "uses"],
+      "additionalProperties": false,
+      "properties": {
+        "id":         { "type": "string", "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$" },
+        "name":       { "type": "string" },
+        "action":     { "type": "string" },
+        "uses":       { "type": "string" },
+        "produces":   { "type": "array", "items": { "type": "string" } },
+        "depends_on": { "type": "array", "items": { "type": "string" } },
+        "retry":      { "$ref": "#/$defs/retry" }
+      }
+    },
+
+    "retry": {
+      "type": "object",
+      "required": ["max", "backoff"],
+      "additionalProperties": false,
+      "properties": {
+        "max":     { "type": "integer", "minimum": 0, "maximum": 10 },
+        "backoff": { "type": "string", "enum": ["constant", "linear", "exponential"] }
+      }
+    },
+
+    "verify": {
+      "type": "object",
+      "required": ["syntactic", "semantic", "confidence_threshold"],
+      "additionalProperties": false,
+      "properties": {
+        "syntactic": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Deterministic checks (exit code, schema, linter)."
+        },
+        "semantic": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Model-judged checks producing a 0-100 confidence."
+        },
+        "confidence_threshold": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100
+        }
+      }
+    },
+
+    "budget": {
+      "type": "object",
+      "required": ["dollars", "minutes"],
+      "additionalProperties": false,
+      "properties": {
+        "dollars": { "type": "number", "exclusiveMinimum": 0 },
+        "minutes": { "type": "number", "exclusiveMinimum": 0 },
+        "tokens":  { "type": "integer", "minimum": 1 }
+      }
+    },
+
+    "lessons": {
+      "type": "object",
+      "required": ["path", "append"],
+      "additionalProperties": false,
+      "properties": {
+        "path":   { "type": "string" },
+        "append": { "type": "boolean" }
+      }
+    },
+
+    "state": {
+      "type": "object",
+      "required": ["path", "resume"],
+      "additionalProperties": false,
+      "properties": {
+        "path":   { "type": "string" },
+        "resume": { "type": "boolean" }
+      }
+    },
+
+    "engine": {
+      "type": "object",
+      "required": ["type", "adapter"],
+      "additionalProperties": true,
+      "properties": {
+        "type":    { "type": "string" },
+        "adapter": { "type": "string" },
+        "governance": { "type": "object" },
+        "tools":      { "type": "array", "items": { "type": "string" } },
+        "delegates":  { "type": "object" }
+      }
+    }
+  }
+}

infini/trace.py

@@ -0,0 +1,178 @@
+"""Trace emission and loading.
+
+A trace is the `run.json` file every execution produces. It's the
+portable record of what happened — the Observatory reads it, `infini
+replay` reads it, `infini diff` reads it.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _sha256(data: bytes) -> str:
+    return "sha256:" + hashlib.sha256(data).hexdigest()
+
+
+@dataclass
+class StepTrace:
+    id: str
+    name: str
+    status: str  # ok | failed | retried | skipped
+    started_at: str
+    ended_at: str
+    cost: dict  # {dollars, minutes, tokens: {input, output, total}}
+    artifacts: list[str]
+    agent: str
+    action: str
+    retry_attempt: int | None = None
+    extensions: dict = field(default_factory=dict)
+
+
+@dataclass
+class CheckResult:
+    check: str
+    status: str  # pass | fail
+    confidence: float | None = None
+    detail: str | None = None
+
+
+@dataclass
+class Trace:
+    loopfile: str
+    loopfile_hash: str
+    engine: dict
+    started_at: str
+    ended_at: str | None
+    iterations: int
+    steps: list[StepTrace]
+    verifications: list[CheckResult]
+    budget: dict
+    outcome: str  # verified | unverified | budget_exceeded | escalated | error
+    lessons: list[str]
+    provenance: dict
+    extensions: dict = field(default_factory=dict)
+    replay_of: str | None = None
+    replay_from_step: str | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "loopfile": self.loopfile,
+            "loopfile_hash": self.loopfile_hash,
+            "engine": self.engine,
+            "started_at": self.started_at,
+            "ended_at": self.ended_at,
+            "iterations": self.iterations,
+            "steps": [asdict(s) for s in self.steps],
+            "verifications": [asdict(v) for v in self.verifications],
+            "budget": self.budget,
+            "outcome": self.outcome,
+            "lessons": self.lessons,
+            "provenance": self.provenance,
+            "extensions": self.extensions,
+            "replay_of": self.replay_of,
+            "replay_from_step": self.replay_from_step,
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent, default=str)
+
+
+def new_trace(loopfile_name: str, loopfile_yaml: str, engine_type: str = "infini-reference") -> Trace:
+    """Create a fresh Trace at the start of a run."""
+    return Trace(
+        loopfile=loopfile_name,
+        loopfile_hash=_sha256(loopfile_yaml.encode()),
+        engine={"type": engine_type, "version": "1.0.0"},
+        started_at=_now_iso(),
+        ended_at=None,
+        iterations=0,
+        steps=[],
+        verifications=[],
+        budget={"spent_dollars": 0.0, "spent_minutes": 0.0},
+        outcome="running",
+        lessons=[],
+        provenance={
+            "engine_signature": "ed25519:placeholder",
+            "artifact_hashes": {},
+        },
+    )
+
+
+def add_step(
+    trace: Trace,
+    step_id: str,
+    step_name: str,
+    agent: str,
+    action: str,
+    artifacts: list[str],
+    cost_dollars: float = 0.0,
+    cost_minutes: float = 0.0,
+    tokens_in: int = 0,
+    tokens_out: int = 0,
+    status: str = "ok",
+    retry_attempt: int | None = None,
+) -> None:
+    """Append a step to the trace."""
+    started = _now_iso()
+    time.sleep(0.001)  # ensure ended > started
+    ended = _now_iso()
+    trace.steps.append(
+        StepTrace(
+            id=step_id, name=step_name, status=status,
+            started_at=started, ended_at=ended,
+            cost={
+                "dollars": round(cost_dollars, 4),
+                "minutes": round(cost_minutes, 2),
+                "tokens": {"input": tokens_in, "output": tokens_out, "total": tokens_in + tokens_out},
+            },
+            artifacts=artifacts, agent=agent, action=action,
+            retry_attempt=retry_attempt,
+        )
+    )
+    trace.budget["spent_dollars"] = round(trace.budget["spent_dollars"] + cost_dollars, 4)
+    trace.budget["spent_minutes"] = round(trace.budget["spent_minutes"] + cost_minutes, 2)
+
+
+def finalize_trace(trace: Trace, outcome: str, lessons: list[str] | None = None) -> None:
+    """Mark the trace as complete."""
+    trace.ended_at = _now_iso()
+    trace.outcome = outcome
+    if lessons:
+        trace.lessons = lessons
+
+
+def add_verification(trace: Trace, check: str, passed: bool, confidence: float | None = None, detail: str | None = None) -> None:
+    trace.verifications.append(
+        CheckResult(
+            check=check,
+            status="pass" if passed else "fail",
+            confidence=confidence,
+            detail=detail,
+        )
+    )
+
+
+def save_trace(trace: Trace, path: str | Path) -> Path:
+    """Save a trace to a file (run.json or run.trace)."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(trace.to_json())
+    return path
+
+
+def load_trace(path: str | Path) -> dict:
+    """Load a trace from a file. Returns the raw dict."""
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Trace not found: {path}")
+    return json.loads(path.read_text())

infini/ui.py

@@ -0,0 +1,70 @@
+"""Observatory UI launcher — `infini ui`.
+
+Launches the local Observatory web app. In V1, this serves the static
+HTML mockups from assets/ and lets you drop a trace file to visualize it.
+"""
+from __future__ import annotations
+
+import json
+import webbrowser
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+# Path to the Observatory UI (Next.js app in observatory-ui/)
+_UI_DIR = Path(__file__).parent.parent.parent.parent / "observatory-ui"
+
+
+def launch_ui(trace_path: str | None = None, port: int = 3000) -> None:
+    """Launch the Observatory UI.
+
+    In V1, if the Next.js app is built, serve it. Otherwise, print
+    instructions for running it manually.
+    """
+    console.print(f"[bold cyan]╔══════════════════════════════════════════════════════╗[/bold cyan]")
+    console.print(f"[bold cyan]║[/bold cyan]  [bold]INFINI Loop Observatory[/bold]                          [bold cyan]║[/bold cyan]")
+    console.print(f"[bold cyan]╚══════════════════════════════════════════════════════╝[/bold cyan]")
+    console.print()
+
+    if _UI_DIR.exists() and (_UI_DIR / "package.json").exists():
+        # Next.js app exists — try to launch it
+        console.print(f"[green]▶ Observatory UI found at {_UI_DIR}[/green]")
+        console.print(f"[dim]  Starting Next.js dev server on port {port}...[/dim]")
+        console.print()
+        console.print(f"  [bold]Open:[/bold] [link=http://localhost:{port}]http://localhost:{port}[/link]")
+        if trace_path:
+            console.print(f"  [bold]Trace:[/bold] {trace_path}")
+        console.print()
+        console.print(f"[dim]  Press Ctrl+C to stop.[/dim]")
+
+        import subprocess
+        try:
+            env = {"PORT": str(port), "PATH": __import__("os").environ.get("PATH", "")}
+            import os
+            env = {**os.environ, "PORT": str(port)}
+            if trace_path:
+                env["INFINI_TRACE"] = str(Path(trace_path).resolve())
+            subprocess.run(
+                ["npm", "run", "dev", "--", "--port", str(port)],
+                cwd=str(_UI_DIR),
+                env=env,
+            )
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Observatory stopped.[/yellow]")
+        except FileNotFoundError:
+            console.print("[yellow]npm not found. Install Node.js to run the Observatory UI.[/yellow]")
+            console.print(f"[dim]  Or open the mockup directly: file://{_UI_DIR}/../assets/observatory.html[/dim]")
+    else:
+        # No Next.js app — serve the static mockup
+        console.print(f"[yellow]▶ Observatory UI not built. Showing static mockup.[/yellow]")
+        console.print()
+        mockup = Path(__file__).parent.parent.parent.parent / "assets" / "observatory.html"
+        if mockup.exists():
+            console.print(f"  [bold]Open:[/bold] [link=file://{mockup}]file://{mockup}[/link]")
+            webbrowser.open(f"file://{mockup}")
+        else:
+            console.print(f"  [red]Mockup not found at {mockup}[/red]")
+        console.print()
+        console.print(f"[dim]  To build the full UI: cd observatory-ui && npm install && npm run dev[/dim]")