kivi-cli 2.0.6__py3-none-any.whl

kiviai/services/git_service.py

@@ -0,0 +1,219 @@
+"""
+Git service — enhanced git operations for the UI.
+
+Supports:
+- Branch management (create, switch, list, delete)
+- Status and diff
+- Commit with message
+- Repo detection
+- Log viewing
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+from typing import Any
+
+log = logging.getLogger("cc-ui.git")
+
+
+class GitService:
+    @staticmethod
+    async def _run(cmd: list[str], cwd: str) -> tuple[int, str, str]:
+        """Run a git command and return (returncode, stdout, stderr)."""
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd,
+        )
+        stdout, stderr = await proc.communicate()
+        return proc.returncode, stdout.decode().strip(), stderr.decode().strip()
+
+    @staticmethod
+    async def is_repo(cwd: str) -> bool:
+        rc, _, _ = await GitService._run(
+            ["git", "rev-parse", "--is-inside-work-tree"], cwd
+        )
+        return rc == 0
+
+    @staticmethod
+    async def get_status(cwd: str) -> dict:
+        """Get comprehensive git status."""
+        if not await GitService.is_repo(cwd):
+            return {"is_git": False}
+
+        rc, status, _ = await GitService._run(["git", "status", "--short"], cwd)
+        rc, branch, _ = await GitService._run(["git", "branch", "--show-current"], cwd)
+        rc, diff, _ = await GitService._run(["git", "diff", "HEAD"], cwd)
+        rc, remote, _ = await GitService._run(["git", "remote", "-v"], cwd)
+
+        return {
+            "is_git": True,
+            "branch": branch,
+            "status": status,
+            "diff": diff,
+            "remote": remote.split("\n")[0] if remote else "",
+            "has_changes": bool(status.strip()),
+        }
+
+    @staticmethod
+    async def list_branches(cwd: str) -> list[dict]:
+        """List all branches with current marker."""
+        if not await GitService.is_repo(cwd):
+            return []
+
+        rc, output, _ = await GitService._run(["git", "branch", "-a", "--format=%(refname:short)|%(objectname:short)|%(HEAD)"], cwd)
+        branches = []
+        for line in output.splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("|")
+            if len(parts) >= 3:
+                branches.append({
+                    "name": parts[0].strip(),
+                    "sha": parts[1].strip(),
+                    "current": parts[2].strip() == "*",
+                })
+        return branches
+
+    @staticmethod
+    async def create_branch(cwd: str, name: str, checkout: bool = True) -> dict:
+        """Create a new branch, optionally check it out."""
+        if not await GitService.is_repo(cwd):
+            return {"error": "Not a git repository"}
+
+        if checkout:
+            rc, out, err = await GitService._run(["git", "checkout", "-b", name], cwd)
+        else:
+            rc, out, err = await GitService._run(["git", "branch", name], cwd)
+
+        return {"success": rc == 0, "output": out or err, "branch": name}
+
+    @staticmethod
+    async def switch_branch(cwd: str, name: str) -> dict:
+        """Switch to an existing branch."""
+        rc, out, err = await GitService._run(["git", "checkout", name], cwd)
+        return {"success": rc == 0, "output": out or err, "branch": name}
+
+    @staticmethod
+    async def commit(cwd: str, message: str, add_all: bool = True) -> dict:
+        """Commit changes."""
+        if add_all:
+            await GitService._run(["git", "add", "-A"], cwd)
+        rc, out, err = await GitService._run(["git", "commit", "-m", message], cwd)
+        return {"success": rc == 0, "output": out or err}
+
+    @staticmethod
+    async def get_log(cwd: str, n: int = 20) -> list[dict]:
+        """Get recent commit log."""
+        if not await GitService.is_repo(cwd):
+            return []
+
+        rc, output, _ = await GitService._run(
+            ["git", "log", f"-{n}", "--format=%H|%h|%s|%an|%ai"], cwd
+        )
+        commits = []
+        for line in output.splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("|", 4)
+            if len(parts) >= 5:
+                commits.append({
+                    "sha": parts[0], "short_sha": parts[1],
+                    "message": parts[2], "author": parts[3],
+                    "date": parts[4],
+                })
+        return commits
+
+    @staticmethod
+    async def get_diff(cwd: str) -> dict:
+        """Get status + diff (for the git panel)."""
+        if not await GitService.is_repo(cwd):
+            return {"is_git": False, "status": "", "diff": ""}
+
+        rc, status, _ = await GitService._run(["git", "status", "--short"], cwd)
+        rc, diff, _ = await GitService._run(["git", "diff", "HEAD"], cwd)
+        return {"is_git": True, "status": status, "diff": diff}
+
+    @staticmethod
+    async def stash(cwd: str, message: str = "") -> dict:
+        cmd = ["git", "stash"]
+        if message:
+            cmd += ["-m", message]
+        rc, out, err = await GitService._run(cmd, cwd)
+        return {"success": rc == 0, "output": out or err}
+
+    @staticmethod
+    async def stash_pop(cwd: str) -> dict:
+        rc, out, err = await GitService._run(["git", "stash", "pop"], cwd)
+        return {"success": rc == 0, "output": out or err}
+
+    @staticmethod
+    async def list_prs(cwd: str, limit: int = 20) -> list[dict]:
+        """List open PRs using gh CLI."""
+        rc, out, err = await GitService._run(
+            ["gh", "pr", "list", "--json",
+             "number,title,author,headRefName,baseRefName,state,url,createdAt,isDraft",
+             "--limit", str(limit)],
+            cwd,
+        )
+        if rc != 0:
+            return []
+        import json
+        try:
+            return json.loads(out)
+        except Exception:
+            return []
+
+    @staticmethod
+    async def create_pr(cwd: str, title: str, body: str = "", base: str = "main", head: str = "") -> dict:
+        """Create a PR using gh CLI."""
+        cmd = ["gh", "pr", "create", "--title", title, "--body", body, "--base", base]
+        if head:
+            cmd.extend(["--head", head])
+        rc, out, err = await GitService._run(cmd, cwd)
+        return {"success": rc == 0, "output": out or err}
+
+    @staticmethod
+    async def merge_pr(cwd: str, pr_number: int, method: str = "merge") -> dict:
+        """Merge a PR using gh CLI."""
+        rc, out, err = await GitService._run(
+            ["gh", "pr", "merge", str(pr_number), f"--{method}"], cwd
+        )
+        return {"success": rc == 0, "output": out or err}
+
+    @staticmethod
+    async def pr_diff(cwd: str, pr_number: int) -> str:
+        """Get diff for a PR using gh CLI."""
+        rc, out, err = await GitService._run(
+            ["gh", "pr", "diff", str(pr_number)], cwd
+        )
+        return out if rc == 0 else err
+
+    @staticmethod
+    async def get_all_diffs(cwd: str) -> dict:
+        """Get staged, unstaged, and untracked diffs."""
+        _, staged, _ = await GitService._run(["git", "diff", "--cached"], cwd)
+        _, unstaged, _ = await GitService._run(["git", "diff"], cwd)
+        _, untracked_files, _ = await GitService._run(
+            ["git", "ls-files", "--others", "--exclude-standard"], cwd
+        )
+        untracked_diff = ""
+        for f in untracked_files.splitlines():
+            if f:
+                try:
+                    fpath = os.path.join(cwd, f)
+                    if os.path.isfile(fpath) and os.path.getsize(fpath) < 50000:
+                        with open(fpath, 'r', errors='replace') as fh:
+                            content = fh.read()
+                        untracked_diff += f"\n--- /dev/null\n+++ b/{f}\n" + "\n".join("+" + line for line in content.splitlines()) + "\n"
+                except Exception:
+                    pass
+        return {
+            "staged": staged,
+            "unstaged": unstaged,
+            "untracked": untracked_diff,
+            "total": staged + "\n" + unstaged + "\n" + untracked_diff,
+        }

kiviai/services/monitor.py

@@ -0,0 +1,97 @@
+"""
+Monitor service — health checks, system metrics, provider status.
+
+Tracks:
+- Provider availability (which AI backends are online)
+- System resources (CPU, memory, disk)
+- Task statistics (running, completed, error rates)
+- Uptime and response times
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+from datetime import datetime
+from typing import Any
+
+log = logging.getLogger("cc-ui.monitor")
+
+
+class Monitor:
+    def __init__(self):
+        self._start_time = time.time()
+        self._task_stats = {
+            "total": 0, "running": 0, "done": 0,
+            "error": 0, "stopped": 0,
+        }
+        self._provider_status: dict[str, dict] = {}
+        self._last_health_check: str = ""
+
+    def update_task_stats(self, tasks: dict):
+        """Recalculate task statistics from task dict."""
+        stats = {"total": 0, "running": 0, "done": 0, "error": 0, "stopped": 0}
+        for t in tasks.values():
+            stats["total"] += 1
+            status = t.get("status", "unknown")
+            if status in stats:
+                stats[status] += 1
+        self._task_stats = stats
+
+    async def check_providers(self) -> dict:
+        """Run health checks on all registered providers."""
+        try:
+            from kiviai.services.providers.registry import health_check_all
+            self._provider_status = await health_check_all()
+        except Exception as e:
+            self._provider_status = {"error": str(e)}
+        self._last_health_check = datetime.now().isoformat()
+        return self._provider_status
+
+    def get_system_info(self) -> dict:
+        """Get system resource info."""
+        info = {
+            "uptime_seconds": round(time.time() - self._start_time),
+            "pid": os.getpid(),
+            "python_version": os.sys.version.split()[0],
+        }
+
+        try:
+            import psutil
+            info["cpu_percent"] = psutil.cpu_percent(interval=0.1)
+            mem = psutil.virtual_memory()
+            info["memory_used_gb"] = round(mem.used / (1024**3), 2)
+            info["memory_total_gb"] = round(mem.total / (1024**3), 2)
+            info["memory_percent"] = mem.percent
+            disk = psutil.disk_usage("/")
+            info["disk_used_gb"] = round(disk.used / (1024**3), 2)
+            info["disk_total_gb"] = round(disk.total / (1024**3), 2)
+        except ImportError:
+            pass
+
+        return info
+
+    def get_dashboard(self) -> dict:
+        """Full monitoring dashboard data."""
+        return {
+            "timestamp": datetime.now().isoformat(),
+            "uptime_seconds": round(time.time() - self._start_time),
+            "tasks": self._task_stats,
+            "providers": self._provider_status,
+            "last_health_check": self._last_health_check,
+            "system": self.get_system_info(),
+        }
+
+    def get_metrics(self) -> dict:
+        """Prometheus-style metrics."""
+        m = {
+            "ccui_uptime_seconds": round(time.time() - self._start_time),
+            "ccui_tasks_total": self._task_stats["total"],
+            "ccui_tasks_running": self._task_stats["running"],
+            "ccui_tasks_done": self._task_stats["done"],
+            "ccui_tasks_error": self._task_stats["error"],
+        }
+        for name, status in self._provider_status.items():
+            m[f"ccui_provider_{name}_up"] = 1 if status.get("status") == "ok" else 0
+        return m

kiviai/services/providers/base.py

@@ -0,0 +1,131 @@
+"""
+Base provider protocol for all AI integrations.
+
+Every provider implements this interface so the system can swap
+between Claude, Copilot, VLLM, etc. with zero friction.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, AsyncIterator, Optional
+
+
+class EventType(str, Enum):
+    TEXT = "text"
+    TOOL_START = "tool_start"
+    TOOL_RESULT = "tool_result"
+    THINKING = "thinking"
+    AGENT_GROUP = "agent_group"
+    ERROR = "error"
+    DONE = "done"
+    COST = "cost"
+
+
+@dataclass
+class ProviderEvent:
+    """Unified event emitted by all providers."""
+    type: EventType
+    content: str = ""
+    metadata: dict = field(default_factory=dict)
+
+    def to_history_entry(self) -> dict | None:
+        """Convert to a history message dict for storage."""
+        if self.type == EventType.TEXT:
+            return {"role": "assistant", "content": self.content}
+        elif self.type == EventType.TOOL_START:
+            title = self.metadata.get("title", "⚙ tool")
+            args = self.metadata.get("args", "")
+            return {
+                "role": "assistant",
+                "content": f"```json\n{args}\n```" if args else "",
+                "metadata": {"title": title, "status": "pending"},
+            }
+        elif self.type == EventType.TOOL_RESULT:
+            title = self.metadata.get("title", "✓ result")
+            is_error = self.metadata.get("is_error", False)
+            icon = "❌" if is_error else "✓"
+            preview = self.content[:600] + ("…" if len(self.content) > 600 else "")
+            return {
+                "role": "assistant",
+                "content": f"```\n{preview}\n```",
+                "metadata": {"title": f"{icon} result", "status": "done"},
+            }
+        elif self.type == EventType.THINKING:
+            return {
+                "role": "assistant",
+                "content": self.content[:500],
+                "metadata": {"title": "💭 Thinking", "status": "done"},
+            }
+        elif self.type == EventType.ERROR:
+            return {"role": "assistant", "content": f"❌ {self.content}"}
+        elif self.type == EventType.AGENT_GROUP:
+            return {
+                "role": "agent-group",
+                "agent_id": self.metadata.get("agent_id", ""),
+                "agent_label": self.metadata.get("agent_label", "Agent"),
+                "model": self.metadata.get("model", ""),
+                "status": self.metadata.get("status", "running"),
+                "children": self.metadata.get("children", []),
+            }
+        return None
+
+
+@dataclass
+class ProviderConfig:
+    """Configuration for a provider instance."""
+    model: str = ""
+    mode: str = "default"
+    cwd: str = ""
+    session_id: str | None = None
+    api_key: str = ""
+    base_url: str = ""
+    extra: dict = field(default_factory=dict)
+
+
+class BaseProvider(ABC):
+    """Abstract base for all AI provider adapters."""
+
+    name: str = "base"
+    display_name: str = "Base Provider"
+    description: str = ""
+    supports_streaming: bool = True
+    supports_tools: bool = False
+    supports_sessions: bool = False
+    supports_agents: bool = False
+    available_models: list[str] = []
+
+    @abstractmethod
+    async def run(
+        self,
+        prompt: str,
+        config: ProviderConfig,
+        history: list[dict] | None = None,
+    ) -> AsyncIterator[ProviderEvent]:
+        """Execute a prompt and yield events."""
+        ...
+
+    async def stop(self) -> None:
+        """Signal the provider to stop current execution."""
+        pass
+
+    async def health_check(self) -> dict:
+        """Check if the provider is available and responsive."""
+        return {"status": "unknown", "provider": self.name}
+
+    def get_capabilities(self) -> dict:
+        """Return provider capabilities for the UI."""
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "streaming": self.supports_streaming,
+            "tools": self.supports_tools,
+            "sessions": self.supports_sessions,
+            "agents": self.supports_agents,
+            "models": self.available_models,
+        }

kiviai/services/providers/claude.py

@@ -0,0 +1,125 @@
+"""Claude Code provider — uses claude_agent_sdk for streaming."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from typing import AsyncIterator
+
+from .base import BaseProvider, ProviderConfig, ProviderEvent, EventType
+
+
+class ClaudeProvider(BaseProvider):
+    name = "claude"
+    display_name = "Claude Code"
+    description = "Anthropic's agentic coding assistant. Reads/writes files, runs shell commands, manages git, and reasons through complex multi-step tasks. Supports session resumption and sub-agent orchestration."
+    supports_streaming = True
+    supports_tools = True
+    supports_sessions = True
+    supports_agents = True
+    available_models = [
+        "sonnet", "opus", "haiku", "fable",
+    ]
+
+    def __init__(self):
+        self._stop = False
+
+    async def run(self, prompt: str, config: ProviderConfig, history=None) -> AsyncIterator[ProviderEvent]:
+        from claude_agent_sdk import (
+            query, ClaudeAgentOptions,
+            AssistantMessage, ResultMessage, SystemMessage,
+            TextBlock, ToolUseBlock, ToolResultBlock, ThinkingBlock,
+        )
+
+        self._stop = False
+        opts = ClaudeAgentOptions(
+            permission_mode=config.mode or "bypassPermissions",
+            resume=config.session_id,
+            cwd=config.cwd or None,
+            env={**os.environ, **config.extra.get("env", {})},
+            model=config.model or None,
+        )
+
+        # Extended CLI flags via extra dict
+        if config.extra.get("system_prompt"):
+            opts.system_prompt = config.extra["system_prompt"]
+        if config.extra.get("append_system_prompt"):
+            opts.append_system_prompt = config.extra["append_system_prompt"]
+        if config.extra.get("effort"):
+            opts.effort = config.extra["effort"]
+        if config.extra.get("max_budget_usd"):
+            opts.max_budget_usd = float(config.extra["max_budget_usd"])
+        if config.extra.get("allowed_tools"):
+            opts.allowed_tools = config.extra["allowed_tools"]
+        if config.extra.get("disallowed_tools"):
+            opts.disallowed_tools = config.extra["disallowed_tools"]
+        if config.extra.get("mcp_config"):
+            opts.mcp_config = config.extra["mcp_config"]
+
+        # File attachments: prepend to prompt
+        files = config.extra.get("files", [])
+        if files:
+            file_context = "\n".join(f"[Attached file: {f}]" for f in files)
+            prompt = file_context + "\n\n" + prompt
+
+        text_buf = ""
+        try:
+            async for msg in query(prompt=prompt, options=opts):
+                if self._stop:
+                    yield ProviderEvent(type=EventType.TEXT, content="⏹ *stopped*")
+                    yield ProviderEvent(type=EventType.DONE)
+                    return
+
+                if isinstance(msg, AssistantMessage):
+                    if msg.error:
+                        yield ProviderEvent(type=EventType.ERROR, content=str(msg.error))
+                        return
+                    for block in msg.content:
+                        if isinstance(block, TextBlock):
+                            text_buf += block.text
+                            yield ProviderEvent(type=EventType.TEXT, content=block.text)
+                        elif isinstance(block, ThinkingBlock):
+                            yield ProviderEvent(type=EventType.THINKING, content=block.thinking[:500])
+                        elif isinstance(block, ToolUseBlock):
+                            args = json.dumps(block.input, indent=2) if block.input else ""
+                            yield ProviderEvent(
+                                type=EventType.TOOL_START,
+                                metadata={"title": f"⚙ {block.name}", "args": args},
+                            )
+                        elif isinstance(block, ToolResultBlock):
+                            content = block.content or ""
+                            if isinstance(content, list):
+                                content = "\n".join(c.get("text", str(c)) for c in content)
+                            yield ProviderEvent(
+                                type=EventType.TOOL_RESULT,
+                                content=str(content),
+                                metadata={"is_error": block.is_error},
+                            )
+
+                elif isinstance(msg, ResultMessage):
+                    yield ProviderEvent(
+                        type=EventType.COST,
+                        metadata={
+                            "session_id": msg.session_id,
+                            "total_cost_usd": msg.total_cost_usd or 0,
+                            "usage": msg.usage or {},
+                        },
+                    )
+
+        except Exception as e:
+            yield ProviderEvent(type=EventType.ERROR, content=str(e))
+            return
+
+        yield ProviderEvent(type=EventType.DONE)
+
+    async def stop(self):
+        self._stop = True
+
+    async def health_check(self):
+        import shutil
+        has_claude = shutil.which("claude") is not None
+        return {
+            "status": "ok" if has_claude else "unavailable",
+            "provider": self.name,
+            "binary": "claude" if has_claude else None,
+        }