orchex-cli 0.1.0__py3-none-any.whl

orchex/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

orchex/__main__.py

@@ -0,0 +1,2 @@
+from orchex.cli import main
+main()

orchex/adapters/base.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional
+
+
+@dataclass
+class AdapterFeature:
+    name: str
+    description: str
+    enabled: bool = True
+
+
+class AgentAdapter(ABC):
+    name: str = ""
+    config_dir: Path = Path()
+    instruction_files: Dict[str, str] = {}
+
+    @abstractmethod
+    async def detect(self):
+        ...
+
+    @abstractmethod
+    async def send_prompt(self, prompt, working_dir):
+        ...
+
+    @abstractmethod
+    async def get_version(self):
+        ...
+
+    async def list_features(self):
+        return []
+
+    async def get_instructions(self, project_dir):
+        project_file = self.instruction_files.get("project")
+        if project_file:
+            path = project_dir / project_file
+            if path.exists():
+                return path.read_text()
+        return None

orchex/adapters/claude.py

@@ -0,0 +1,62 @@
+import asyncio
+import json
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+from orchex.adapters.base import AdapterFeature, AgentAdapter
+
+
+class ClaudeAdapter(AgentAdapter):
+    name = "claude"
+    config_dir = Path.home() / ".claude"
+    instruction_files = {
+        "project": "CLAUDE.md",
+        "global": str(Path.home() / ".claude" / "CLAUDE.md"),
+    }
+
+    async def detect(self):
+        return shutil.which("claude") is not None
+
+    async def get_version(self):
+        if not await self.detect():
+            return None
+        proc = await asyncio.create_subprocess_exec(
+            "claude", "--version",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        return stdout.decode().strip() if proc.returncode == 0 else None
+
+    async def send_prompt(self, prompt, working_dir):
+        proc = await asyncio.create_subprocess_exec(
+            "claude", "-p", prompt, "--output-format", "json",
+            cwd=str(working_dir),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+
+        if proc.returncode != 0:
+            raise RuntimeError("Claude CLI failed: %s" % stderr.decode())
+
+        data = json.loads(stdout.decode())
+        return data.get("result", "")
+
+    async def list_features(self):
+        features = []
+        settings_path = self.config_dir / "settings.json"
+        if settings_path.exists():
+            try:
+                settings = json.loads(settings_path.read_text())
+                mcp_servers = settings.get("mcpServers", {})
+                for name in mcp_servers:
+                    features.append(AdapterFeature(
+                        name="mcp:%s" % name,
+                        description="MCP server: %s" % name,
+                        enabled=True,
+                    ))
+            except (json.JSONDecodeError, KeyError):
+                pass
+        return features

orchex/adapters/codex.py

@@ -0,0 +1,46 @@
+import asyncio
+import shutil
+from pathlib import Path
+
+from orchex.adapters.base import AdapterFeature, AgentAdapter
+
+
+class CodexAdapter(AgentAdapter):
+    name = "codex"
+    config_dir = Path.home() / ".codex"
+    instruction_files = {
+        "project": "AGENTS.md",
+        "global": str(Path.home() / ".codex" / "instructions.md"),
+    }
+
+    async def detect(self):
+        return shutil.which("codex") is not None
+
+    async def get_version(self):
+        if not await self.detect():
+            return None
+        proc = await asyncio.create_subprocess_exec(
+            "codex", "--version",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        return stdout.decode().strip() if proc.returncode == 0 else None
+
+    async def send_prompt(self, prompt, working_dir):
+        proc = await asyncio.create_subprocess_exec(
+            "codex", "exec", prompt,
+            cwd=str(working_dir),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            raise RuntimeError("Codex CLI failed: %s" % stderr.decode())
+        return stdout.decode().strip()
+
+    async def list_features(self):
+        return [
+            AdapterFeature(name="sandbox", description="Sandboxed execution mode", enabled=True),
+            AdapterFeature(name="auto-edit", description="Automatic file editing", enabled=True),
+        ]

orchex/adapters/gemini.py

@@ -0,0 +1,46 @@
+import asyncio
+import shutil
+from pathlib import Path
+
+from orchex.adapters.base import AdapterFeature, AgentAdapter
+
+
+class GeminiAdapter(AgentAdapter):
+    name = "gemini"
+    config_dir = Path.home() / ".gemini"
+    instruction_files = {
+        "project": "GEMINI.md",
+        "global": str(Path.home() / ".gemini" / "GEMINI.md"),
+    }
+
+    async def detect(self):
+        return shutil.which("gemini") is not None
+
+    async def get_version(self):
+        if not await self.detect():
+            return None
+        proc = await asyncio.create_subprocess_exec(
+            "gemini", "--version",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        return stdout.decode().strip() if proc.returncode == 0 else None
+
+    async def send_prompt(self, prompt, working_dir):
+        proc = await asyncio.create_subprocess_exec(
+            "gemini", "-p", prompt,
+            cwd=str(working_dir),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            raise RuntimeError("Gemini CLI failed: %s" % stderr.decode())
+        return stdout.decode().strip()
+
+    async def list_features(self):
+        return [
+            AdapterFeature(name="google-search", description="Google Search integration", enabled=True),
+            AdapterFeature(name="multimodal", description="Multimodal input support", enabled=True),
+        ]

orchex/adapters/registry.py

@@ -0,0 +1,11 @@
+from orchex.adapters.claude import ClaudeAdapter
+from orchex.adapters.codex import CodexAdapter
+from orchex.adapters.gemini import GeminiAdapter
+
+
+def discover_adapters():
+    return [
+        ClaudeAdapter(),
+        CodexAdapter(),
+        GeminiAdapter(),
+    ]

orchex/cli.py

@@ -0,0 +1,286 @@
+import asyncio
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+from rich.rule import Rule
+from rich.live import Live
+
+from orchex.core.engine import Engine
+
+console = Console()
+
+LOGO = """[bold cyan]   ___  ____   ____ _   _ _______  __
+  / _ \\|  _ \\ / ___| | | | ____\\ \\/ /
+ | | | | |_) | |   | |_| |  _|  \\  /
+ | |_| |  _ <| |___|  _  | |___ /  \\
+  \\___/|_| \\_\\\\____|_| |_|_____/_/\\_\\[/bold cyan]"""
+
+COLORS = {"claude": "cyan", "codex": "green", "gemini": "yellow"}
+
+_verbose_mode = False
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+async def _get_engine():
+    engine = Engine()
+    await engine.init()
+    return engine
+
+
+def _agent_color(name):
+    return COLORS.get(name, "white")
+
+
+def _print_header(engine):
+    agents_str = "  ".join(
+        "[%s]%s[/%s]" % (_agent_color(a), a, _agent_color(a))
+        for a in engine.available_agents
+    )
+    offline = [a.name for a in engine.adapters if a.name not in engine.available_agents]
+    if offline:
+        agents_str += "  " + "  ".join("[dim red]%s[/dim red]" % a for a in offline)
+
+    console.print(LOGO)
+    console.print("  [bold]orchex[/bold] v0.1.0")
+    console.print("  Multi-Provider Agent Orchestrator")
+    console.print("  [dim]%s[/dim]" % Path.cwd())
+    console.print()
+    console.print("  Agents: %s" % agents_str)
+    console.print()
+    console.print(Rule(style="dim"))
+    console.print()
+
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+def main(ctx):
+    """orchex -- Multi-provider AI coding agent orchestrator.
+
+    All agents collaborate on every request.
+    """
+    if ctx.invoked_subcommand is None:
+        _run(_interactive())
+
+
+async def _interactive():
+    engine = await _get_engine()
+
+    if not engine.available_agents:
+        console.print("[red]No AI agents found. Install claude, codex, or gemini CLI.[/red]")
+        return
+
+    _print_header(engine)
+
+    while True:
+        try:
+            user_input = console.input("[bold]> [/bold]")
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[dim]Bye.[/dim]")
+            break
+
+        user_input = user_input.strip()
+        if not user_input:
+            continue
+
+        if user_input.startswith("/"):
+            handled = await _handle_command(engine, user_input)
+            if handled == "quit":
+                break
+            continue
+
+        await _orchestrate(engine, user_input)
+
+
+async def _handle_command(engine, cmd):
+    parts = cmd.split(None, 1)
+    command = parts[0].lower()
+    arg = parts[1] if len(parts) > 1 else ""
+
+    if command in ("/quit", "/exit", "/q"):
+        console.print("[dim]Bye.[/dim]")
+        return "quit"
+
+    elif command == "/agents":
+        statuses = await engine.get_agent_status()
+        table = Table(show_header=True, expand=True, border_style="dim")
+        table.add_column("Agent", style="bold")
+        table.add_column("Status")
+        table.add_column("Version")
+        table.add_column("Features", style="dim")
+        for s in statuses:
+            status = Text("ONLINE", style="green") if s["detected"] else Text("OFFLINE", style="red")
+            ver = s.get("version") or "-"
+            feats = ", ".join(f["name"] for f in s.get("features", [])[:3]) or "-"
+            table.add_row(s["name"], status, ver, feats)
+        console.print(table)
+        console.print()
+
+    elif command == "/verbose":
+        global _verbose_mode
+        _verbose_mode = not _verbose_mode
+        state = "ON" if _verbose_mode else "OFF"
+        console.print("[dim]Verbose mode: %s[/dim]" % state)
+
+    elif command == "/help":
+        console.print(Panel(
+            "[bold]Commands:[/bold]\n"
+            "  /agents    Show agent status\n"
+            "  /verbose   Toggle detailed output (responses + reviews)\n"
+            "  /help      This help\n"
+            "  /quit      Exit\n"
+            "\n"
+            "[bold]How it works:[/bold]\n"
+            "  Type any question or task. All agents work on it\n"
+            "  independently, then cross-review each other's work,\n"
+            "  and deliver a consolidated answer.",
+            title="Help",
+            border_style="dim",
+        ))
+
+    else:
+        console.print("[yellow]Unknown command. Type /help[/yellow]")
+
+    return None
+
+
+async def _orchestrate(engine, user_input):
+    """Full pipeline with live status indicators."""
+    import time
+
+    agent_status = {name: "waiting" for name in engine.available_agents}
+    current_phase = ""
+    start_time = time.time()
+
+    def _status_line():
+        """Build a dynamic status line showing each agent's state."""
+        parts = []
+        for name in engine.available_agents:
+            c = _agent_color(name)
+            st = agent_status[name]
+            if st == "waiting":
+                parts.append("[dim]%s[/dim]" % name)
+            elif st == "working":
+                parts.append("[bold %s]%s ...[/bold %s]" % (c, name, c))
+            elif st == "done":
+                parts.append("[%s]%s OK[/%s]" % (c, name, c))
+            elif st == "error":
+                parts.append("[red]%s ERR[/red]" % name)
+        elapsed = "%.0fs" % (time.time() - start_time)
+        return "[dim][%s][/dim] %s  [dim]%s[/dim]" % (current_phase, "  ".join(parts), elapsed)
+
+    def on_agent_done(agent_name, result):
+        if result.get("ok"):
+            agent_status[agent_name] = "done"
+        else:
+            agent_status[agent_name] = "error"
+        # Update live display
+        if live:
+            live.update(_status_line())
+
+    def on_phase(phase, data):
+        nonlocal current_phase
+        if phase == "asking":
+            current_phase = "Phase 1/3: Researching"
+            for name in engine.available_agents:
+                agent_status[name] = "working"
+        elif phase == "responses_done":
+            pass
+        elif phase == "reviewing":
+            current_phase = "Phase 2/3: Cross-Review"
+            for name in engine.available_agents:
+                if agent_status[name] == "done":
+                    agent_status[name] = "working"
+        elif phase == "reviews_done":
+            pass
+        elif phase == "synthesizing":
+            current_phase = "Phase 3/3: Synthesizing"
+            for name in engine.available_agents:
+                agent_status[name] = "waiting"
+            agent_status[engine.available_agents[0]] = "working"
+        if live:
+            live.update(_status_line())
+
+    live = Live(_status_line(), console=console, refresh_per_second=4)
+    with live:
+        result = await engine.orchestrate(
+            user_input, on_phase=on_phase, on_agent_done=on_agent_done
+        )
+
+    elapsed_total = "%.0fs" % (time.time() - start_time)
+    console.print()
+
+    # Verbose: show agent responses and reviews
+    if _verbose_mode:
+        console.print(Rule("Agent Responses", style="dim"))
+        console.print()
+        for r in result["responses"]:
+            c = _agent_color(r["agent"])
+            if r["ok"]:
+                console.print("[bold %s]%s[/bold %s]" % (c, r["agent"], c))
+                console.print(r["response"][:500])
+                console.print()
+
+        if result["reviews"]:
+            console.print(Rule("Cross Reviews", style="dim"))
+            console.print()
+            for r in result["reviews"]:
+                if isinstance(r, dict) and r.get("ok"):
+                    c = _agent_color(r["agent"])
+                    console.print("[bold %s]%s review[/bold %s]" % (c, r["agent"], c))
+                    console.print(r["response"][:500])
+                    console.print()
+
+    # Always show final answer
+    agent_count = len([r for r in result["responses"] if r["ok"]])
+    review_count = len([r for r in result.get("reviews", []) if isinstance(r, dict) and r.get("ok")])
+    meta = "[dim]%d agents | %d reviews | %s[/dim]" % (agent_count, review_count, elapsed_total)
+
+    console.print(Panel(
+        result["summary"][:3000],
+        title="[bold green]orchex[/bold green]",
+        subtitle=meta,
+        border_style="green",
+    ))
+    console.print()
+
+
+# --- Non-interactive subcommands ---
+
+@main.command()
+def agents():
+    """Show agent status."""
+    async def _exec():
+        engine = await _get_engine()
+        statuses = await engine.get_agent_status()
+        table = Table(show_header=True, expand=True, border_style="dim")
+        table.add_column("Agent", style="bold")
+        table.add_column("Status")
+        table.add_column("Version")
+        table.add_column("Features", style="dim")
+        for s in statuses:
+            status = Text("ONLINE", style="green") if s["detected"] else Text("OFFLINE", style="red")
+            ver = s.get("version") or "-"
+            feats = ", ".join(f["name"] for f in s.get("features", [])[:3]) or "-"
+            table.add_row(s["name"], status, ver, feats)
+        console.print(table)
+    _run(_exec())
+
+
+@main.command()
+@click.argument("prompt")
+def ask(prompt):
+    """Ask all agents a question (non-interactive)."""
+    async def _exec():
+        engine = await _get_engine()
+        if not engine.available_agents:
+            console.print("[red]No agents found.[/red]")
+            return
+        await _orchestrate(engine, prompt)
+    _run(_exec())

orchex/config/loader.py

@@ -0,0 +1,58 @@
+import os
+import sys
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+from orchex.config.schema import OrchexConfig
+
+
+def _resolve_env(value):
+    if isinstance(value, str) and value.startswith("env:"):
+        return os.environ.get(value[4:], "")
+    return value
+
+
+def load_config(project_dir):
+    config_path = project_dir / ".orchex" / "config.toml"
+    cfg = OrchexConfig()
+
+    if not config_path.exists():
+        return cfg
+
+    with open(config_path, "rb") as f:
+        data = tomllib.load(f)
+
+    ideation = data.get("ideation", {})
+    if "max_rounds" in ideation:
+        cfg.max_rounds = ideation["max_rounds"]
+    if "token_budget" in ideation:
+        cfg.token_budget = ideation["token_budget"]
+    if "discussion_mode" in ideation:
+        cfg.discussion_mode = ideation["discussion_mode"]
+
+    routing = data.get("routing", {}).get("defaults", {})
+    if routing:
+        cfg.routing_defaults.update(routing)
+
+    daemon = data.get("daemon", {})
+    if "socket_path" in daemon:
+        cfg.socket_path = daemon["socket_path"]
+    if "pid_file" in daemon:
+        cfg.pid_file = daemon["pid_file"]
+
+    tg = data.get("notify", {}).get("telegram", {})
+    if tg.get("enabled"):
+        cfg.telegram_enabled = True
+        cfg.telegram_bot_token = _resolve_env(tg.get("bot_token", ""))
+        cfg.telegram_chat_id = _resolve_env(tg.get("chat_id", ""))
+
+    dc = data.get("notify", {}).get("discord", {})
+    if dc.get("enabled"):
+        cfg.discord_enabled = True
+        cfg.discord_webhook_url = _resolve_env(dc.get("webhook_url", ""))
+
+    return cfg

orchex/config/schema.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass, field
+from typing import Dict
+
+
+@dataclass
+class OrchexConfig:
+    max_rounds: int = 5
+    token_budget: int = 50000
+    discussion_mode: str = "free"
+    routing_defaults: Dict[str, str] = field(default_factory=lambda: {
+        "architecture": "claude",
+        "implementation": "codex",
+        "research": "gemini",
+        "testing": "claude",
+        "review": "round-robin",
+    })
+    socket_path: str = "/tmp/orchex.sock"
+    pid_file: str = "/tmp/orchex.pid"
+    telegram_enabled: bool = False
+    telegram_bot_token: str = ""
+    telegram_chat_id: str = ""
+    discord_enabled: bool = False
+    discord_webhook_url: str = ""