infini-cli 0.1.0__py3-none-any.whl

infini/__init__.py

@@ -0,0 +1,6 @@
+"""INFINI — the open standard for agent loops.
+
+Write a Loopfile, run it on any engine.
+"""
+
+__version__ = "0.1.0"

infini/__main__.py

@@ -0,0 +1,4 @@
+from infini.cli import main
+
+if __name__ == "__main__":
+    main()

infini/adapters.py

@@ -0,0 +1,68 @@
+"""Adapter discovery and capability metadata.
+
+Scans the adapters/ directory for adapter.yaml manifests and reports
+actual capabilities (parse, run, verify, inspect, replay, diff) instead
+of just directory names.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+def find_adapters_dir(start: Optional[Path] = None) -> Optional[Path]:
+    """Search upwards from start (or cwd) for an adapters/ directory."""
+    p = Path(start or Path.cwd()).resolve()
+    root = p.anchor
+    while True:
+        candidate = p / "adapters"
+        if candidate.is_dir():
+            return candidate
+        if str(p) == root:
+            return None
+        p = p.parent
+
+
+def load_adapter_manifest(adapter_dir: Path) -> dict | None:
+    """Load an adapter's adapter.yaml manifest. Returns None if not found."""
+    manifest_path = adapter_dir / "adapter.yaml"
+    if not manifest_path.exists():
+        return None
+    try:
+        with manifest_path.open("r", encoding="utf-8") as fh:
+            data = yaml.safe_load(fh)
+        return data if isinstance(data, dict) else None
+    except Exception:
+        return None
+
+
+def detect_adapters(base: Optional[Path] = None) -> list[dict]:
+    """Scan for adapters and return their manifests.
+
+    Returns a list of dicts, each with at minimum:
+      - name: adapter directory name
+      - path: absolute path to the adapter directory
+      - manifest: the parsed adapter.yaml (or None if no manifest)
+      - capabilities: list of supported capability strings (from manifest, or [])
+    """
+    adapters_dir = find_adapters_dir(base)
+    if not adapters_dir:
+        return []
+
+    results = []
+    for p in sorted(adapters_dir.iterdir()):
+        if not p.is_dir():
+            continue
+        manifest = load_adapter_manifest(p)
+        caps = []
+        if manifest and isinstance(manifest.get("capabilities"), dict):
+            caps = [k for k, v in manifest["capabilities"].items() if v is True]
+        results.append({
+            "name": p.name,
+            "path": str(p),
+            "manifest": manifest,
+            "capabilities": caps,
+        })
+    return results

infini/cli.py

@@ -0,0 +1,287 @@
+"""INFINI CLI — the entry point.
+
+Usage:
+    infini validate <loopfile>
+    infini run <loopfile> [--mock] [--output <dir>]
+    infini inspect <run_dir> [--web]
+    infini replay <run_dir> [--step <id>] [--freeze-model-calls]
+    infini diff <v1> <v2>
+    infini ui [<trace>]
+    infini engines
+    infini init [--target <dir>] [--filename <name>]
+    infini new <name>
+    infini graph <loopfile>
+    infini benchmark <loopfile>
+    infini --version
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+from . import __version__
+from .parse import parse_file, ParseError
+from .engine import run as run_loop
+from .inspect import inspect as inspect_trace
+from .replay import replay as replay_trace
+from .diff import diff as diff_cmd
+from .ui import launch_ui
+from .adapters import detect_adapters
+
+console = Console()
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(__version__, prog_name="infini")
+def cli():
+    """INFINI — the open standard for agent loops.
+
+    Write a Loopfile, run it on any engine.
+
+    \b
+    Quickstart:
+        infini validate loop.yaml
+        infini run loop.yaml --mock
+        infini inspect runs/latest/
+        infini replay runs/latest/ --step s3
+        infini ui runs/latest/run.json
+    """
+
+
+@cli.command()
+@click.argument("loopfile", type=click.Path(exists=True))
+def validate(loopfile: str):
+    """Validate a Loopfile against the spec."""
+    try:
+        lf = parse_file(loopfile)
+        console.print(f"[green]✓ valid[/green]  {lf.name}@{lf.version}  (LOOPFILE-{lf.spec_version})")
+        console.print(f"  [dim]objective: {lf.objective}[/dim]")
+        console.print(f"  [dim]agents: {len(lf.agents)}  steps: {len(lf.steps)}  verify: {len(lf.verify.syntactic)} syntactic + {len(lf.verify.semantic)} semantic[/dim]")
+        console.print(f"  [dim]budget: ${lf.budget.dollars} / {lf.budget.minutes}m[/dim]")
+    except ParseError as e:
+        console.print(f"[red]✗ invalid[/red]")
+        console.print(str(e))
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("loopfile", type=click.Path(exists=True))
+@click.option("--mock/--live", default=True, help="Use mock LLM (default) or live execution.")
+@click.option("-o", "--output", default="runs/latest", help="Output directory for the trace.")
+@click.option("--max-iterations", default=5, help="Hard cap on iterations.")
+@click.option("-q", "--quiet", is_flag=True, help="Suppress progress output.")
+def run(loopfile: str, mock: bool, output: str, max_iterations: int, quiet: bool):
+    """Run a Loopfile."""
+    try:
+        lf = parse_file(loopfile)
+    except ParseError as e:
+        console.print(f"[red]✗ invalid Loopfile[/red]")
+        console.print(str(e))
+        sys.exit(1)
+
+    trace = run_loop(
+        lf,
+        output_dir=output,
+        mock=mock,
+        max_iterations=max_iterations,
+        verbose=not quiet,
+    )
+
+    if trace.outcome == "verified":
+        console.print(f"\n[green]✓ shipped.[/green] trace: {Path(output) / 'run.json'}")
+    elif trace.outcome == "budget_exceeded":
+        console.print(f"\n[red]✗ budget exceeded.[/red] trace: {Path(output) / 'run.json'}")
+        sys.exit(1)
+    else:
+        console.print(f"\n[yellow]⚠ unverified.[/yellow] trace: {Path(output) / 'run.json'}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("run_dir", type=click.Path(exists=True))
+@click.option("--web", is_flag=True, help="Open the Observatory UI in the browser (coming soon).")
+def inspect(run_dir: str, web: bool):
+    """Inspect a run trace. Use --web to open the Observatory UI (coming soon)."""
+    inspect_trace(run_dir)
+    if web:
+        console.print("[blue]Observatory UI support is coming soon.[/blue]")
+        console.print("[dim]For now, run `infini ui` separately to launch the Next.js dashboard.[/dim]")
+
+
+@cli.command()
+@click.argument("run_dir", type=click.Path(exists=True))
+@click.option("--step", default=None, help="Step ID to replay from.")
+@click.option("--freeze-model-calls", is_flag=True, help="Reuse original model responses (bit-exact).")
+@click.option("-o", "--output", default=None, help="Output directory for the replay trace.")
+def replay(run_dir: str, step: str | None, freeze_model_calls: bool, output: str | None):
+    """Replay a run from a specific step."""
+    replay_trace(run_dir, from_step=step, freeze_model_calls=freeze_model_calls, output_dir=output)
+
+
+@cli.command()
+@click.argument("v1", type=click.Path(exists=True))
+@click.argument("v2", type=click.Path(exists=True))
+def diff(v1: str, v2: str):
+    """Semantic diff between two Loopfiles or two traces."""
+    diff_cmd(v1, v2)
+
+
+@cli.command()
+@click.argument("trace", required=False, type=click.Path(exists=True))
+@click.option("--port", default=3000, help="Port for the Observatory UI.")
+def ui(trace: str | None, port: int):
+    """Launch the Loop Observatory UI."""
+    launch_ui(trace_path=trace, port=port)
+
+
+@cli.command()
+def engines():
+    """List installed adapters and their capabilities (from adapter.yaml manifests)."""
+    console.rule("[bold]Engines / Adapters (detected)")
+    adapters = detect_adapters()
+    if not adapters:
+        console.print("[yellow]No adapters found under adapters/.[/yellow]")
+        console.print("[dim]Adapters are discovered by scanning for adapter.yaml manifests.[/dim]")
+        return
+    table = Table(box=box.SIMPLE)
+    table.add_column("Adapter", style="cyan")
+    table.add_column("Version")
+    table.add_column("Type")
+    table.add_column("Capabilities", style="green")
+    for a in adapters:
+        m = a.get("manifest") or {}
+        adapter_info = m.get("adapter", {}) if isinstance(m, dict) else {}
+        name = adapter_info.get("name", a["name"])
+        version = adapter_info.get("version", "?")
+        atype = adapter_info.get("type", "?")
+        caps = a.get("capabilities", [])
+        caps_str = ", ".join(caps) if caps else "(none declared)"
+        table.add_row(name, version, atype, caps_str)
+    console.print(table)
+    console.print("\n[dim]Full compatibility matrix: spec/compatibility.md[/dim]")
+    console.print("[dim]Adapters without adapter.yaml are not listed.[/dim]")
+
+
+@cli.command()
+@click.option("--target", "-t", default=".", help="Directory to initialize.")
+@click.option("--filename", "-f", default="Loopfile", help="Starter Loopfile name.")
+def init(target: str, filename: str):
+    """Scaffold a minimal loop project: Loopfile, loops/, state/, runs/."""
+    target_path = Path(target).resolve()
+    for d in ("loops", "state", "runs"):
+        (target_path / d).mkdir(parents=True, exist_ok=True)
+    lf = target_path / filename
+    if not lf.exists():
+        lf.write_text(
+            'LOOPFILE: "1.0"\n'
+            'name: my-loop\n'
+            'version: 1.0.0\n'
+            'OBJECTIVE: "Describe the objective here."\n'
+            'AGENTS:\n'
+            '  - { name: builder, role: builder, model_tier: sonnet }\n'
+            'STEPS: []\n'
+            'VERIFY:\n'
+            '  syntactic: []\n'
+            '  semantic: []\n'
+            '  confidence_threshold: 80\n'
+            'BUDGET: { dollars: 5, minutes: 15 }\n'
+            'STOP_WHEN: ["all_verify_passed"]\n'
+        )
+    console.print(Panel.fit(
+        f"Initialized at [cyan]{target_path}[/cyan]\nLoopfile: [green]{lf}[/green]",
+        title="infini init",
+    ))
+
+
+@cli.command()
+@click.argument("name")
+def new(name: str):
+    """Create a new loop project scaffold: <name>/Loopfile, state/, runs/, artifacts/.
+
+    NAME is used both as the directory name and the Loopfile's name field.
+    Use a simple slug (e.g. 'my-loop'), not a full path.
+    """
+    # Derive a clean slug from the name (last path component, lowercased)
+    slug = Path(name).name.lower().replace(" ", "-")
+    base = Path.cwd() / name
+    base.mkdir(parents=True, exist_ok=True)
+    for d in ("state", "runs", "artifacts"):
+        (base / d).mkdir(exist_ok=True)
+    lf = base / "Loopfile"
+    if not lf.exists():
+        lf.write_text(
+            f'LOOPFILE: "1.0"\n'
+            f'name: {slug}\n'
+            f'version: 1.0.0\n'
+            f'OBJECTIVE: "Describe the objective."\n'
+            f'AGENTS:\n'
+            f'  - {{ name: builder, role: builder, model_tier: sonnet }}\n'
+            f'STEPS: []\n'
+            f'VERIFY:\n'
+            f'  syntactic: []\n'
+            f'  semantic: []\n'
+            f'  confidence_threshold: 80\n'
+            f'BUDGET: {{ dollars: 5, minutes: 15 }}\n'
+            f'STOP_WHEN: ["all_verify_passed"]\n'
+        )
+    console.print(Panel.fit(
+        f"Created new project at [cyan]{base}[/cyan]\nLoopfile: [green]{lf}[/green]",
+        title="infini new",
+    ))
+
+
+@cli.command()
+@click.argument("loopfile", type=click.Path(exists=True))
+def graph(loopfile: str):
+    """Render a simple ASCII graph of the Loopfile's steps."""
+    try:
+        lf = parse_file(loopfile)
+    except ParseError as e:
+        console.print(f"[red]✗ invalid Loopfile[/red]")
+        console.print(str(e))
+        sys.exit(1)
+    console.rule("[bold]Loop Graph")
+    if not lf.steps:
+        console.print("[yellow]No steps found to graph.[/yellow]")
+        return
+    for idx, s in enumerate(lf.steps):
+        console.print(f"  [cyan]{s.id}[/cyan]  [bold]{s.name}[/bold]")
+        if idx < len(lf.steps) - 1:
+            console.print("  [dim]│[/dim]")
+            console.print("  [dim]▼[/dim]")
+
+
+@cli.command()
+@click.argument("loopfile", type=click.Path(exists=True))
+def benchmark(loopfile: str):
+    """Produce a benchmark estimate (preview — real profiling coming later)."""
+    try:
+        lf = parse_file(loopfile)
+    except ParseError as e:
+        console.print(f"[red]✗ invalid Loopfile[/red]")
+        console.print(str(e))
+        sys.exit(1)
+    n = len(lf.steps)
+    console.rule("[bold]Benchmark Estimate — Preview")
+    console.print("[dim]This is a preview. Real profiling requires running the loop.[/dim]\n")
+    console.print(f"  Steps detected:     [bold]{n}[/bold]")
+    console.print(f"  Runtime:            [yellow]Unknown[/yellow]  [dim](run `infini run` to measure)[/dim]")
+    console.print(f"  Cost:               [yellow]Unknown[/yellow]  [dim](run `infini run` to measure)[/dim]")
+    console.print(f"  Iterations:         [yellow]Unknown[/yellow]  [dim](depends on verification)[/dim]")
+    console.print(f"  Confidence:         [yellow]Unknown[/yellow]  [dim](depends on semantic checks)[/dim]")
+    console.print(f"\n  To get real numbers:\n    infini run {loopfile} --mock")
+
+
+def main():
+    """Entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

infini/diff.py

@@ -0,0 +1,167 @@
+"""Semantic diff — `infini diff`.
+
+Produces a semantic diff between two Loopfiles or two traces, not a
+line diff. Highlights changes to OBJECTIVE, AGENTS, STEPS, VERIFY,
+BUDGET, STOP_WHEN.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from .parse import parse_file
+from .trace import load_trace
+
+console = Console()
+
+
+def diff(v1: str | Path, v2: str | Path) -> None:
+    """Diff two Loopfiles or two traces. Auto-detects which."""
+    p1, p2 = Path(v1), Path(v2)
+
+    # Auto-detect: is this a Loopfile (YAML) or a trace (JSON)?
+    is_trace_1 = _is_trace(p1)
+    is_trace_2 = _is_trace(p2)
+
+    if is_trace_1 and is_trace_2:
+        _diff_traces(p1, p2)
+    elif not is_trace_1 and not is_trace_2:
+        _diff_loopfiles(p1, p2)
+    else:
+        console.print("[red]Cannot diff a Loopfile against a trace. Both arguments must be the same type.[/red]")
+
+
+def _is_trace(path: Path) -> bool:
+    """Heuristic: is this file a trace (JSON with 'loopfile' key) or a Loopfile (YAML)?"""
+    if not path.exists():
+        return False
+    text = path.read_text()
+    try:
+        data = json.loads(text)
+        return isinstance(data, dict) and "loopfile" in data
+    except json.JSONDecodeError:
+        return False
+
+
+def _diff_loopfiles(v1: Path, v2: Path) -> None:
+    """Diff two Loopfiles."""
+    lf1 = parse_file(v1)
+    lf2 = parse_file(v2)
+
+    console.print(f"\n[bold]INFINI diff[/bold] — Loopfiles")
+    console.print(f"  [dim]v1: {v1}[/dim]")
+    console.print(f"  [dim]v2: {v2}[/dim]\n")
+
+    changes: list[str] = []
+
+    # Objective
+    if lf1.objective != lf2.objective:
+        changes.append(f"[red]OBJECTIVE changed[/red]")
+        console.print(f"  [red]- OBJECTIVE: {lf1.objective}[/red]")
+        console.print(f"  [green]+ OBJECTIVE: {lf2.objective}[/green]")
+    else:
+        console.print(f"  [dim]OBJECTIVE: unchanged[/dim]")
+
+    # Agents
+    agents1 = {a.name: a for a in lf1.agents}
+    agents2 = {a.name: a for a in lf2.agents}
+    added = set(agents2) - set(agents1)
+    removed = set(agents1) - set(agents2)
+    if added:
+        changes.append(f"[green]+{len(added)} agent(s) added[/green]")
+        console.print(f"  [green]+ AGENTS: {', '.join(added)}[/green]")
+    if removed:
+        changes.append(f"[red]-{len(removed)} agent(s) removed[/red]")
+        console.print(f"  [red]- AGENTS: {', '.join(removed)}[/red]")
+    if not added and not removed:
+        console.print(f"  [dim]AGENTS: unchanged[/dim]")
+
+    # Steps
+    steps1 = {s.id: s for s in lf1.steps}
+    steps2 = {s.id: s for s in lf2.steps}
+    added_s = set(steps2) - set(steps1)
+    removed_s = set(steps1) - set(steps2)
+    if added_s:
+        changes.append(f"[green]+{len(added_s)} step(s) added[/green]")
+        console.print(f"  [green]+ STEPS: {', '.join(added_s)}[/green]")
+    if removed_s:
+        changes.append(f"[red]-{len(removed_s)} step(s) removed[/red]")
+        console.print(f"  [red]- STEPS: {', '.join(removed_s)}[/red]")
+    if not added_s and not removed_s:
+        console.print(f"  [dim]STEPS: unchanged[/dim]")
+
+    # Verify
+    v1_checks = set(lf1.verify.syntactic + lf1.verify.semantic)
+    v2_checks = set(lf2.verify.syntactic + lf2.verify.semantic)
+    added_v = v2_checks - v1_checks
+    removed_v = v1_checks - v2_checks
+    if added_v:
+        changes.append(f"[green]+{len(added_v)} verification check(s) added[/green]")
+        console.print(f"  [green]+ VERIFY: {', '.join(added_v)}[/green]")
+    if removed_v:
+        changes.append(f"[red]-{len(removed_v)} verification check(s) removed[/red]")
+        console.print(f"  [red]- VERIFY: {', '.join(removed_v)}[/red]")
+    if lf1.verify.confidence_threshold != lf2.verify.confidence_threshold:
+        changes.append(f"[yellow]~ confidence_threshold: {lf1.verify.confidence_threshold} → {lf2.verify.confidence_threshold}[/yellow]")
+        console.print(f"  [yellow]~ confidence_threshold: {lf1.verify.confidence_threshold} → {lf2.verify.confidence_threshold}[/yellow]")
+    if not added_v and not removed_v and lf1.verify.confidence_threshold == lf2.verify.confidence_threshold:
+        console.print(f"  [dim]VERIFY: unchanged[/dim]")
+
+    # Budget
+    if lf1.budget.dollars != lf2.budget.dollars:
+        changes.append(f"[yellow]~ BUDGET dollars: ${lf1.budget.dollars} → ${lf2.budget.dollars}[/yellow]")
+        console.print(f"  [yellow]~ BUDGET dollars: ${lf1.budget.dollars} → ${lf2.budget.dollars}[/yellow]")
+    if lf1.budget.minutes != lf2.budget.minutes:
+        changes.append(f"[yellow]~ BUDGET minutes: {lf1.budget.minutes} → {lf2.budget.minutes}[/yellow]")
+        console.print(f"  [yellow]~ BUDGET minutes: {lf1.budget.minutes}m → {lf2.budget.minutes}m[/yellow]")
+    if lf1.budget.dollars == lf2.budget.dollars and lf1.budget.minutes == lf2.budget.minutes:
+        console.print(f"  [dim]BUDGET: unchanged[/dim]")
+
+    # Summary
+    console.print(f"\n[bold]Summary[/bold]")
+    if not changes:
+        console.print(f"  [green]No semantic changes. The two Loopfiles are equivalent.[/green]")
+    else:
+        for c in changes:
+            console.print(f"  {c}")
+
+    # Compatibility classification
+    if any("[red]" in c for c in changes):
+        console.print(f"\n  [red]This is a BREAKING change.[/red]")
+    elif any("[yellow]" in c for c in changes):
+        console.print(f"\n  [yellow]This is a COMPATIBLE change.[/yellow]")
+    elif added or added_s or added_v:
+        console.print(f"\n  [green]This is an ADDITIVE change.[/green]")
+
+
+def _diff_traces(v1: Path, v2: Path) -> None:
+    """Diff two traces."""
+    t1 = load_trace(v1)
+    t2 = load_trace(v2)
+
+    console.print(f"\n[bold]INFINI diff[/bold] — Traces")
+    console.print(f"  [dim]v1: {v1}[/dim]")
+    console.print(f"  [dim]v2: {v2}[/dim]\n")
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Metric")
+    table.add_column("v1", justify="right")
+    table.add_column("v2", justify="right")
+    table.add_column("Delta", justify="right")
+
+    b1, b2 = t1.get("budget", {}), t2.get("budget", {})
+    d_cost = b2.get("spent_dollars", 0) - b1.get("spent_dollars", 0)
+    d_time = b2.get("spent_minutes", 0) - b1.get("spent_minutes", 0)
+
+    table.add_row("Outcome", t1.get("outcome", "?"), t2.get("outcome", "?"), "")
+    table.add_row("Iterations", str(t1.get("iterations", 0)), str(t2.get("iterations", 0)), "")
+    table.add_row("Steps", str(len(t1.get("steps", []))), str(len(t2.get("steps", []))), "")
+    table.add_row("Cost", f"${b1.get('spent_dollars', 0):.2f}", f"${b2.get('spent_dollars', 0):.2f}",
+                  f"[{'red' if d_cost > 0 else 'green'}]{'+' if d_cost > 0 else ''}${d_cost:.2f}[/]")
+    table.add_row("Time", f"{b1.get('spent_minutes', 0):.1f}m", f"{b2.get('spent_minutes', 0):.1f}m",
+                  f"[{'red' if d_time > 0 else 'green'}]{'+' if d_time > 0 else ''}{d_time:.1f}m[/]")
+
+    console.print(table)