ghostcode-canary 0.1.25-canary.0

package/src/ghostcode/agents/explore.py

@@ -0,0 +1,50 @@
+SYSTEM_PROMPT = """You are a file search specialist and software architect for GhostCode. You excel at thoroughly navigating and exploring codebases to find information and design implementation plans.
+
+=== CRITICAL: READ-ONLY MODE ===
+This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
+
+Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools — attempting to edit files will fail.
+
+Your strengths:
+- Rapidly finding files using glob patterns
+- Searching code with powerful regex patterns
+- Reading and analyzing file contents
+
+# Process
+
+1. Understand requirements. Read any context or files provided.
+
+2. Explore thoroughly — make efficient parallel tool calls:
+   - Use grep_search and list_files for targeted searches
+   - Use read_file when you know the specific file path
+   - Use run_command ONLY for read-only operations: Get-ChildItem, git status, git log, git diff, Get-Content
+   - NEVER use run_command for: New-Item, Remove-Item, Copy-Item, Move-Item, git add, git commit, npm install, pip install
+   - Before asking a clarifying question, spend time investigating first
+
+3. Design the solution:
+   - Consider trade-offs and architectural decisions
+   - Follow existing patterns where appropriate
+   - Identify dependencies and sequencing
+   - Be efficient — make parallel tool calls where possible
+
+4. Detail the plan:
+   - Provide step-by-step implementation strategy
+   - Identify 3-5 critical files most important for implementing
+   - Note build commands, test setup, and verification steps
+
+# Communication
+
+Lead with the outcome. First sentence should answer "what did you find" or "what's the plan." Supporting detail comes after. Write so the reader can pick up cold: complete sentences, no unexplained jargon. When referencing code, include file_path:line_number.
+
+Match the response to the ask: a quick search gets a direct answer, not sections. A full plan gets the structure it needs.
+
+NOTE: You are meant to be a fast agent that returns output as quickly as possible. Make efficient use of tools and spawn multiple parallel tool calls for searching and reading files.
+
+Complete the user's search request efficiently and report your findings clearly."""

package/src/ghostcode/ai/anthropic_client.py

@@ -0,0 +1,8 @@
+from ghostcode.ai.base import BaseAIClient
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class AnthropicClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "anthropic"

package/src/ghostcode/ai/base.py

@@ -0,0 +1,33 @@
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+
+
+class BaseAIClient(ABC):
+    @property
+    def supports_tools(self) -> bool:
+        return False
+
+    @abstractmethod
+    async def generate(
+        self, messages: list[dict], stream: bool = True
+    ) -> AsyncGenerator[str, None]:
+        ...
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list | None = None,
+        permission_callback=None,
+    ) -> AsyncGenerator[str, None]:
+        yield "[dim]tool-calling not supported by this provider[/dim]"
+        return
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        ...

package/src/ghostcode/ai/factory.py

@@ -0,0 +1,38 @@
+from ghostcode.ai.anthropic_client import AnthropicClient
+from ghostcode.ai.base import BaseAIClient
+from ghostcode.ai.groq_client import GroqClient
+from ghostcode.ai.nvidia_client import NvidiaClient
+from ghostcode.ai.ollama_client import OllamaClient
+from ghostcode.ai.opencode_go_client import OpenCodeGoClient
+from ghostcode.ai.opencode_zen_client import OpenCodeZenClient
+from ghostcode.ai.openai_client import OpenAIClient
+from ghostcode.ai.openrouter_client import OpenRouterClient
+from ghostcode.ai.registry import PROVIDERS
+from ghostcode.utils.config_loader import get_api_key
+
+
+def create_client(provider: str | None = None, model: str | None = None) -> BaseAIClient:
+    provider = (provider or "nvidia").lower()
+    info = PROVIDERS.get(provider)
+    if not info:
+        raise ValueError(f"Unknown provider: {provider}")
+
+    model = model or info["default_model"]
+    api_key = get_api_key(provider)
+    base_url = info["base_url"]
+
+    cls_map = {
+        "nvidia": NvidiaClient,
+        "openai": OpenAIClient,
+        "groq": GroqClient,
+        "anthropic": AnthropicClient,
+        "ollama": OllamaClient,
+        "openrouter": OpenRouterClient,
+        "opencode-zen": OpenCodeZenClient,
+        "opencode-go": OpenCodeGoClient,
+    }
+    client_cls = cls_map.get(provider)
+    if not client_cls:
+        raise ValueError(f"Provider not implemented: {provider}")
+
+    return client_cls(api_key=api_key, model=model, base_url=base_url)

package/src/ghostcode/ai/groq_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class GroqClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "groq"

package/src/ghostcode/ai/nvidia_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class NvidiaClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "nvidia"

package/src/ghostcode/ai/ollama_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class OllamaClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "ollama"

package/src/ghostcode/ai/openai_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class OpenAIClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "openai"

package/src/ghostcode/ai/openai_compat.py

@@ -0,0 +1,139 @@
+import json
+from collections.abc import AsyncGenerator
+
+import httpx
+
+from ghostcode.ai.base import BaseAIClient
+from ghostcode.tools.executor import execute_tool, needs_permission
+
+
+def _first_choice(data: dict) -> dict:
+    choices = data.get("choices")
+    if choices and len(choices) > 0:
+        return choices[0]
+    return {}
+
+
+class OpenAICompatClient(BaseAIClient):
+    def __init__(self, api_key: str, model: str, base_url: str):
+        self._api_key = api_key
+        self._model = model
+        self._base_url = base_url.rstrip("/")
+
+    @property
+    def model_name(self) -> str:
+        return self._model
+
+    @property
+    def supports_tools(self) -> bool:
+        return True
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self._api_key:
+            h["Authorization"] = f"Bearer {self._api_key}"
+        return h
+
+    async def _post(self, url: str, payload: dict) -> dict:
+        async with httpx.AsyncClient(timeout=httpx.Timeout(120.0)) as client:
+            resp = await client.post(url, json=payload, headers=self._headers())
+            resp.raise_for_status()
+            return resp.json()
+
+    async def generate(self, messages: list[dict], stream: bool = True) -> AsyncGenerator[str, None]:
+        url = f"{self._base_url}/chat/completions"
+        payload = {
+            "model": self._model,
+            "messages": messages,
+            "stream": stream,
+            "max_tokens": 4096,
+            "temperature": 0.3,
+        }
+
+        async with httpx.AsyncClient(timeout=httpx.Timeout(120.0)) as client:
+            if stream:
+                async with client.stream("POST", url, json=payload, headers=self._headers()) as resp:
+                    resp.raise_for_status()
+                    async for line in resp.aiter_lines():
+                        if not line or line.startswith(":"):
+                            continue
+                        if line.startswith("data: "):
+                            data = line[6:]
+                            if data.strip() == "[DONE]":
+                                break
+                            try:
+                                chunk = json.loads(data)
+                                choice = _first_choice(chunk)
+                                delta = choice.get("delta", {})
+                                content = delta.get("content", "")
+                                if content:
+                                    yield content
+                            except json.JSONDecodeError:
+                                continue
+            else:
+                resp = await client.post(url, json=payload, headers=self._headers())
+                resp.raise_for_status()
+                data = resp.json()
+                choice = _first_choice(data)
+                content = choice.get("message", {}).get("content", "")
+                if content:
+                    yield content
+
+    async def chat(
+        self,
+        messages: list[dict],
+        tools: list | None = None,
+        permission_callback=None,
+    ) -> AsyncGenerator[str, None]:
+        msgs = list(messages)
+        url = f"{self._base_url}/chat/completions"
+        base_payload = {
+            "model": self._model,
+            "max_tokens": 4096,
+            "temperature": 0.3,
+        }
+
+        while tools:
+            payload = {**base_payload, "messages": msgs, "tools": tools, "stream": False}
+            yield "[dim]...thinking[/dim]\n"
+
+            data = await self._post(url, payload)
+            choice = _first_choice(data)
+            msg = choice.get("message", {})
+
+            tool_calls = msg.get("tool_calls")
+            if not tool_calls:
+                break
+
+            msgs.append({"role": "assistant", "content": msg.get("content") or "", "tool_calls": tool_calls})
+
+            for tc in tool_calls:
+                func = tc.get("function", {})
+                tool_name = func.get("name", "")
+                try:
+                    args = json.loads(func.get("arguments", "{}"))
+                except json.JSONDecodeError:
+                    args = {}
+
+                yield f"[dim]→ {tool_name}[/dim]\n"
+
+                if permission_callback and needs_permission(tool_name, args):
+                    allowed = await permission_callback(tool_name, args)
+                    if not allowed:
+                        msgs.append({
+                            "role": "tool",
+                            "tool_call_id": tc["id"],
+                            "content": json.dumps({"error": "Permission denied by user"}),
+                        })
+                        yield f"[dim]  denied[/dim]\n"
+                        continue
+
+                result = await execute_tool(tool_name, args)
+                msgs.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+        async for chunk in self.generate(msgs, stream=True):
+            yield chunk

package/src/ghostcode/ai/opencode_go_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class OpenCodeGoClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "opencode-go"

package/src/ghostcode/ai/opencode_zen_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class OpenCodeZenClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "opencode-zen"

package/src/ghostcode/ai/openrouter_client.py

@@ -0,0 +1,7 @@
+from ghostcode.ai.openai_compat import OpenAICompatClient
+
+
+class OpenRouterClient(OpenAICompatClient):
+    @property
+    def provider_name(self) -> str:
+        return "openrouter"

package/src/ghostcode/ai/registry.py

@@ -0,0 +1,169 @@
+PROVIDERS = {
+    "opencode-zen": {
+        "name": "OpenCode Zen",
+        "description": "Curated pay-as-you-go coding models",
+        "default_model": "deepseek-v4-flash",
+        "base_url": "https://opencode.ai/zen/v1",
+        "env_var": "OPENCODE_API_KEY",
+        "needs_key": True,
+        "models": [
+            "deepseek-v4-pro",
+            "deepseek-v4-flash",
+            "deepseek-v4-flash-free",
+            "kimi-k2.7-code",
+            "kimi-k2.6",
+            "minimax-m3",
+            "minimax-m2.7",
+            "qwen3.7-max",
+            "qwen3.7-plus",
+            "qwen3.6-plus",
+            "grok-4.5",
+            "glm-5.2",
+            "glm-5.1",
+            "big-pickle",
+            "mimo-v2.5-free",
+            "gpt-5.6-sol",
+            "gpt-5.6-terra",
+            "gpt-5.6-luna",
+            "gpt-5.5",
+            "gpt-5.4",
+            "gpt-5.4-mini",
+            "gpt-5.4-nano",
+            "gpt-5.3-codex",
+            "gpt-5.3-codex-spark",
+            "gpt-5.2-codex",
+            "gpt-5.1-codex",
+            "claude-sonnet-4-6",
+            "claude-sonnet-4-5",
+            "claude-haiku-4-5",
+            "gemini-3.6-flash",
+            "gemini-3.5-flash",
+        ],
+    },
+    "opencode-go": {
+        "name": "OpenCode Go",
+        "description": "$10/mo subscription — open coding models",
+        "default_model": "deepseek-v4-flash",
+        "base_url": "https://opencode.ai/zen/go/v1",
+        "env_var": "OPENCODE_API_KEY",
+        "needs_key": True,
+        "models": [
+            "deepseek-v4-pro",
+            "deepseek-v4-flash",
+            "kimi-k2.7-code",
+            "kimi-k2.6",
+            "minimax-m3",
+            "minimax-m2.7",
+            "qwen3.7-max",
+            "qwen3.7-plus",
+            "qwen3.6-plus",
+            "grok-4.5",
+            "glm-5.2",
+            "glm-5.1",
+            "mimo-v2.5",
+            "mimo-v2.5-pro",
+        ],
+    },
+    "nvidia": {
+        "name": "NVIDIA",
+        "description": "NVIDIA AI Foundation / NIM",
+        "default_model": "meta/llama-3.1-70b-instruct",
+        "base_url": "https://integrate.api.nvidia.com/v1",
+        "env_var": "NVIDIA_API_KEY",
+        "needs_key": True,
+        "models": [
+            "meta/llama-3.1-70b-instruct",
+            "meta/llama-3.1-8b-instruct",
+            "mistralai/mistral-7b-instruct-v0.3",
+            "mistralai/mistral-large",
+            "google/gemma-2-27b-it",
+            "google/gemma-2-9b-it",
+            "nvidia/llama-3.1-nemotron-70b-instruct",
+        ],
+    },
+    "openai": {
+        "name": "OpenAI",
+        "description": "OpenAI GPT-4 / GPT-4o",
+        "default_model": "gpt-4o",
+        "base_url": "https://api.openai.com/v1",
+        "env_var": "OPENAI_API_KEY",
+        "needs_key": True,
+        "models": [
+            "gpt-4o",
+            "gpt-4o-mini",
+            "gpt-4-turbo",
+            "gpt-4",
+            "gpt-3.5-turbo",
+            "o1-mini",
+            "o1-preview",
+        ],
+    },
+    "groq": {
+        "name": "Groq",
+        "description": "Groq LPU inference — fast LLMs",
+        "default_model": "llama-3.3-70b-versatile",
+        "base_url": "https://api.groq.com/openai/v1",
+        "env_var": "GROQ_API_KEY",
+        "needs_key": True,
+        "models": [
+            "llama-3.3-70b-versatile",
+            "llama-3.3-70b-specdec",
+            "llama-3.1-8b-instant",
+            "mixtral-8x7b-32768",
+            "gemma2-9b-it",
+            "llama-guard-3-8b",
+            "openai/gpt-oss-120b",
+            "openai/gpt-oss-20b",
+        ],
+    },
+    "anthropic": {
+        "name": "Anthropic",
+        "description": "Anthropic Claude 3.5 Sonnet",
+        "default_model": "claude-3-5-sonnet-20241022",
+        "base_url": "https://api.anthropic.com/v1",
+        "env_var": "ANTHROPIC_API_KEY",
+        "needs_key": True,
+        "models": [
+            "claude-3-5-sonnet-20241022",
+            "claude-3-5-haiku-20241022",
+            "claude-3-opus-20240229",
+        ],
+        "status": "coming_soon",
+    },
+    "ollama": {
+        "name": "Ollama",
+        "description": "Local models via Ollama",
+        "default_model": "llama3.1",
+        "base_url": "http://localhost:11434",
+        "env_var": "",
+        "needs_key": False,
+        "models": ["llama3.1", "llama3", "mistral", "codellama", "gemma2"],
+        "status": "coming_soon",
+    },
+    "openrouter": {
+        "name": "OpenRouter",
+        "description": "Unified API — many models",
+        "default_model": "meta-llama/llama-3.1-70b-instruct",
+        "base_url": "https://openrouter.ai/api/v1",
+        "env_var": "OPENROUTER_API_KEY",
+        "needs_key": True,
+        "models": [
+            "meta-llama/llama-3.1-70b-instruct",
+            "meta-llama/llama-3.1-8b-instruct",
+            "mistralai/mixtral-8x22b-instruct",
+            "qwen/qwen-2.5-72b-instruct",
+        ],
+        "status": "coming_soon",
+    },
+}
+
+
+def provider_status(pid: str, has_key: bool) -> str:
+    info = PROVIDERS[pid]
+    if info.get("status") == "coming_soon":
+        return "coming soon"
+    if info["needs_key"] and not has_key:
+        return "needs key"
+    if info["needs_key"] and has_key:
+        return "connected"
+    return "ready"

package/src/ghostcode/app.py

@@ -0,0 +1,148 @@
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+
+from ghostcode._version import get_version
+from ghostcode.tui.app import GhostCodeApp
+from ghostcode.utils.config_loader import find_and_load_env, migrate_env_keys_to_config
+from ghostcode.utils.logger import setup_logger
+
+
+def cmd_update():
+    import httpx
+    import re
+    current = get_version()
+    print(f"GhostCode v{current}")
+    print("Checking for updates...")
+    try:
+        r = httpx.get("https://registry.npmjs.org/ghostcode-canary/latest", timeout=5)
+        if r.status_code != 200:
+            print("Failed to check for updates.")
+            sys.exit(1)
+        latest = r.json().get("version", "")
+        if not latest:
+            print("No version info from registry.")
+            sys.exit(1)
+
+        from ghostcode.tui.screens import ChatScreen
+        if not ChatScreen._is_newer(latest, current):
+            print(f"Already up to date (v{current}).")
+            return
+
+        print(f"Update available: v{current} -> v{latest}")
+        print()
+        print(f"  Downloading v{latest}...")
+
+        proc = subprocess.Popen(
+            ["npm", "i", "-g", "ghostcode-canary"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+
+        step_re = re.compile(r"\[(\d+)/(\d+)\]")
+        last_msg = ""
+        while True:
+            line = proc.stdout.readline()
+            if not line and proc.poll() is not None:
+                break
+            if not line:
+                continue
+            line = line.strip()
+            if not line:
+                continue
+
+            m = step_re.search(line)
+            if m:
+                done, total = int(m.group(1)), int(m.group(2))
+                pct = int(done / total * 100) if total > 0 else 0
+                bar_len = 20
+                filled = int(bar_len * done / total) if total > 0 else 0
+                bar = "█" * filled + "░" * (bar_len - filled)
+                msg = f"  [{bar}] {pct}%  ({done}/{total} steps)"
+                if msg != last_msg:
+                    print(f"\r{msg}", end="", flush=True)
+                    last_msg = msg
+            elif "added" in line.lower() or "updated" in line.lower():
+                print(f"\r  {line}")
+            elif "err" in line.lower() or "error" in line.lower():
+                print(f"\r  {line}")
+
+        proc.wait()
+        print()
+
+        if proc.returncode == 0:
+            print(f"  Updated to v{latest}. Run 'ghostcode' to start.")
+        else:
+            print("  Update failed.")
+            sys.exit(1)
+    except FileNotFoundError:
+        print("npm not found. Install Node.js first.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Update failed: {e}")
+        sys.exit(1)
+
+
+def cmd_uninstall(clean: bool):
+    print("GhostCode uninstall...")
+    config_dir = os.path.expanduser("~/.ghostcode")
+
+    if clean:
+        if os.path.exists(config_dir):
+            print(f"Removing config: {config_dir}")
+            shutil.rmtree(config_dir, ignore_errors=True)
+            print("Config removed.")
+        else:
+            print("No config found, skipping.")
+    else:
+        print("Config kept. Use --clean to also remove config and API keys.")
+
+    try:
+        print("Uninstalling npm package...")
+        result = subprocess.run(
+            ["npm", "uninstall", "-g", "ghostcode-canary"],
+            capture_output=True, text=True,
+        )
+        if result.returncode == 0:
+            print("GhostCode uninstalled.")
+        else:
+            print("Failed to uninstall npm package:")
+            print(result.stderr)
+            sys.exit(1)
+    except FileNotFoundError:
+        print("npm not found. Install Node.js first.")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--version", action="store_true", help="show version")
+    args, rest = parser.parse_known_args()
+
+    if args.version:
+        print(f"GhostCode v{get_version()}")
+        return
+
+    if rest and rest[0] == "update":
+        cmd_update()
+        return
+
+    if rest and rest[0] == "uninstall":
+        clean = "--clean" in rest
+        cmd_uninstall(clean)
+        return
+
+    find_and_load_env()
+    migrate_env_keys_to_config()
+
+    setup_logger("ghostcode", os.getenv("GHOSTCODE_LOG_LEVEL", "WARNING"))
+
+    app = GhostCodeApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

package/src/ghostcode/config.py

@@ -0,0 +1,24 @@
+from ghostcode.ai.registry import PROVIDERS
+from ghostcode.utils.config_loader import get_api_key, get_default_provider
+
+
+class Settings:
+    @property
+    def providers(self):
+        return PROVIDERS
+
+    @property
+    def default_provider(self) -> str:
+        return get_default_provider()
+
+    @property
+    def api_key(self) -> str:
+        return get_api_key(self.default_provider)
+
+    @property
+    def log_level(self) -> str:
+        import os
+        return os.getenv("GHOSTCODE_LOG_LEVEL", "WARNING")
+
+
+settings = Settings()

package/src/ghostcode/core/__init__.py

@@ -0,0 +1,5 @@
+from ghostcode.core.memory import save_memory, search_memory, delete_memory, list_memories, memory_summary, count_memories
+from ghostcode.core.security import is_action_denied, needs_confirmation, scan_for_secrets, redact_secrets, add_deny_rule, remove_deny_rule, list_deny_rules
+from ghostcode.core.hooks import hook_registry
+from ghostcode.core.tasks import task_manager, TaskStatus
+from ghostcode.core.commands import Command, register, dispatch, get_command, list_commands