github-sync-agent 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

github_sync/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.0"
+__version__ = "0.3.0"

github_sync/api.py

@@ -3,14 +3,17 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
+from pathlib import Path
 
 from fastapi import Depends, FastAPI, HTTPException, Security
+from fastapi.responses import HTMLResponse, StreamingResponse
 from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from . import __version__
-from . import agent
+from . import tools
 
 LOG = logging.getLogger(__name__)
 _security = HTTPBearer(auto_error=False)
@@ -47,6 +50,10 @@ class StatusResponse(BaseModel):
     projects: list[StatusRow]
 
 
+class ChatRequest(BaseModel):
+    query: str
+
+
 def create_app(cfg: dict) -> FastAPI:
     api_key: str = cfg.get("api_key") or ""
 
@@ -64,17 +71,39 @@ def create_app(cfg: dict) -> FastAPI:
         if credentials is None or credentials.credentials != api_key:
             raise HTTPException(status_code=401, detail="Invalid or missing API key")
 
+    _chat_html = (Path(__file__).parent / "static" / "chat.html").read_text()
+
+    @app.get("/", include_in_schema=False)
+    async def index() -> HTMLResponse:
+        # Inject API key and config so the browser UI can authenticate
+        html = _chat_html.replace(
+            "const API_KEY = null;",
+            f"const API_KEY = {json.dumps(api_key or '')};",
+        ).replace(
+            "const LLM_MODEL = null;",
+            f"const LLM_MODEL = {json.dumps(str(cfg.get('llm_model', 'gemma3:4b')))};",
+        ).replace(
+            "const GITHUB_USER = null;",
+            f"const GITHUB_USER = {json.dumps(str(cfg.get('github_user', '')))};",
+        )
+        return HTMLResponse(html)
+
     @app.get("/health")
     async def health() -> dict[str, str]:
         return {"status": "ok", "version": __version__}
 
+    @app.get("/tools", dependencies=[Depends(require_auth)])
+    async def list_tools() -> list[dict]:
+        return tools.list_tools()
+
     @app.get("/status", response_model=StatusResponse, dependencies=[Depends(require_auth)])
     async def status() -> StatusResponse:
-        rows = await asyncio.to_thread(agent.get_status, cfg)
+        result = await asyncio.to_thread(tools.run_tool, "get_status", cfg, {})
+        data = result["data"]
         return StatusResponse(
-            github_user=cfg["github_user"],
-            projects_root=cfg["projects_root"],
-            projects=[StatusRow(**row) for row in rows],
+            github_user=data["github_user"],
+            projects_root=data["projects_root"],
+            projects=[StatusRow(**row) for row in data["projects"]],
         )
 
     @app.post("/sync", response_model=SyncResponse, dependencies=[Depends(require_auth)])
@@ -85,27 +114,56 @@ def create_app(cfg: dict) -> FastAPI:
     async def sync_one(project: str, body: SyncRequest = SyncRequest()) -> SyncResponse:
         return await _run_sync(cfg, project=project, dry_run=body.dry_run)
 
+    @app.post("/chat", dependencies=[Depends(require_auth)])
+    async def chat(body: ChatRequest):
+        async def generate():
+            try:
+                from .llm import ask_stream
+                async for event in ask_stream(body.query, cfg):
+                    yield f"data: {json.dumps(event)}\n\n"
+            except ImportError:
+                yield f"data: {json.dumps({'type': 'error', 'message': 'LLM deps not installed. Run: pip install httpx'})}\n\n"
+                yield f"data: {json.dumps({'type': 'done'})}\n\n"
+            except Exception as exc:
+                LOG.exception("Chat error")
+                yield f"data: {json.dumps({'type': 'error', 'message': str(exc)})}\n\n"
+                yield f"data: {json.dumps({'type': 'done'})}\n\n"
+
+        return StreamingResponse(
+            generate(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "X-Accel-Buffering": "no",
+                "Connection": "keep-alive",
+            },
+        )
+
     return app
 
 
 async def _run_sync(cfg: dict, project: str | None, dry_run: bool) -> SyncResponse:
-    try:
-        projects = await asyncio.to_thread(agent.discover_projects, cfg, project)
-    except ValueError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-    results: list[SyncResult] = []
-    for path in projects:
-        ok = await asyncio.to_thread(agent.sync_project, path, cfg, dry_run)
-        results.append(SyncResult(project=path.name, success=ok))
-        level = logging.INFO if ok else logging.ERROR
-        LOG.log(level, "%s %s", path.name, "synced" if ok else "FAILED")
-
-    synced = sum(1 for r in results if r.success)
-    failed = len(results) - synced
+    tool_name = "sync_project" if project else "sync_all"
+    args: dict = {"dry_run": dry_run}
+    if project:
+        args["project"] = project
+
+    result = await asyncio.to_thread(tools.run_tool, tool_name, cfg, args)
+    if not result["ok"] and project and "not found" in result["message"].lower():
+        raise HTTPException(status_code=404, detail=result["message"])
+
+    data = result["data"]
+    results = [SyncResult(**r) for r in data.get("results", [])]
+    if project and not results:
+        results = [SyncResult(project=project, success=result["ok"])]
+
+    for r in results:
+        level = logging.INFO if r.success else logging.ERROR
+        LOG.log(level, "%s %s", r.project, "synced" if r.success else "FAILED")
+
     return SyncResponse(
-        success=failed == 0,
-        synced=synced,
-        failed=failed,
+        success=result["ok"],
+        synced=data.get("synced", 1 if result["ok"] else 0),
+        failed=data.get("failed", 0 if result["ok"] else 1),
         results=results,
     )

github_sync/cli.py

@@ -6,7 +6,7 @@ from pathlib import Path
 import click
 
 from . import __version__
-from . import agent, config, setup
+from . import agent, config, setup, tools
 
 LOG_FORMAT = "%(asctime)s  %(levelname)-8s  %(message)s"
 
@@ -120,7 +120,7 @@ def status(ctx: click.Context) -> None:
             f"{root_short:<30} "
             f"{'✓' if row['git'] else '✗':<6} "
             f"{'✓' if row['remote'] else '✗':<8} "
-            f"{'dirty' if row['changes'] else 'clean':<10} "
+            f"{'unsynced' if row['changes'] else 'synced':<10} "
             f"{'✓' if row['on_github'] else '✗'}"
         )
     click.echo()
@@ -257,6 +257,69 @@ def init() -> None:
     click.echo()
 
 
+# ---------------------------------------------------------------------------
+# tools
+# ---------------------------------------------------------------------------
+
+@cli.group()
+def tool() -> None:
+    """Inspect and run shared tools (used by MCP / LLM)."""
+
+
+@tool.command("list")
+def tool_list() -> None:
+    """List available tools and their schemas."""
+    for t in tools.list_tools():
+        click.echo(f"\n{click.style(t['name'], bold=True)}")
+        click.echo(f"  {t['description']}")
+        props = t["input_schema"].get("properties") or {}
+        if props:
+            click.echo("  Parameters:")
+            for name, spec in props.items():
+                req = "required" if name in t["input_schema"].get("required", []) else "optional"
+                click.echo(f"    - {name} ({spec.get('type', 'any')}, {req}): {spec.get('description', '')}")
+        else:
+            click.echo("  Parameters: none")
+    click.echo()
+
+
+@tool.command("run")
+@click.argument("name")
+@click.option("--arg", "args", multiple=True, help="Tool argument as key=value")
+@click.option("--config", "config_path", type=click.Path(path_type=Path), default=None)
+def tool_run(name: str, args: tuple[str, ...], config_path: Path | None) -> None:
+    """Run a tool by name (e.g. github-sync tool run get_status)."""
+    try:
+        cfg = config.load(config_path)
+    except (FileNotFoundError, ValueError) as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    _setup_logging(cfg)
+
+    arguments: dict = {}
+    for item in args:
+        if "=" not in item:
+            click.echo(f"Error: invalid --arg '{item}' (use key=value)", err=True)
+            sys.exit(1)
+        key, _, value = item.partition("=")
+        if value.lower() in ("true", "false"):
+            arguments[key] = value.lower() == "true"
+        else:
+            arguments[key] = value
+
+    try:
+        result = tools.run_tool(name, cfg, arguments)
+    except KeyError as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    import json
+    click.echo(json.dumps(result, indent=2))
+    if not result.get("ok"):
+        sys.exit(1)
+
+
 # ---------------------------------------------------------------------------
 # serve
 # ---------------------------------------------------------------------------
@@ -285,12 +348,351 @@ def serve(ctx: click.Context, host: str | None, port: int | None) -> None:
 
     auth_note = "API key required" if cfg.get("api_key") else "no auth (localhost only recommended)"
     click.echo(f"Starting GitHub Sync API on http://{bind_host}:{bind_port} ({auth_note})")
-    click.echo("Endpoints: GET /health  GET /status  POST /sync  POST /sync/{project}")
+    click.echo("Endpoints: GET /health  GET /tools  GET /status  POST /sync  POST /sync/{project}")
     click.echo()
 
     uvicorn.run(app, host=bind_host, port=bind_port, log_level=cfg.get("log_level", "info").lower())
 
 
+# ---------------------------------------------------------------------------
+# ask (LLM / Ollama)
+# ---------------------------------------------------------------------------
+
+@cli.command()
+@click.argument("query", nargs=-1, required=True)
+@click.option("--model", default=None, help="Ollama model (default: llm_model from config)")
+@click.option("--ollama-url", default=None, help="Ollama base URL (default: ollama_url from config)")
+@click.pass_context
+def ask(ctx: click.Context, query: tuple[str, ...], model: str | None, ollama_url: str | None) -> None:
+    """Ask a question in plain English — the LLM calls tools as needed.
+
+    Examples:\n
+      github-sync ask what is the status of my projects\n
+      github-sync ask sync the Agents project\n
+      github-sync ask are there any projects with uncommitted changes
+    """
+    try:
+        from . import llm
+    except ImportError:
+        click.echo("Error: LLM dependencies not installed.", err=True)
+        click.echo("Run: pip install 'github-sync-agent[llm]'", err=True)
+        sys.exit(1)
+
+    cfg = ctx.obj["cfg"]
+    _setup_logging(cfg)
+
+    if model:
+        cfg = {**cfg, "llm_model": model}
+    if ollama_url:
+        cfg = {**cfg, "ollama_url": ollama_url}
+
+    question = " ".join(query)
+    ollama = cfg.get("ollama_url", "http://localhost:11434")
+    llm_model = cfg.get("llm_model", "gemma3:4b")
+
+    click.echo(f"Asking {llm_model} via {ollama} ...\n")
+
+    try:
+        import httpx
+        answer = llm.ask(question, cfg)
+    except httpx.HTTPError as exc:
+        click.echo(click.style(f"Connection error: {exc}", fg="red"), err=True)
+        click.echo("Is Ollama running? Try: ollama serve", err=True)
+        sys.exit(1)
+    except Exception as exc:
+        import traceback
+        click.echo(click.style(f"Error: {type(exc).__name__}: {exc}", fg="red"), err=True)
+        click.echo(traceback.format_exc(), err=True)
+        sys.exit(1)
+
+    click.echo(answer)
+
+
+# ---------------------------------------------------------------------------
+# doctor / start / stop
+# ---------------------------------------------------------------------------
+
+def _check(label: str, ok: bool, detail: str = "", fix: str = "") -> bool:
+    icon = click.style("✓", fg="green") if ok else click.style("✗", fg="red")
+    line = f"  {icon}  {label}"
+    if detail:
+        line += f"  ({detail})"
+    click.echo(line)
+    if not ok and fix:
+        click.echo(f"       → {fix}")
+    return ok
+
+
+def _cmd_ok(*cmd: str) -> tuple[bool, str]:
+    import subprocess
+    r = subprocess.run(list(cmd), capture_output=True, text=True)
+    return r.returncode == 0, (r.stdout + r.stderr).strip()
+
+
+def _port_pid(port: int) -> int | None:
+    """Return PID listening on port, or None."""
+    import subprocess
+    r = subprocess.run(["lsof", "-ti", f":{port}"], capture_output=True, text=True)
+    out = r.stdout.strip()
+    return int(out.split()[0]) if out else None
+
+
+def _ollama_url(cfg: dict | None) -> str:
+    return (cfg or {}).get("ollama_url", "http://localhost:11434")
+
+
+def _ollama_running(url: str) -> bool:
+    try:
+        import urllib.request
+        urllib.request.urlopen(url, timeout=2)
+        return True
+    except Exception:
+        return False
+
+
+@cli.command()
+@click.pass_context
+def doctor(ctx: click.Context) -> None:
+    """Check all prerequisites and service status."""
+    click.echo()
+    click.echo(click.style("=== GitHub Sync Agent — Doctor ===", bold=True))
+    click.echo()
+
+    all_ok = True
+
+    # ── System tools ──────────────────────────────────────────────
+    click.echo(click.style("System tools", bold=True))
+    ok, ver = _cmd_ok("git", "--version")
+    all_ok &= _check("git", ok, ver.split("\n")[0], _install_hint("git"))
+
+    ok, ver = _cmd_ok("gh", "--version")
+    all_ok &= _check("gh (GitHub CLI)", ok, ver.split("\n")[0], _install_hint("gh"))
+
+    ok, ver = _cmd_ok("python3", "--version")
+    all_ok &= _check("python3", ok, ver)
+
+    click.echo()
+
+    # ── GitHub auth ───────────────────────────────────────────────
+    click.echo(click.style("GitHub", bold=True))
+    from . import setup as _setup
+    auth_ok = _setup.gh_authenticated()
+    gh_user = _setup.get_github_username() if auth_ok else ""
+    all_ok &= _check("gh authenticated", auth_ok, gh_user, "Run: gh auth login")
+
+    ssh_ok, ssh_msg, _ = _setup.ensure_github_ssh()
+    ssh_user = _setup.ssh_auth_username(ssh_msg) if ssh_ok else ""
+    all_ok &= _check("SSH to github.com", ssh_ok, ssh_user or ssh_msg[:60],
+                     "Run: github-sync init")
+    click.echo()
+
+    # ── Config ────────────────────────────────────────────────────
+    click.echo(click.style("Configuration", bold=True))
+    cfg = None
+    try:
+        from . import config as _config
+        cfg = _config.load()
+        all_ok &= _check("config file", True, str(_config.DEFAULT_CONFIG
+                          if _config.DEFAULT_CONFIG.exists() else _config.FALLBACK_CONFIG))
+        all_ok &= _check("projects_root exists",
+                          all(Path(r).exists() for r in cfg["projects_root"]),
+                          ", ".join(cfg["projects_root"]))
+    except (FileNotFoundError, ValueError) as exc:
+        all_ok &= _check("config file", False, str(exc), "Run: github-sync init")
+    click.echo()
+
+    # ── Ollama / LLM ──────────────────────────────────────────────
+    click.echo(click.style("Ollama / LLM  (optional — needed for ask + web chat)", bold=True))
+    ok, _ = _cmd_ok("ollama", "--version")
+    _check("ollama installed", ok, fix="See https://ollama.com/download")
+
+    url = _ollama_url(cfg)
+    running = _ollama_running(url)
+    _check("ollama running", running, url, "Run: ollama serve")
+
+    if running:
+        import json as _json, urllib.request as _req
+        try:
+            data = _json.loads(_req.urlopen(f"{url}/api/tags", timeout=3).read())
+            models = [m["name"] for m in data.get("models", [])]
+            model_name = cfg.get("llm_model", "gemma3:4b") if cfg else "gemma3:4b"
+            has_model = any(model_name in m for m in models)
+            _check(f"model {model_name}", has_model,
+                   "available" if has_model else "not pulled",
+                   f"Run: ollama pull {model_name}")
+        except Exception:
+            _check("model check", False, "could not query Ollama")
+    click.echo()
+
+    # ── Services ──────────────────────────────────────────────────
+    click.echo(click.style("Services", bold=True))
+    api_port = int((cfg or {}).get("api_port", 8741))
+    api_pid = _port_pid(api_port)
+    _check(f"HTTP API / web UI  (port {api_port})",
+           api_pid is not None,
+           f"pid {api_pid}" if api_pid else "not running",
+           "Run: github-sync start")
+    click.echo()
+
+    # ── Summary ───────────────────────────────────────────────────
+    if all_ok:
+        click.echo(click.style("  All checks passed ✓", fg="green", bold=True))
+    else:
+        click.echo(click.style("  Some checks failed — see above for fixes.", fg="yellow"))
+    click.echo()
+
+
+@cli.command()
+@click.option("--no-ollama", is_flag=True, help="Skip starting Ollama")
+@click.option("--no-api", is_flag=True, help="Skip starting the HTTP API server")
+@click.pass_context
+def start(ctx: click.Context, no_ollama: bool, no_api: bool) -> None:
+    """Start all agent services (Ollama + HTTP API / web chat)."""
+    import subprocess
+    cfg = ctx.obj["cfg"]
+    _setup_logging(cfg)
+
+    url = _ollama_url(cfg)
+    api_port = int(cfg.get("api_port", 8741))
+    api_host = cfg.get("api_host", "127.0.0.1")
+
+    click.echo()
+    click.echo(click.style("=== Starting GitHub Sync Agent services ===", bold=True))
+    click.echo()
+
+    # ── Ollama ────────────────────────────────────────────────────
+    if not no_ollama:
+        if _ollama_running(url):
+            click.echo(click.style("  ✓", fg="green") + f"  Ollama already running at {url}")
+        else:
+            click.echo("  ↗  Starting Ollama...")
+            started = False
+
+            # Try user systemd service first (no sudo needed)
+            r = subprocess.run(["systemctl", "--user", "start", "ollama"], capture_output=True)
+            if r.returncode == 0:
+                started = True
+
+            # Try system systemd service via sudo (passwordless sudo only)
+            if not started:
+                r2 = subprocess.run(
+                    ["sudo", "-n", "systemctl", "start", "ollama"],
+                    capture_output=True
+                )
+                if r2.returncode == 0:
+                    started = True
+
+            if started:
+                import time
+                for _ in range(15):
+                    time.sleep(1)
+                    if _ollama_running(url):
+                        click.echo(click.style("  ✓", fg="green") + f"  Ollama started at {url}")
+                        break
+                else:
+                    click.echo(click.style("  ✗  Ollama did not respond after 15s.", fg="red"))
+            else:
+                click.echo(click.style("  ✗  Cannot start Ollama automatically.", fg="yellow"))
+                click.echo("     Run:  sudo systemctl start ollama")
+                click.echo("     Then: github-sync start --no-ollama")
+
+    # ── HTTP API ──────────────────────────────────────────────────
+    if not no_api:
+        if _port_pid(api_port):
+            click.echo(click.style("  ✓", fg="green") + f"  API already running at http://{api_host}:{api_port}")
+        else:
+            # Check API deps before trying to start
+            try:
+                import uvicorn  # noqa: F401
+            except ImportError:
+                click.echo(click.style("  ✗  API dependencies not installed.", fg="red"))
+                click.echo("     Run: pip install 'github-sync-agent[api]'")
+                click.echo("     Or:  pipx inject github-sync-agent fastapi uvicorn")
+                click.echo()
+                click.echo("  Run " + click.style("github-sync doctor", bold=True) + " to verify everything is healthy.")
+                click.echo()
+                return
+
+            click.echo("  ↗  Starting HTTP API / web chat...")
+            log_file = cfg.get("log_file", str(Path.home() / ".local/share/github-sync/github-sync.log"))
+            Path(log_file).parent.mkdir(parents=True, exist_ok=True)
+            subprocess.Popen(
+                [sys.argv[0], "serve", "--host", api_host, "--port", str(api_port)],
+                stdout=open(log_file, "a"), stderr=subprocess.STDOUT,
+                start_new_session=True,
+            )
+            import time; time.sleep(3)
+            if _port_pid(api_port):
+                click.echo(click.style("  ✓", fg="green") + f"  API started — http://{api_host}:{api_port}")
+                click.echo(f"     Web chat: http://{api_host}:{api_port}")
+                click.echo(f"     Logs:     {log_file}")
+            else:
+                click.echo(click.style("  ✗  API failed to start. Last log lines:", fg="red"))
+                try:
+                    lines = Path(log_file).read_text().strip().split("\n")
+                    for line in lines[-5:]:
+                        click.echo(f"     {line}")
+                except Exception:
+                    click.echo(f"     (check {log_file})")
+
+    click.echo()
+    click.echo("  Run " + click.style("github-sync doctor", bold=True) + " to verify everything is healthy.")
+    click.echo()
+
+
+@cli.command()
+@click.option("--no-ollama", is_flag=True, help="Skip stopping Ollama")
+@click.option("--no-api", is_flag=True, help="Skip stopping the HTTP API server")
+@click.pass_context
+def stop(ctx: click.Context, no_ollama: bool, no_api: bool) -> None:
+    """Stop all agent services (HTTP API + optionally Ollama)."""
+    import subprocess
+    cfg = ctx.obj["cfg"]
+    api_port = int(cfg.get("api_port", 8741))
+
+    click.echo()
+    click.echo(click.style("=== Stopping GitHub Sync Agent services ===", bold=True))
+    click.echo()
+
+    # ── HTTP API ──────────────────────────────────────────────────
+    if not no_api:
+        pid = _port_pid(api_port)
+        if pid:
+            import signal
+            import os
+            os.kill(pid, signal.SIGTERM)
+            click.echo(click.style("  ✓", fg="green") + f"  API server stopped (pid {pid})")
+        else:
+            click.echo(f"  –  API server not running on port {api_port}")
+
+    # ── Ollama ────────────────────────────────────────────────────
+    if not no_ollama:
+        url = _ollama_url(cfg)
+        if _ollama_running(url):
+            stopped = False
+            # 1. Try user systemd (no sudo)
+            r = subprocess.run(["systemctl", "--user", "stop", "ollama"], capture_output=True)
+            if r.returncode == 0:
+                stopped = True
+                click.echo(click.style("  ✓", fg="green") + "  Ollama stopped (systemctl --user)")
+            # 2. Try system systemd via passwordless sudo
+            if not stopped:
+                r2 = subprocess.run(["sudo", "-n", "systemctl", "stop", "ollama"], capture_output=True)
+                if r2.returncode == 0:
+                    stopped = True
+                    click.echo(click.style("  ✓", fg="green") + "  Ollama stopped (sudo systemctl)")
+            if not stopped:
+                click.echo(click.style("  ✗  Cannot stop Ollama automatically.", fg="yellow"))
+                click.echo("     Run: sudo systemctl stop ollama")
+                import getpass as _gp
+                _u = _gp.getuser()
+                click.echo(f"     For passwordless control: echo '{_u} ALL=(ALL) NOPASSWD: /usr/bin/systemctl start ollama, /usr/bin/systemctl stop ollama' | sudo tee /etc/sudoers.d/ollama")
+        else:
+            click.echo("  –  Ollama not running")
+
+    click.echo()
+
+
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------

github_sync/config.py

@@ -29,6 +29,9 @@ def _apply_defaults(cfg: dict) -> None:
     cfg.setdefault("api_host", "127.0.0.1")
     cfg.setdefault("api_port", 8741)
     cfg.setdefault("api_key", "")
+    cfg.setdefault("ollama_url", "http://localhost:11434")
+    cfg.setdefault("llm_model", "gemma3:4b")
+    cfg.setdefault("llm_timeout", 120)
 
     if not cfg.get("github_user"):
         raise ValueError("Missing required config key: 'github_user'")