ghostcode-canary 0.1.25-canary.0

package/src/ghostcode/tools/executor.py

@@ -0,0 +1,261 @@
+import asyncio
+import json
+import os
+import subprocess
+from pathlib import Path
+
+from ghostcode.core.hooks import hook_registry
+from ghostcode.core.memory import save_memory, search_memory, delete_memory, list_memories
+from ghostcode.core.security import is_action_denied, needs_confirmation, scan_for_secrets
+from ghostcode.core.tasks import task_manager, TaskStatus
+
+
+def needs_permission(tool_name: str, args: dict) -> bool:
+    if tool_name == "run_command":
+        return True
+    denied, _ = is_action_denied(tool_name, args)
+    if denied:
+        return True
+    needs, _ = needs_confirmation(tool_name, args)
+    if needs:
+        return True
+    path_str = args.get("file_path") or args.get("path") or ""
+    if not path_str:
+        return False
+    cwd = os.getcwd()
+    abs_path = os.path.abspath(path_str) if not os.path.isabs(path_str) else os.path.abspath(path_str)
+    return not abs_path.startswith(Path(cwd).resolve().as_posix())
+
+
+async def execute_tool(tool_name: str, args: dict) -> str:
+    allowed, reason = hook_registry.run_before(tool_name, args)
+    if not allowed:
+        return json.dumps({"error": f"Hook blocked: {reason}"})
+
+    if tool_name == "read_file":
+        result = _exec_read_file(args)
+    elif tool_name == "write_file":
+        result = _exec_write_file(args)
+    elif tool_name == "edit_file":
+        result = _exec_edit_file(args)
+    elif tool_name == "run_command":
+        result = await _exec_run_command(args)
+    elif tool_name == "list_files":
+        result = _exec_list_files(args)
+    elif tool_name == "grep_search":
+        result = _exec_grep_search(args)
+    elif tool_name == "web_search":
+        result = json.dumps({"error": "web_search not available directly — use the provider's web search"})
+    elif tool_name == "web_fetch":
+        result = await _exec_web_fetch(args)
+    elif tool_name == "todo_write":
+        result = json.dumps({"ok": True, "note": "Todo list updated in conversation context"})
+    elif tool_name == "memory_save":
+        result = _exec_memory_save(args)
+    elif tool_name == "memory_search":
+        result = _exec_memory_search(args)
+    elif tool_name == "memory_delete":
+        result = _exec_memory_delete(args)
+    elif tool_name == "memory_list":
+        result = _exec_memory_list(args)
+    elif tool_name == "task_create":
+        result = _exec_task_create(args)
+    elif tool_name == "task_stop":
+        result = _exec_task_stop(args)
+    elif tool_name == "task_list":
+        result = _exec_task_list(args)
+    else:
+        return json.dumps({"error": f"Unknown tool: {tool_name}"})
+
+    result = hook_registry.run_after(tool_name, args, result)
+    return result
+
+
+def _exec_read_file(args: dict) -> str:
+    path = args["file_path"]
+    offset = args.get("offset")
+    limit = args.get("limit")
+    try:
+        p = Path(path).expanduser().resolve()
+        if not p.exists():
+            return json.dumps({"error": f"File not found: {path}"})
+        lines = p.read_text(encoding="utf-8").splitlines()
+        total = len(lines)
+        if offset:
+            start = max(0, int(offset) - 1)
+            lines = lines[start:]
+        if limit:
+            lines = lines[:int(limit)]
+        if total > len(lines):
+            content = "\n".join(lines) + f"\n\n[Read {len(lines)} of {total} lines]"
+        else:
+            content = "\n".join(lines)
+        return content
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _exec_write_file(args: dict) -> str:
+    path = args["file_path"]
+    content = args["content"]
+    secrets = scan_for_secrets(content)
+    if secrets:
+        return json.dumps({"error": f"Refusing to write — potential secrets detected: {secrets[0][:20]}..."})
+    try:
+        p = Path(path).expanduser().resolve()
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        size = len(content.encode("utf-8"))
+        return json.dumps({"ok": True, "path": str(p), "bytes": size})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _exec_edit_file(args: dict) -> str:
+    path = args["file_path"]
+    old = args["old_string"]
+    new = args["new_string"]
+    try:
+        p = Path(path).expanduser().resolve()
+        content = p.read_text(encoding="utf-8")
+        if old not in content:
+            return json.dumps({"error": "old_string not found in file"})
+        new_content = content.replace(old, new, 1)
+        p.write_text(new_content, encoding="utf-8")
+        return json.dumps({"ok": True, "path": str(p), "replaced": 1})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+async def _exec_run_command(args: dict) -> str:
+    command = args["command"]
+    workdir = args.get("workdir") or os.getcwd()
+    timeout = args.get("timeout", 120000) / 1000
+    try:
+        proc = await asyncio.create_subprocess_shell(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=workdir,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        out = stdout.decode("utf-8", errors="replace")
+        err = stderr.decode("utf-8", errors="replace")
+        result = {"exit_code": proc.returncode, "stdout": out, "stderr": err}
+        return json.dumps(result)
+    except asyncio.TimeoutError:
+        return json.dumps({"error": "Command timed out"})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _exec_list_files(args: dict) -> str:
+    path = args.get("path") or os.getcwd()
+    pattern = args.get("pattern")
+    try:
+        p = Path(path).expanduser().resolve()
+        if pattern:
+            matches = list(p.rglob(pattern))
+            return json.dumps({"files": [str(m.relative_to(p)) for m in sorted(matches) if m.is_file()]})
+        items = []
+        for entry in sorted(p.iterdir()):
+            name = entry.name + "/" if entry.is_dir() else entry.name
+            items.append(name)
+        return json.dumps({"files": items, "path": str(p)})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _exec_grep_search(args: dict) -> str:
+    pattern = args["pattern"]
+    include = args.get("include")
+    path = args.get("path") or os.getcwd()
+    try:
+        import re
+        p = Path(path).expanduser().resolve()
+        if not p.exists():
+            return json.dumps({"error": f"Path not found: {path}"})
+        if p.is_file():
+            files = [p]
+        elif include:
+            files = []
+            for ext in include.split(","):
+                files.extend(p.rglob(ext.strip()))
+        else:
+            files = [f for f in p.rglob("*") if f.is_file() and not f.name.startswith(".")]
+        results = []
+        for f in files:
+            try:
+                text = f.read_text(encoding="utf-8", errors="replace")
+                for i, line in enumerate(text.splitlines(), 1):
+                    if re.search(pattern, line):
+                        results.append({"file": str(f.relative_to(p) if f.is_relative_to(p) else f), "line": i, "content": line.strip()})
+                        if len(results) >= 200:
+                            break
+            except Exception:
+                continue
+            if len(results) >= 200:
+                break
+        return json.dumps({"matches": results, "total": len(results)})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+async def _exec_web_fetch(args: dict) -> str:
+    url = args["url"]
+    import httpx
+    try:
+        async with httpx.AsyncClient(timeout=30) as client:
+            resp = await client.get(url, follow_redirects=True)
+            resp.raise_for_status()
+            return resp.text[:50000]
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def _exec_memory_save(args: dict) -> str:
+    name = args["name"]
+    content = args["content"]
+    mtype = args.get("type", "reference")
+    desc = args.get("description", "")
+    pinned = args.get("pinned", False)
+    result = save_memory(name, content, {"type": mtype, "description": desc, "pinned": pinned})
+    return json.dumps(result)
+
+
+def _exec_memory_search(args: dict) -> str:
+    query = args["query"]
+    results = search_memory(query)
+    return json.dumps({"matches": results, "total": len(results)})
+
+
+def _exec_memory_delete(args: dict) -> str:
+    name = args["name"]
+    ok = delete_memory(name)
+    return json.dumps({"ok": ok, "note": f"Memory '{name}' {'deleted' if ok else 'not found'}"})
+
+
+def _exec_memory_list(args: dict) -> str:
+    mtype = args.get("type")
+    results = list_memories(mtype)
+    return json.dumps({"memories": results, "total": len(results)})
+
+
+def _exec_task_create(args: dict) -> str:
+    desc = args["description"]
+    prompt = args["prompt"]
+    subagent_type = args.get("subagent_type", "worker")
+    task = task_manager.create(desc, prompt, subagent_type)
+    return json.dumps({"task_id": task.id, "status": "pending", "description": desc})
+
+
+def _exec_task_stop(args: dict) -> str:
+    task_id = args["task_id"]
+    ok = task_manager.stop(task_id)
+    return json.dumps({"ok": ok, "task_id": task_id})
+
+
+def _exec_task_list(args: dict) -> str:
+    status = args.get("status")
+    tasks = task_manager.list_tasks(status)
+    return json.dumps({"tasks": tasks, "total": len(tasks)})

package/src/ghostcode/tui/app.py

@@ -0,0 +1,12 @@
+from textual.app import App
+
+from ghostcode.tui.screens import ChatScreen
+
+
+class GhostCodeApp(App):
+    TITLE = "GhostCode"
+    SUB_TITLE = "AI coding assistant"
+    SCREENS = {"chat": ChatScreen}
+
+    def on_mount(self):
+        self.push_screen("chat")

package/src/ghostcode/tui/dialogs.py

@@ -0,0 +1,241 @@
+import textwrap
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label
+
+
+class ApiKeyDialog(ModalScreen):
+    def __init__(self, provider_id: str, provider_name: str):
+        super().__init__()
+        self._pid = provider_id
+        self._pname = provider_name
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label(f"Enter API key for [bold]{self._pname}[/bold]:", id="dialog-title")
+            yield Input(id="key-input", placeholder="sk-... or nvapi-...", password=True)
+            yield Label("Press [bold]Enter[/bold] to save - [bold]Esc[/bold] to cancel", id="dialog-hint")
+        yield from ()
+
+    CSS = """
+    ApiKeyDialog {
+        align: center middle;
+    }
+
+    #dialog {
+        width: 50;
+        height: auto;
+        padding: 2 3;
+        background: $surface;
+        border: tall $primary;
+    }
+
+    #dialog-title {
+        margin-bottom: 1;
+        text-style: bold;
+    }
+
+    #key-input {
+        width: 100%;
+        margin-bottom: 1;
+    }
+
+    #dialog-hint {
+        color: $text-muted;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    def action_cancel(self):
+        self.dismiss(None)
+
+    @on(Input.Submitted, "#key-input")
+    def on_key_submitted(self, event: Input.Submitted):
+        self.dismiss(event.value.strip())
+
+
+class UpdateDialog(ModalScreen):
+    def __init__(self, current: str, latest: str):
+        super().__init__()
+        self._current = current
+        self._latest = latest
+        self._updating = False
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label("[bold yellow]Update available[/bold yellow]", id="dialog-title")
+            yield Label(f"Current: v{self._current}", id="label-current")
+            yield Label(f"Latest:  [bold green]v{self._latest}[/bold green]", id="label-latest")
+            yield Label("")
+            yield Label("To update, run this in your terminal:")
+            yield Label("[bold cyan]ghostcode update[/bold cyan]", id="label-command")
+            yield Label("")
+            yield Button("Close", id="btn-close")
+
+    CSS = """
+    UpdateDialog {
+        align: center middle;
+    }
+
+    #dialog {
+        width: 56;
+        height: auto;
+        padding: 2 3;
+        background: $surface;
+        border: tall $primary;
+    }
+
+    #dialog-title {
+        margin-bottom: 1;
+    }
+
+    Label {
+        margin-bottom: 1;
+    }
+
+    #label-command {
+        padding: 1 2;
+        background: $background;
+        color: $primary;
+        text-style: bold;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+    ]
+
+    @on(Button.Pressed, "#btn-close")
+    def action_close(self):
+        self.dismiss(None)
+
+
+class DevMenu(ModalScreen):
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label("[bold]Dev Menu[/bold]", id="dialog-title")
+            yield Label("Test UI components:", id="dialog-subtitle")
+            yield Button("ApiKeyDialog", id="btn-apikey")
+            yield Button("UpdateDialog", id="btn-update")
+            yield Button("Close", id="btn-close", variant="primary")
+
+    CSS = """
+    DevMenu {
+        align: center middle;
+    }
+
+    #dialog {
+        width: 50;
+        height: auto;
+        padding: 2 3;
+        background: $surface;
+        border: tall $primary;
+    }
+
+    #dialog-title {
+        margin-bottom: 1;
+        text-style: bold;
+    }
+
+    #dialog-subtitle {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+
+    Button {
+        width: 100%;
+        margin-bottom: 1;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close"),
+    ]
+
+    @on(Button.Pressed, "#btn-apikey")
+    def test_apikey(self):
+        self.app.push_screen(ApiKeyDialog("groq", "Groq (test)"))
+
+    @on(Button.Pressed, "#btn-update")
+    def test_update(self):
+        self.app.push_screen(UpdateDialog("0.1.0", "99.9.9"))
+
+    @on(Button.Pressed, "#btn-close")
+    def action_close(self):
+        self.dismiss(None)
+
+
+class PermissionDialog(ModalScreen):
+    def __init__(self, tool_name: str, args: dict):
+        super().__init__()
+        self._tool_name = tool_name
+        self._args = args
+
+    def compose(self) -> ComposeResult:
+        args_str = str(self._args)
+        if len(args_str) > 70:
+            args_str = args_str[:67] + "..."
+        with Vertical(id="dialog"):
+            yield Label("[bold yellow]Permission required[/bold yellow]", id="dialog-title")
+            yield Label(f"Tool: [bold]{self._tool_name}[/bold]", id="label-tool")
+            yield Label(f"Args: [dim]{args_str}[/dim]", id="label-args")
+            yield Label("")
+            with Horizontal(id="perm-buttons"):
+                yield Button("Allow", id="btn-allow", variant="primary")
+                yield Button("Deny", id="btn-deny", variant="error")
+
+    CSS = """
+    PermissionDialog {
+        align: center middle;
+    }
+
+    #dialog {
+        width: 60;
+        height: auto;
+        padding: 2 3;
+        background: $surface;
+        border: tall $primary;
+    }
+
+    #dialog-title {
+        margin-bottom: 1;
+    }
+
+    #label-tool {
+        margin-bottom: 1;
+    }
+
+    #label-args {
+        margin-bottom: 1;
+        color: $text-muted;
+    }
+
+    #perm-buttons {
+        height: 3;
+        align: center middle;
+    }
+
+    #perm-buttons Button {
+        margin: 0 1;
+        width: 20;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "deny", "Deny"),
+    ]
+
+    @on(Button.Pressed, "#btn-allow")
+    def action_allow(self):
+        self.dismiss(True)
+
+    @on(Button.Pressed, "#btn-deny")
+    def action_deny(self):
+        self.dismiss(False)