astromesh-cli 0.1.1__py3-none-any.whl

astromesh_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Astromesh CLI — manage Astromesh nodes and clusters."""
+
+__version__ = "0.1.1"

astromesh_cli/client.py

@@ -0,0 +1,41 @@
+"""HTTP client for communicating with astromeshd."""
+
+import os
+
+import httpx
+
+DEFAULT_URL = "http://localhost:8000"
+
+
+def get_base_url() -> str:
+    return os.environ.get("ASTROMESH_DAEMON_URL", DEFAULT_URL)
+
+
+def api_get(path: str) -> dict:
+    url = f"{get_base_url()}{path}"
+    resp = httpx.get(url, timeout=5.0)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def api_post(path: str, json: dict | None = None) -> dict:
+    url = f"{get_base_url()}{path}"
+    resp = httpx.post(url, json=json, timeout=5.0)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def api_post_with_timeout(path: str, json: dict | None = None, timeout: float = 30.0) -> dict:
+    """POST with configurable timeout for long-running operations."""
+    url = f"{get_base_url()}{path}"
+    resp = httpx.post(url, json=json, timeout=timeout)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def api_get_params(path: str, params: dict | None = None, timeout: float = 5.0) -> dict:
+    """GET with query parameters."""
+    url = f"{get_base_url()}{path}"
+    resp = httpx.get(url, params=params, timeout=timeout)
+    resp.raise_for_status()
+    return resp.json()

astromesh_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules."""

astromesh_cli/commands/agents.py

@@ -0,0 +1,41 @@
+"""astromeshctl agents commands."""
+
+import typer
+from rich.table import Table
+
+from astromesh_cli.client import api_get
+from astromesh_cli.output import console, print_error, print_json
+
+app = typer.Typer(help="Manage agents.")
+
+
+@app.command("list")
+def list_agents(json: bool = typer.Option(False, "--json", help="Output as JSON")):
+    """List loaded agents."""
+    try:
+        data = api_get("/v1/agents")
+        if json:
+            print_json(data)
+            return
+
+        agents = data.get("agents", [])
+        if not agents:
+            console.print("[dim]No agents loaded.[/dim]")
+            return
+
+        table = Table(title="Loaded Agents")
+        table.add_column("Name", style="cyan")
+        table.add_column("Version", style="green")
+        table.add_column("Namespace", style="dim")
+
+        for agent in agents:
+            table.add_row(
+                agent.get("name", ""),
+                agent.get("version", ""),
+                agent.get("namespace", ""),
+            )
+
+        console.print(table)
+    except Exception:
+        print_error("Daemon not reachable.")
+        raise typer.Exit(code=0)

astromesh_cli/commands/ask.py

@@ -0,0 +1,111 @@
+"""astromeshctl ask — Copilot CLI interface."""
+
+import uuid
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.markdown import Markdown
+from rich.panel import Panel
+
+from astromesh_cli.client import api_post_with_timeout
+from astromesh_cli.output import console, print_error, print_json
+
+COPILOT_AGENT = "astromesh-copilot"
+MAX_CONTEXT_SIZE = 100 * 1024  # 100KB
+ALLOWED_CONTEXT_PREFIXES = ("config", "docs")
+
+
+def _validate_context_path(path: Path) -> bool:
+    """Validate that a context file path is safe to read.
+
+    Must be under ./config/ or ./docs/, must exist, and must be < 100KB.
+    """
+    try:
+        resolved = path.resolve()
+        cwd = Path.cwd().resolve()
+
+        # Check that the path is under an allowed prefix
+        relative = resolved.relative_to(cwd)
+        parts = relative.parts
+        if not parts or parts[0] not in ALLOWED_CONTEXT_PREFIXES:
+            print_error(f"Context file must be under config/ or docs/. Got: {relative}")
+            return False
+    except (ValueError, OSError):
+        print_error(f"Context file path is not within the project directory: {path}")
+        return False
+
+    if not path.exists():
+        print_error(f"Context file does not exist: {path}")
+        return False
+
+    if not path.is_file():
+        print_error(f"Context path is not a file: {path}")
+        return False
+
+    if path.stat().st_size > MAX_CONTEXT_SIZE:
+        print_error(f"Context file too large (max 100KB): {path}")
+        return False
+
+    return True
+
+
+def ask_command(
+    query: str = typer.Argument(..., help="Question or request for the copilot"),
+    context: Optional[str] = typer.Option(
+        None, "--context", help="Path to a context file (must be under config/ or docs/)"
+    ),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Run in dry-run mode (no side effects)"),
+    session: Optional[str] = typer.Option(
+        None, "--session", help="Session ID for multi-turn conversation"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Ask the Astromesh Copilot a question."""
+    full_query = query
+    context_content = None
+
+    if context:
+        context_path = Path(context)
+        if not _validate_context_path(context_path):
+            raise typer.Exit(code=1)
+        context_content = context_path.read_text()
+        full_query = f"{query}\n\n---\nContext from {context}:\n{context_content}"
+
+    session_id = session or str(uuid.uuid4())
+
+    metadata: dict = {}
+    if context_content:
+        metadata["context_file"] = context_content
+    if dry_run:
+        metadata["dry_run"] = True
+
+    try:
+        data = api_post_with_timeout(
+            f"/v1/agents/{COPILOT_AGENT}/run",
+            json={
+                "query": full_query,
+                "session_id": session_id,
+                "metadata": metadata,
+            },
+            timeout=60.0,
+        )
+    except Exception as e:
+        print_error(f"Failed to reach copilot: {e}")
+        raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(data)
+        return
+
+    response_text = data.get("response", "")
+    trace_id = data.get("trace_id", "N/A")
+
+    console.print(
+        Panel(
+            Markdown(response_text),
+            title="[cyan]Astromesh Copilot[/cyan]",
+            subtitle=f"trace: {trace_id}",
+            border_style="cyan",
+        )
+    )

astromesh_cli/commands/dev.py

@@ -0,0 +1,43 @@
+"""astromeshctl dev — Hot-reload development server."""
+
+import typer
+from rich.panel import Panel
+
+from astromesh_cli.output import console
+
+
+def _launch_uvicorn(
+    host: str = "0.0.0.0",
+    port: int = 8000,
+    reload: bool = True,
+    reload_dirs: list[str] | None = None,
+) -> None:
+    """Launch uvicorn with the given configuration."""
+    import uvicorn
+
+    uvicorn.run(
+        "astromesh.api.main:app",
+        host=host,
+        port=port,
+        reload=reload,
+        reload_dirs=reload_dirs or ["astromesh", "config"],
+    )
+
+
+def dev_command(
+    host: str = typer.Option("0.0.0.0", "--host", help="Bind host"),
+    port: int = typer.Option(8000, "--port", help="Bind port"),
+    config: str = typer.Option("./config", "--config", help="Config directory"),
+    no_open: bool = typer.Option(False, "--no-open", help="Skip opening browser"),
+) -> None:
+    """Start the Astromesh dev server with hot-reload."""
+    banner = (
+        f"[bold cyan]Astromesh Dev Server[/bold cyan]\n\n"
+        f"  Host:   {host}\n"
+        f"  Port:   {port}\n"
+        f"  Config: {config}\n"
+        f"  Reload: enabled"
+    )
+    console.print(Panel(banner, title="astromesh dev", border_style="cyan"))
+
+    _launch_uvicorn(host=host, port=port, reload=True, reload_dirs=["astromesh", "config"])

astromesh_cli/commands/doctor.py

@@ -0,0 +1,74 @@
+"""astromeshctl doctor command."""
+
+import subprocess
+import sys
+
+import typer
+from rich.table import Table
+
+from astromesh_cli.client import api_get
+from astromesh_cli.output import console, print_error, print_json
+
+app = typer.Typer()
+
+STATUS_ICONS = {
+    "ok": "[green]OK[/green]",
+    "degraded": "[yellow]DEGRADED[/yellow]",
+    "error": "[red]ERROR[/red]",
+    "unavailable": "[red]UNAVAILABLE[/red]",
+}
+
+
+def _check_stale_astromesh_package() -> str | None:
+    """Return a warning string if the old 'astromesh' deb package is still installed."""
+    if sys.platform != "linux":
+        return None
+    try:
+        result = subprocess.run(
+            ["dpkg", "-l", "astromesh"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and "astromesh" in result.stdout:
+            # Ensure it's the old package, not the new astromesh-node package
+            if "astromesh-node" not in result.stdout:
+                return (
+                    "Stale 'astromesh' package detected. "
+                    "Upgrade to astromesh-node: sudo dpkg -i astromesh-node-*.deb"
+                )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass  # dpkg not available or timed out
+    return None
+
+
+@app.callback(invoke_without_command=True)
+def doctor(json: bool = typer.Option(False, "--json", help="Output as JSON")):
+    """Run system health checks."""
+    migration_warning = _check_stale_astromesh_package()
+    if migration_warning:
+        console.print(f"[yellow]WARNING:[/yellow] {migration_warning}\n")
+
+    try:
+        data = api_get("/v1/system/doctor")
+        if json:
+            print_json(data)
+            return
+
+        healthy = data["healthy"]
+        header = "[green]System Healthy[/green]" if healthy else "[red]System Unhealthy[/red]"
+        console.print(f"\n{header}\n")
+
+        table = Table()
+        table.add_column("Check", style="cyan")
+        table.add_column("Status")
+        table.add_column("Message", style="dim")
+
+        for name, check in data["checks"].items():
+            status_display = STATUS_ICONS.get(check["status"], check["status"])
+            table.add_row(name, status_display, check.get("message", ""))
+
+        console.print(table)
+    except Exception:
+        print_error("Daemon not reachable at configured URL.")
+        raise typer.Exit(code=0)

astromesh_cli/commands/mesh.py

@@ -0,0 +1,105 @@
+"""astromeshctl mesh commands."""
+
+import typer
+from rich.table import Table
+
+from astromesh_cli.client import api_get, api_post
+from astromesh_cli.output import console, print_error, print_json
+
+app = typer.Typer(help="Mesh cluster management.")
+
+
+@app.command("status")
+def mesh_status(json: bool = typer.Option(False, "--json", help="Output as JSON")):
+    """Show mesh cluster summary."""
+    try:
+        data = api_get("/v1/mesh/state")
+        if json:
+            print_json(data)
+            return
+
+        nodes = data.get("nodes", [])
+        leader_id = data.get("leader_id")
+        leader_name = ""
+        for n in nodes:
+            if n.get("node_id") == leader_id:
+                leader_name = n.get("name", leader_id)
+                break
+
+        console.print("[bold]Mesh Cluster[/bold]")
+        console.print(f"  Nodes:   {len(nodes)}")
+        console.print(f"  Leader:  {leader_name or 'none'}")
+        console.print(f"  Version: {data.get('version', 0)}")
+
+        alive = sum(1 for n in nodes if n.get("status") == "alive")
+        suspect = sum(1 for n in nodes if n.get("status") == "suspect")
+        dead = sum(1 for n in nodes if n.get("status") == "dead")
+        console.print(f"  Alive:   {alive}  Suspect: {suspect}  Dead: {dead}")
+    except Exception:
+        print_error("Mesh not enabled or daemon not reachable.")
+        raise typer.Exit(code=0)
+
+
+@app.command("nodes")
+def mesh_nodes(json: bool = typer.Option(False, "--json", help="Output as JSON")):
+    """List all nodes in the mesh."""
+    try:
+        data = api_get("/v1/mesh/state")
+        if json:
+            print_json(data)
+            return
+
+        nodes = data.get("nodes", [])
+        leader_id = data.get("leader_id")
+
+        if not nodes:
+            console.print("[dim]No nodes in mesh.[/dim]")
+            return
+
+        table = Table(title="Mesh Nodes")
+        table.add_column("Name", style="cyan")
+        table.add_column("URL", style="green")
+        table.add_column("Services", style="dim")
+        table.add_column("Agents", style="dim")
+        table.add_column("Load", style="yellow")
+        table.add_column("Status")
+        table.add_column("Leader")
+
+        for node in nodes:
+            services = ", ".join(node.get("services", []))
+            agents = ", ".join(node.get("agents", []))
+            load = node.get("load", {})
+            load_str = f"CPU:{load.get('cpu_percent', 0):.0f}% Req:{load.get('active_requests', 0)}"
+            status = node.get("status", "unknown")
+            status_display = {
+                "alive": "[green]alive[/green]",
+                "suspect": "[yellow]suspect[/yellow]",
+                "dead": "[red]dead[/red]",
+            }.get(status, status)
+            is_leader = "[bold green]YES[/bold green]" if node.get("node_id") == leader_id else ""
+
+            table.add_row(
+                node.get("name", ""),
+                node.get("url", ""),
+                services,
+                agents,
+                load_str,
+                status_display,
+                is_leader,
+            )
+
+        console.print(table)
+    except Exception:
+        print_error("Mesh not enabled or daemon not reachable.")
+        raise typer.Exit(code=0)
+
+
+@app.command("leave")
+def mesh_leave():
+    """Gracefully leave the mesh."""
+    try:
+        api_post("/v1/mesh/leave", json={"node_id": "self"})
+        console.print("[green]Left mesh successfully.[/green]")
+    except Exception:
+        print_error("Failed to leave mesh.")
+        raise typer.Exit(code=0)

astromesh_cli/commands/metrics.py

@@ -0,0 +1,43 @@
+"""astromeshctl metrics/cost — Aggregated metrics and cost summary."""
+
+from typing import Optional
+
+import typer
+
+from astromesh_cli.client import api_get
+from astromesh_cli.output import print_cost_table, print_error, print_json, print_metrics_table
+
+
+def metrics_command(
+    agent: Optional[str] = typer.Option(None, "--agent", help="Filter by agent name"),
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Show aggregated runtime metrics."""
+    try:
+        data = api_get("/v1/metrics/")
+    except Exception as e:
+        print_error(f"Failed to fetch metrics: {e}")
+        raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(data)
+        return
+
+    print_metrics_table(data)
+
+
+def cost_command(
+    json_output: bool = typer.Option(False, "--json", help="Output raw JSON"),
+) -> None:
+    """Show cost summary."""
+    try:
+        data = api_get("/v1/metrics/")
+    except Exception as e:
+        print_error(f"Failed to fetch metrics: {e}")
+        raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(data)
+        return
+
+    print_cost_table(data)

astromesh_cli/commands/new.py

@@ -0,0 +1,168 @@
+"""astromeshctl new — Scaffold new agents, workflows, and tools."""
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from jinja2 import Environment, FileSystemLoader
+from rich.panel import Panel
+
+from astromesh_cli.output import console, print_error
+
+TEMPLATES_DIR = Path(__file__).resolve().parent.parent / "templates"
+
+app = typer.Typer(help="Scaffold new agents, workflows, and tools.")
+
+
+def _get_jinja_env() -> Environment:
+    return Environment(loader=FileSystemLoader(str(TEMPLATES_DIR)), keep_trailing_newline=True)
+
+
+def render_agent_template(
+    name: str,
+    provider: str = "ollama",
+    model: str = "llama3.1:8b",
+    orchestration_pattern: str = "react",
+    tools: list[str] | None = None,
+    temperature: float = 0.3,
+    max_tokens: int = 2048,
+    description: str = "",
+) -> str:
+    """Render an agent YAML template."""
+    env = _get_jinja_env()
+    template = env.get_template("agent.yaml.j2")
+    display_name = name.replace("-", " ").replace("_", " ").title()
+    return template.render(
+        name=name,
+        display_name=display_name,
+        description=description or f"Agent {display_name}",
+        provider=provider,
+        model=model,
+        orchestration_pattern=orchestration_pattern,
+        tools=tools or [],
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+
+
+def render_workflow_template(
+    name: str,
+    description: str = "",
+) -> str:
+    """Render a workflow YAML template."""
+    env = _get_jinja_env()
+    template = env.get_template("workflow.yaml.j2")
+    return template.render(
+        name=name,
+        description=description or f"Workflow {name}",
+    )
+
+
+def render_tool_template(
+    name: str,
+    description: str = "A custom tool",
+) -> str:
+    """Render a tool Python file template."""
+    env = _get_jinja_env()
+    template = env.get_template("tool.py.j2")
+    # Convert snake_case name to PascalCase class name
+    class_name = "".join(part.capitalize() for part in name.split("_"))
+    return template.render(
+        name=name,
+        description=description,
+        class_name=class_name,
+    )
+
+
+@app.command("agent")
+def new_agent(
+    name: str = typer.Argument(..., help="Agent name (e.g., my-bot)"),
+    provider: str = typer.Option("ollama", "--provider", help="LLM provider"),
+    model: str = typer.Option("llama3.1:8b", "--model", help="Model name"),
+    orchestration: str = typer.Option("react", "--orchestration", help="Orchestration pattern"),
+    tools: Optional[list[str]] = typer.Option(None, "--tools", help="Tools to include"),
+    output_dir: str = typer.Option("./config/agents", "--output-dir", help="Output directory"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing file"),
+) -> None:
+    """Scaffold a new agent YAML configuration."""
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    dest = out / f"{name}.agent.yaml"
+
+    if dest.exists() and not force:
+        print_error(f"File already exists: {dest}. Use --force to overwrite.")
+        raise typer.Exit(code=0)
+
+    content = render_agent_template(
+        name=name,
+        provider=provider,
+        model=model,
+        orchestration_pattern=orchestration,
+        tools=tools,
+    )
+    dest.write_text(content)
+    console.print(
+        Panel(
+            f"[green]Created agent:[/green] {dest}\n\n"
+            f"  Provider: {provider}\n"
+            f"  Model: {model}\n"
+            f"  Pattern: {orchestration}",
+            title="astromesh new agent",
+            border_style="green",
+        )
+    )
+
+
+@app.command("workflow")
+def new_workflow(
+    name: str = typer.Argument(..., help="Workflow name"),
+    output_dir: str = typer.Option("./config/workflows", "--output-dir", help="Output directory"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing file"),
+) -> None:
+    """Scaffold a new workflow YAML configuration."""
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    dest = out / f"{name}.workflow.yaml"
+
+    if dest.exists() and not force:
+        print_error(f"File already exists: {dest}. Use --force to overwrite.")
+        raise typer.Exit(code=0)
+
+    content = render_workflow_template(name=name)
+    dest.write_text(content)
+    console.print(
+        Panel(
+            f"[green]Created workflow:[/green] {dest}",
+            title="astromesh new workflow",
+            border_style="green",
+        )
+    )
+
+
+@app.command("tool")
+def new_tool(
+    name: str = typer.Argument(..., help="Tool name (snake_case)"),
+    description: str = typer.Option("A custom tool", "--description", help="Tool description"),
+    output_dir: str = typer.Option(".", "--output-dir", help="Output directory"),
+    force: bool = typer.Option(False, "--force", help="Overwrite existing file"),
+) -> None:
+    """Scaffold a new custom tool Python file."""
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    dest = out / f"{name}.py"
+
+    if dest.exists() and not force:
+        print_error(f"File already exists: {dest}. Use --force to overwrite.")
+        raise typer.Exit(code=0)
+
+    content = render_tool_template(name=name, description=description)
+    dest.write_text(content)
+    console.print(
+        Panel(
+            f"[green]Created tool:[/green] {dest}\n\n"
+            f"  Class: {name.replace('_', ' ').title().replace(' ', '')}Tool\n"
+            f"  Description: {description}",
+            title="astromesh new tool",
+            border_style="green",
+        )
+    )

astromesh_cli/commands/peers.py

@@ -0,0 +1,38 @@
+"""astromeshctl peers commands."""
+
+import typer
+from rich.table import Table
+
+from astromesh_cli.client import api_get
+from astromesh_cli.output import console, print_error, print_json
+
+app = typer.Typer(help="Manage peer nodes.")
+
+
+@app.command("list")
+def list_peers(json: bool = typer.Option(False, "--json", help="Output as JSON")):
+    """List configured peer nodes."""
+    try:
+        data = api_get("/v1/system/status")
+        if json:
+            print_json({"peers": data.get("peers", [])})
+            return
+
+        peers = data.get("peers", [])
+        if not peers:
+            console.print("[dim]No peers configured.[/dim]")
+            return
+
+        table = Table(title="Peer Nodes")
+        table.add_column("Name", style="cyan")
+        table.add_column("URL", style="green")
+        table.add_column("Services", style="dim")
+
+        for peer in peers:
+            services = ", ".join(peer.get("services", []))
+            table.add_row(peer.get("name", ""), peer.get("url", ""), services)
+
+        console.print(table)
+    except Exception:
+        print_error("Daemon not reachable.")
+        raise typer.Exit(code=0)