wagner-cli 0.1.0__py3-none-any.whl

wagner_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Wagner CLI — AI coding orchestrator with self-improving specialists."""
+
+__version__ = "0.1.0"

wagner_cli/client.py

@@ -0,0 +1,108 @@
+"""Wagner API client."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+
+DEFAULT_SERVER = "https://wagner.razzyshmazzy.com"
+CONFIG_PATH = Path.home() / ".wagner" / "config.json"
+
+
+class WagnerClient:
+    """Client for the Wagner orchestration API."""
+
+    def __init__(self, server_url: str | None = None, api_key: str | None = None,
+                 anthropic_key: str | None = None, timeout: float = 300.0):
+        config = self._load_config()
+        self.server_url = (server_url or config.get("server_url", DEFAULT_SERVER)).rstrip("/")
+        self.api_key = api_key or config.get("api_key", "")
+        # BYOK: the user's own Anthropic key. Sent only on conduct requests via
+        # the X-Anthropic-Key header — never on health/status/faces.
+        self.anthropic_key = anthropic_key or config.get("anthropic_key", "")
+        self.timeout = timeout
+        self._client = httpx.Client(
+            base_url=self.server_url,
+            timeout=timeout,
+            headers=self._headers(),
+        )
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.api_key:
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    @staticmethod
+    def _load_config() -> dict:
+        if CONFIG_PATH.exists():
+            try:
+                return json.loads(CONFIG_PATH.read_text())
+            except Exception:
+                return {}
+        return {}
+
+    @staticmethod
+    def save_config(server_url: str, api_key: str = "", anthropic_key: str = ""):
+        CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+        CONFIG_PATH.write_text(json.dumps({
+            "server_url": server_url,
+            "api_key": api_key,
+            "anthropic_key": anthropic_key,
+        }, indent=2))
+
+    def _conduct_headers(self) -> dict:
+        """Extra headers sent ONLY on conduct requests (BYOK key)."""
+        if self.anthropic_key:
+            return {"X-Anthropic-Key": self.anthropic_key}
+        return {}
+
+    def health(self) -> dict:
+        r = self._client.get("/api/health")
+        r.raise_for_status()
+        return r.json()
+
+    def conduct(self, prompt: str, synthesize: bool = True,
+                skip_clarification: bool = False, max_revisions: int = 1,
+                context: dict[str, str] | None = None) -> dict:
+        payload = {
+            "prompt": prompt,
+            "synthesize": synthesize,
+            "skip_clarification": skip_clarification,
+            "max_revisions": max_revisions,
+        }
+        if context:
+            payload["context"] = context
+        r = self._client.post("/api/conduct", json=payload, headers=self._conduct_headers())
+        r.raise_for_status()
+        return r.json()
+
+    def conduct_dry(self, prompt: str, context: dict[str, str] | None = None) -> dict:
+        payload = {"prompt": prompt}
+        if context:
+            payload["context"] = context
+        r = self._client.post("/api/conduct/dry", json=payload, headers=self._conduct_headers())
+        r.raise_for_status()
+        return r.json()
+
+    def faces(self) -> list[dict]:
+        r = self._client.get("/api/faces")
+        r.raise_for_status()
+        return r.json()
+
+    def status(self) -> dict:
+        r = self._client.get("/api/status")
+        r.raise_for_status()
+        return r.json()
+
+    def performances(self, limit: int = 10) -> list[dict]:
+        r = self._client.get(f"/api/performances?limit={limit}")
+        r.raise_for_status()
+        return r.json()
+
+    def gaps(self) -> dict:
+        r = self._client.get("/api/gaps")
+        r.raise_for_status()
+        return r.json()

wagner_cli/display.py

@@ -0,0 +1,175 @@
+"""Rich console rendering for Wagner CLI."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.syntax import Syntax
+from rich.text import Text
+from rich.columns import Columns
+from rich import box
+
+console = Console()
+
+
+def print_banner():
+    banner = Text("WAGNER", style="bold yellow")
+    console.print(Panel(
+        banner,
+        subtitle="AI Coding Orchestrator",
+        border_style="dim yellow",
+        padding=(0, 2),
+    ))
+
+
+def print_status(status: dict):
+    table = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+    table.add_column("Key", style="dim")
+    table.add_column("Value", style="bold")
+    table.add_row("Server", status.get("server", ""))
+    table.add_row("Faces", str(status.get("total_faces", 0)))
+    table.add_row("Performances", str(status.get("total_performances", 0)))
+    table.add_row("API", "connected" if status.get("api_connected") else "no key")
+    console.print(table)
+
+
+def print_faces(faces: list[dict]):
+    table = Table(title="Specialist Faces", box=box.ROUNDED, border_style="dim")
+    table.add_column("Name", style="bold")
+    table.add_column("Mode", style="cyan", width=6)
+    table.add_column("Examples", justify="right")
+    table.add_column("Queries", justify="right")
+    table.add_column("Progress", width=12)
+
+    for f in sorted(faces, key=lambda x: x.get("examples", 0), reverse=True):
+        progress = f.get("graduation_progress", "0%")
+        bar_pct = min(100, int(progress.replace("%", "") or 0))
+        bar_filled = int(bar_pct / 5)
+        bar = "[yellow]" + "█" * bar_filled + "[dim]" + "░" * (20 - bar_filled)
+
+        table.add_row(
+            f.get("name", "?"),
+            f.get("mode", "rag").upper(),
+            str(f.get("examples", 0)),
+            str(f.get("total_queries", 0)),
+            bar,
+        )
+
+    console.print(table)
+
+
+def print_conduct_result(result: dict, show_synthesis: bool = True):
+    # Header
+    console.print()
+    console.print(Panel(
+        f'[bold]{result.get("prompt", "")[:100]}[/bold]',
+        title="Orchestration Complete",
+        border_style="green",
+    ))
+
+    # Stats row
+    stats = Table(box=box.SIMPLE, show_header=False, padding=(0, 2))
+    stats.add_column("", style="dim")
+    stats.add_column("", style="bold")
+    stats.add_row("Subtasks", str(result.get("subtasks", 0)))
+    stats.add_row("Specialists", str(result.get("specialists_used", 0)))
+    stats.add_row("Latency", f'{result.get("total_latency_ms", 0):.0f}ms')
+    stats.add_row("API calls", str(result.get("total_api_calls", 0)))
+
+    gaps = result.get("gaps_detected", [])
+    if gaps:
+        stats.add_row("Gaps", ", ".join(gaps))
+
+    revised = result.get("revised", False)
+    if revised:
+        stats.add_row("Revised", "[green]Yes — critic triggered revision[/green]")
+
+    critique = result.get("critique")
+    if critique:
+        score = critique.get("score", "?")
+        stats.add_row("Critic score", f"{score}/10")
+
+    console.print(stats)
+
+    # Specialist outputs
+    outputs = result.get("specialist_outputs", [])
+    if outputs:
+        table = Table(title="Specialists", box=box.SIMPLE_HEAVY, border_style="dim")
+        table.add_column("Face", style="bold")
+        table.add_column("Task")
+        table.add_column("Conf", justify="right", style="cyan")
+        table.add_column("ms", justify="right", style="dim")
+
+        for o in outputs:
+            conf = o.get("confidence", 0)
+            conf_style = "green" if conf > 0.5 else "yellow" if conf > 0.3 else "red"
+            table.add_row(
+                o.get("face_name", "?"),
+                (o.get("task", "")[:60] + "...") if len(o.get("task", "")) > 60 else o.get("task", ""),
+                f"[{conf_style}]{conf:.0%}[/{conf_style}]",
+                f'{o.get("latency_ms", 0):.0f}',
+            )
+        console.print(table)
+
+    # Clarification
+    clarification = result.get("clarification")
+    if clarification and clarification.get("needs_clarification"):
+        console.print()
+        console.print(Panel(
+            "\n".join(f"  {i+1}. {q}" for i, q in enumerate(clarification.get("questions", []))),
+            title="[yellow]Clarification Needed[/yellow]",
+            border_style="yellow",
+        ))
+        return
+
+    # Synthesis
+    if show_synthesis and result.get("synthesis"):
+        console.print()
+        console.print("[dim]─── Synthesis ───[/dim]")
+        console.print(result["synthesis"])
+
+
+def print_files_written(paths: list[str]):
+    console.print()
+    for p in paths:
+        console.print(f"  [green]✓[/green] {p}")
+    console.print(f"\n  [bold]{len(paths)} files written[/bold]")
+
+
+def print_file_preview(previews: list[dict]):
+    table = Table(title="Generated Files", box=box.ROUNDED, border_style="dim")
+    table.add_column("File", style="bold")
+    table.add_column("Lines", justify="right")
+    table.add_column("Size", justify="right", style="dim")
+
+    for p in previews:
+        size = f'{p["chars"]}' if p["chars"] < 1024 else f'{p["chars"]/1024:.1f}K'
+        table.add_row(p["path"], str(p["lines"]), size)
+
+    console.print(table)
+
+
+def spinner(message: str = "Orchestrating..."):
+    return Progress(
+        SpinnerColumn(style="yellow"),
+        TextColumn("[bold]{task.description}"),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    )
+
+
+def print_error(msg: str):
+    console.print(f"[red]Error:[/red] {msg}")
+
+
+def print_clarification_prompt(questions: list[str]) -> list[str]:
+    """Display clarification questions and collect answers."""
+    console.print()
+    console.print("[yellow]Wagner needs clarification before proceeding:[/yellow]")
+    answers = []
+    for i, q in enumerate(questions):
+        console.print(f"\n  [bold]{i+1}.[/bold] {q}")
+        answer = console.input("  [dim]→[/dim] ")
+        answers.append(answer)
+    return answers

wagner_cli/main.py

@@ -0,0 +1,302 @@
+"""Wagner CLI — main entry point."""
+
+import sys
+from pathlib import Path
+
+import click
+import httpx
+
+from wagner_cli import __version__
+from wagner_cli.client import WagnerClient, DEFAULT_SERVER
+from wagner_cli.writer import parse_files, write_files, preview_files
+from wagner_cli.display import (
+    console, print_banner, print_status, print_faces, print_conduct_result,
+    print_files_written, print_file_preview, print_error, spinner,
+    print_clarification_prompt,
+)
+
+
+def _get_client(server: str | None = None) -> WagnerClient:
+    try:
+        return WagnerClient(server_url=server)
+    except Exception as e:
+        print_error(f"Cannot create client: {e}")
+        sys.exit(1)
+
+
+def _check_health(client: WagnerClient):
+    try:
+        client.health()
+    except httpx.ConnectError:
+        print_error(f"Cannot connect to {client.server_url}")
+        console.print("[dim]Run 'wagner config <url>' to set your server[/dim]")
+        sys.exit(1)
+    except Exception as e:
+        print_error(f"Server error: {e}")
+        sys.exit(1)
+
+
+@click.group()
+@click.version_option(__version__, "-v", "--version")
+def cli():
+    """Wagner — AI coding orchestrator with self-improving specialists.
+
+    \b
+    Quick start:
+        wagner config https://wagner.razzyshmazzy.com
+        wagner run "build a REST API with auth"
+        wagner run "build a CLI tool" --write
+    """
+    pass
+
+
+@cli.command()
+@click.argument("prompt", nargs=-1, required=True)
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+@click.option("--write", "-w", is_flag=True, help="Write generated files to disk")
+@click.option("--output", "-o", default=".", help="Output directory for generated files")
+@click.option("--overwrite", is_flag=True, help="Overwrite existing files")
+@click.option("--dry", is_flag=True, help="Dry run — decompose without synthesis")
+@click.option("--no-clarify", is_flag=True, help="Skip clarification step")
+@click.option("--no-critic", is_flag=True, help="Skip critic/revision step")
+@click.option("--context", "-c", multiple=True, help="Source files to include as context (repeatable)")
+def run(prompt, server, write, output, overwrite, dry, no_clarify, no_critic, context):
+    """Run Wagner orchestration on a coding task.
+
+    \b
+    Examples:
+        wagner run "build a FastAPI app with auth"
+        wagner run "add pagination" --context app/routes.py app/models.py --write
+        wagner run "build a chat app" --dry
+    """
+    prompt_text = " ".join(prompt)
+    client = _get_client(server)
+    _check_health(client)
+
+    print_banner()
+
+    # Read context files from disk
+    context_dict = None
+    if context:
+        context_dict = {}
+        for filepath in context:
+            p = Path(filepath)
+            if not p.exists():
+                print_error(f"Context file not found: {filepath}")
+                sys.exit(1)
+            try:
+                context_dict[str(p)] = p.read_text(encoding="utf-8", errors="ignore")
+                console.print(f"  [dim]context:[/dim] {p} ({len(p.read_text())} chars)")
+            except Exception as e:
+                print_error(f"Cannot read {filepath}: {e}")
+                sys.exit(1)
+        console.print()
+
+    if dry:
+        with spinner() as progress:
+            progress.add_task("Decomposing...", total=None)
+            result = client.conduct_dry(prompt_text, context=context_dict)
+        print_conduct_result(result, show_synthesis=False)
+        return
+
+    # Full conduct
+    with spinner() as progress:
+        progress.add_task("Orchestrating...", total=None)
+        result = client.conduct(
+            prompt_text,
+            synthesize=True,
+            skip_clarification=no_clarify,
+            max_revisions=0 if no_critic else 1,
+            context=context_dict,
+        )
+
+    # Handle clarification
+    clarification = result.get("clarification")
+    if clarification and clarification.get("needs_clarification"):
+        questions = clarification.get("questions", [])
+        answers = print_clarification_prompt(questions)
+
+        # Re-submit with answers
+        augmented = prompt_text + "\n\nClarifications:\n"
+        for q, a in zip(questions, answers):
+            augmented += f"- {q}: {a}\n"
+
+        with spinner() as progress:
+            progress.add_task("Orchestrating with clarifications...", total=None)
+            result = client.conduct(
+                augmented,
+                synthesize=True,
+                skip_clarification=True,
+                max_revisions=0 if no_critic else 1,
+                context=context_dict,
+            )
+
+    print_conduct_result(result)
+
+    # Parse and optionally write files
+    synthesis = result.get("synthesis", "")
+    if synthesis:
+        files = parse_files(synthesis)
+        if files:
+            previews = preview_files(files)
+            print_file_preview(previews)
+
+            if write:
+                written = write_files(files, Path(output), overwrite=overwrite)
+                print_files_written(written)
+            else:
+                console.print("\n[dim]Use --write to save files to disk[/dim]")
+
+
+@cli.command()
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+def status(server):
+    """Show Wagner server status."""
+    try:
+        client = _get_client(server)
+        data = client.status()
+        health = client.health()
+        data["server"] = client.server_url
+        data["api_connected"] = health.get("api_connected", False)
+        print_banner()
+        print_status(data)
+    except httpx.ConnectError:
+        print_error("Cannot connect to server")
+    except Exception as e:
+        print_error(str(e))
+
+
+@cli.command()
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+def faces(server):
+    """List all specialist faces."""
+    try:
+        client = _get_client(server)
+        data = client.faces()
+        print_banner()
+        print_faces(data)
+    except httpx.ConnectError:
+        print_error("Cannot connect to server")
+    except Exception as e:
+        print_error(str(e))
+
+
+@cli.command()
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+@click.option("--limit", "-n", default=10, help="Number of recent performances")
+def history(server, limit):
+    """Show recent orchestration history."""
+    try:
+        client = _get_client(server)
+        data = client.performances(limit)
+        print_banner()
+
+        from rich.table import Table
+        from rich import box
+
+        table = Table(title=f"Recent Performances (last {limit})", box=box.ROUNDED, border_style="dim")
+        table.add_column("Prompt", style="bold", max_width=50)
+        table.add_column("Tasks", justify="right")
+        table.add_column("Specs", justify="right")
+        table.add_column("Gaps", justify="right")
+        table.add_column("Latency", justify="right", style="dim")
+        table.add_column("Time", style="dim")
+
+        for p in data:
+            table.add_row(
+                p.get("prompt", "")[:50],
+                str(p.get("subtasks", 0)),
+                str(p.get("specialists", 0)),
+                str(p.get("gaps", 0)),
+                f'{p.get("latency_ms", 0):.0f}ms',
+                p.get("timestamp", "")[:16],
+            )
+
+        console.print(table)
+    except httpx.ConnectError:
+        print_error("Cannot connect to server")
+    except Exception as e:
+        print_error(str(e))
+
+
+@cli.command()
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+def gaps(server):
+    """Show specialist gaps detected during orchestration."""
+    try:
+        client = _get_client(server)
+        data = client.gaps()
+        print_banner()
+
+        if not data:
+            console.print("[dim]No gaps detected yet. Run more prompts.[/dim]")
+            return
+
+        from rich.table import Table
+        from rich import box
+
+        table = Table(title="Specialist Gaps", box=box.ROUNDED, border_style="dim")
+        table.add_column("Missing Specialist", style="bold")
+        table.add_column("Requests", justify="right", style="yellow")
+
+        for name, count in sorted(data.items(), key=lambda x: -x[1]):
+            table.add_row(name, str(count))
+
+        console.print(table)
+    except Exception as e:
+        print_error(str(e))
+
+
+@cli.command()
+@click.argument("api_key", required=False)
+@click.option("--server", "-s", default=None, help="Wagner server URL")
+@click.option("--anthropic-key", default=None,
+              help="Your own Anthropic API key (BYOK). Sent per-request, never stored server-side.")
+def config(api_key, server, anthropic_key):
+    """Configure Wagner.
+
+    \b
+    Bring Your Own Key (BYOK) — Wagner runs all LLM calls on your Anthropic key:
+        wagner config --anthropic-key sk-ant-your-key-here
+
+    \b
+    Combined with a custom server:
+        wagner config --anthropic-key sk-ant-xxx --server https://wagner.razzyshmazzy.com
+
+    \b
+    Set the Wagner access key (positional, optional):
+        wagner config wgn_your_api_key_here
+
+    Any flag you omit keeps its current value.
+    """
+    # Merge with existing config so a partial update never clears other fields.
+    existing = WagnerClient._load_config()
+    new_server = server or existing.get("server_url") or DEFAULT_SERVER
+    new_api_key = api_key if api_key is not None else existing.get("api_key", "")
+    new_anthropic = anthropic_key if anthropic_key is not None else existing.get("anthropic_key", "")
+
+    WagnerClient.save_config(new_server, new_api_key, new_anthropic)
+
+    def _mask(s: str) -> str:
+        if not s:
+            return "(none)"
+        return f"{s[:8]}{'*' * max(0, len(s) - 8)}"
+
+    console.print(f"[green]✓[/green] Configured Wagner")
+    console.print(f"  Server: {new_server}")
+    console.print(f"  Access key: {_mask(new_api_key)}")
+    console.print(f"  Anthropic key (BYOK): {_mask(new_anthropic)}")
+
+    # Test connection
+    try:
+        client = WagnerClient(server_url=new_server, api_key=new_api_key,
+                              anthropic_key=new_anthropic)
+        health = client.health()
+        byok = " · byok supported" if health.get("byok") else ""
+        console.print(f"  Status: [green]connected[/green] ({health.get('faces', 0)} faces{byok})")
+    except Exception as e:
+        console.print(f"  Status: [red]cannot connect[/red] ({e})")
+
+
+if __name__ == "__main__":
+    cli()

wagner_cli/writer.py

@@ -0,0 +1,65 @@
+"""Parse Wagner synthesis output into files and write to disk."""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+
+def parse_files(synthesis: str) -> list[dict]:
+    """Parse ### FILE: markers from Wagner synthesis into file entries."""
+    if not synthesis:
+        return []
+
+    files = []
+    # Match ### FILE: path/to/file.ext followed by a code block
+    pattern = r'###\s*FILE:\s*(.+?)\n\s*```\w*\n(.*?)```'
+    matches = re.finditer(pattern, synthesis, re.DOTALL)
+
+    for match in matches:
+        filepath = match.group(1).strip()
+        code = match.group(2).strip()
+        if filepath and code:
+            files.append({"path": filepath, "code": code})
+
+    # Fallback: if no ### FILE markers, try to extract any code blocks
+    if not files:
+        code_blocks = re.findall(r'```\w*\n(.*?)```', synthesis, re.DOTALL)
+        for i, block in enumerate(code_blocks):
+            block = block.strip()
+            if len(block) > 50:
+                files.append({"path": f"output_{i}.txt", "code": block})
+
+    return files
+
+
+def write_files(files: list[dict], output_dir: Path, overwrite: bool = False) -> list[str]:
+    """Write parsed files to disk. Returns list of written paths."""
+    written = []
+    output_dir = Path(output_dir)
+
+    for entry in files:
+        filepath = output_dir / entry["path"]
+
+        if filepath.exists() and not overwrite:
+            # Add .wagner suffix to avoid clobbering
+            filepath = filepath.with_suffix(filepath.suffix + ".wagner")
+
+        filepath.parent.mkdir(parents=True, exist_ok=True)
+        filepath.write_text(entry["code"] + "\n", encoding="utf-8")
+        written.append(str(filepath))
+
+    return written
+
+
+def preview_files(files: list[dict], max_lines: int = 5) -> list[dict]:
+    """Return a preview of each file (first N lines + total line count)."""
+    previews = []
+    for entry in files:
+        lines = entry["code"].split("\n")
+        previews.append({
+            "path": entry["path"],
+            "lines": len(lines),
+            "chars": len(entry["code"]),
+            "preview": "\n".join(lines[:max_lines]),
+        })
+    return previews

wagner_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: wagner-cli
+Version: 0.1.0
+Summary: AI coding orchestrator with self-improving specialist agents
+Author-email: razzyshmazzy <razzyshmazzy@gmail.com>
+License: Proprietary
+Project-URL: Homepage, https://wagner.razzyshmazzy.com
+Project-URL: Dashboard, https://wagner.razzyshmazzy.com/api/health
+Keywords: ai,coding,orchestration,agents,anthropic,claude,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: click>=8.1.0
+
+# Wagner CLI
+
+AI coding orchestrator with self-improving specialist agents.
+
+Wagner decomposes complex coding tasks across specialist agents, each trained on
+domain-specific patterns. The more you use it, the smarter it gets.
+
+## Install
+
+```bash
+pip install wagner-cli
+```
+
+## Quick Start
+
+Wagner runs on a **bring-your-own-key** model: orchestration (decomposition,
+routing, specialist faces) runs on the Wagner server, while every model call
+runs on **your** Anthropic key. Your key is sent per request and is never
+stored or logged server-side.
+
+```bash
+# 1. Point Wagner at your own Anthropic key (stored in ~/.wagner/config.json)
+wagner config --anthropic-key sk-ant-...
+
+# 2. Orchestrate a coding task
+wagner run "build a REST API with JWT auth and PostgreSQL"
+
+# 3. Write the generated files to disk
+wagner run "build a CLI tool that watches files" --write
+```
+
+More examples:
+
+```bash
+# Dry run — see the decomposition without synthesis (no synthesis cost)
+wagner run "build a chat app" --dry
+
+# Skip clarification / critic passes
+wagner run "build a FastAPI CRUD app" --no-clarify --no-critic
+
+# Edit an existing codebase — pass relevant files as context
+wagner run "add pagination to the list endpoint" \
+  --context app/routes.py app/models.py --write
+```
+
+## Commands
+
+```
+wagner run "prompt"      Orchestrate a coding task
+wagner config            Configure your Anthropic key / server
+wagner status            Show server status and face count
+wagner faces             List all specialist faces
+wagner history           Show recent orchestrations
+wagner gaps              Show missing specialist domains
+```
+
+## `wagner run` options
+
+```
+--write, -w        Write generated files to the output directory
+--output, -o DIR   Output directory (default: current directory)
+--overwrite        Overwrite existing files
+--dry              Decompose only, no synthesis
+--no-clarify       Skip clarification questions
+--no-critic        Skip the critic/revision pass
+--context, -c PATH Source file to include as context (repeatable)
+--server, -s URL   Override the server for this command
+```
+
+## Configuration
+
+```bash
+# Set your Anthropic key (BYOK)
+wagner config --anthropic-key sk-ant-...
+
+# Use a custom server
+wagner config --anthropic-key sk-ant-... --server https://wagner.razzyshmazzy.com
+```
+
+Any flag you omit keeps its current value. Config lives in `~/.wagner/config.json`.
+
+## How It Works
+
+1. You type a prompt
+2. Wagner's **Clarifier** checks if the prompt is ambiguous
+3. The **Decomposer** breaks it into specialist subtasks
+4. Each subtask is **dispatched** to the best specialist Face
+5. The **Synthesizer** combines outputs into structured files
+6. The **Critic** reviews and triggers revision if needed
+7. Files are written to disk with `--write`
+
+Every prompt improves the system. Faces accumulate examples and get smarter over time.

wagner_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+wagner_cli/__init__.py,sha256=OVjw4OW8kgzWvH1ZJarJsv7_0LWxcHmqyIAxcu9LaoE,100
+wagner_cli/client.py,sha256=9F0etR3OJ5nc-aXiiU_NSqxR_8S8r0sou2wfWJH5-W4,3653
+wagner_cli/display.py,sha256=iNGuGbFtFReRE9FnoM9_8PXn3aC19rWbK3SuG4LSHCo,6005
+wagner_cli/main.py,sha256=0bHJcWg86rkEx83FGgKf7DO8PzABJbhKKY2kh2xjzp8,10402
+wagner_cli/writer.py,sha256=N_OlA3SZ3m2GDqR3pD3UDxQzOEVUyLbolwDXSaskTL4,2155
+wagner_cli-0.1.0.dist-info/METADATA,sha256=uvHhl13s3dCZmOiS5kJgZhE1JQBgsCXPJp5aoEhale0,3877
+wagner_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wagner_cli-0.1.0.dist-info/entry_points.txt,sha256=OePlIrKbh2sVquH6a3CTKklxilbjMNKHKvx_XBD0RIo,47
+wagner_cli-0.1.0.dist-info/top_level.txt,sha256=S6-2BghhyM95Ing387bkRBFEUCR6g1mJ7VRfeuzWE3Q,11
+wagner_cli-0.1.0.dist-info/RECORD,,

wagner_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wagner_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wagner = wagner_cli.main:cli

wagner_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wagner_cli