ghostcode-canary 0.1.25-canary.0

package/src/ghostcode/core/tasks.py

@@ -0,0 +1,125 @@
+import asyncio
+import time
+import uuid
+from enum import Enum
+
+
+class TaskStatus(Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    STOPPED = "stopped"
+
+
+class Task:
+    def __init__(self, description: str, prompt: str, subagent_type: str = "worker"):
+        self.id = str(uuid.uuid4())[:8]
+        self.description = description
+        self.prompt = prompt
+        self.subagent_type = subagent_type
+        self.status = TaskStatus.PENDING
+        self.result: str | None = None
+        self.error: str | None = None
+        self.created_at = time.time()
+        self.completed_at: float | None = None
+        self.tool_uses = 0
+        self.duration_ms: int | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "description": self.description,
+            "prompt": self.prompt,
+            "subagent_type": self.subagent_type,
+            "status": self.status.value,
+            "result": self.result,
+            "error": self.error,
+            "created_at": self.created_at,
+            "completed_at": self.completed_at,
+            "tool_uses": self.tool_uses,
+            "duration_ms": self.duration_ms,
+        }
+
+    def to_notification(self) -> str:
+        return (
+            f"<task-notification>\n"
+            f"<task-id>{self.id}</task-id>\n"
+            f"<status>{self.status.value}</status>\n"
+            f"<summary>{self.description} — {self.status.value}</summary>\n"
+            f"<result>{self.result or ''}</result>\n"
+            f"<usage>\n"
+            f"  <tool_uses>{self.tool_uses}</tool_uses>\n"
+            f"  <duration_ms>{self.duration_ms or 0}</duration_ms>\n"
+            f"</usage>\n"
+            f"</task-notification>"
+        )
+
+
+class TaskManager:
+    def __init__(self):
+        self._tasks: dict[str, Task] = {}
+        self._pending_callbacks: dict[str, list] = {}
+
+    def create(self, description: str, prompt: str, subagent_type: str = "worker") -> Task:
+        task = Task(description, prompt, subagent_type)
+        self._tasks[task.id] = task
+        return task
+
+    def get(self, task_id: str) -> Task | None:
+        return self._tasks.get(task_id)
+
+    def update(self, task_id: str, status: TaskStatus, result: str | None = None, error: str | None = None):
+        task = self._tasks.get(task_id)
+        if not task:
+            return
+        task.status = status
+        if result is not None:
+            task.result = result
+        if error is not None:
+            task.error = error
+        if status in (TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.STOPPED):
+            task.completed_at = time.time()
+            task.duration_ms = int((task.completed_at - task.created_at) * 1000)
+        # fire callbacks
+        cb_list = self._pending_callbacks.pop(task_id, [])
+        for cb in cb_list:
+            try:
+                if asyncio.iscoroutinefunction(cb):
+                    asyncio.ensure_future(cb(task))
+                else:
+                    cb(task)
+            except Exception:
+                pass
+
+    def stop(self, task_id: str) -> bool:
+        task = self._tasks.get(task_id)
+        if not task or task.status not in (TaskStatus.PENDING, TaskStatus.RUNNING):
+            return False
+        self.update(task_id, TaskStatus.STOPPED)
+        return True
+
+    def list_tasks(self, status_filter: str | None = None) -> list[dict]:
+        tasks = list(self._tasks.values())
+        if status_filter:
+            tasks = [t for t in tasks if t.status.value == status_filter]
+        tasks.sort(key=lambda t: t.created_at, reverse=True)
+        return [t.to_dict() for t in tasks]
+
+    def on_complete(self, task_id: str, callback):
+        task = self._tasks.get(task_id)
+        if not task:
+            return
+        if task.status in (TaskStatus.COMPLETED, TaskStatus.FAILED, TaskStatus.STOPPED):
+            try:
+                if asyncio.iscoroutinefunction(callback):
+                    asyncio.ensure_future(callback(task))
+                else:
+                    callback(task)
+            except Exception:
+                pass
+            return
+        self._pending_callbacks.setdefault(task_id, []).append(callback)
+
+
+task_manager = TaskManager()

package/src/ghostcode/tools/__init__.py

@@ -0,0 +1,2 @@
+from ghostcode.tools.defs import TOOL_DEFINITIONS, COMPACT_TOOL_DEFINITIONS
+from ghostcode.tools.executor import execute_tool, needs_permission

package/src/ghostcode/tools/defs.py

@@ -0,0 +1,325 @@
+TOOL_DEFINITIONS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Reads a file from the local filesystem. Returns file content as text. Use for code files, configs, and any text-based file. Supports large files with offset/limit params. Also reads images and Jupyter notebooks.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute path to the file. Must be absolute, not relative.",
+                    },
+                    "offset": {
+                        "type": "integer",
+                        "description": "Line number to start reading from (1-indexed). Useful for large files.",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of lines to return. Defaults to all lines if omitted.",
+                    },
+                },
+                "required": ["file_path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Writes a file to the local filesystem. Creates parent directories if needed. Overwrites existing content. Use for creating new files or complete rewrites. For small targeted changes, prefer edit_file. Never create *.md or README files unless asked.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to write to.",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "The full content to write to the file.",
+                    },
+                },
+                "required": ["file_path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "edit_file",
+            "description": "Performs exact string replacements in files. Replace the first occurrence of old_string with new_string. Use for targeted edits — only sends the diff. The old_string must match exactly; include enough surrounding context to make it unique. Prefer editing existing files over creating new ones.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Absolute or relative path to the file to edit.",
+                    },
+                    "old_string": {
+                        "type": "string",
+                        "description": "The exact text to replace (first occurrence only). Include enough surrounding lines for uniqueness. Must match indentation exactly.",
+                    },
+                    "new_string": {
+                        "type": "string",
+                        "description": "The replacement text.",
+                    },
+                },
+                "required": ["file_path", "old_string", "new_string"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_command",
+            "description": "Executes a given shell command and returns its stdout + stderr output. Use for running tests, build commands, git operations, and other CLI tools. Commands run in the specified working directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "The shell command to execute.",
+                    },
+                    "workdir": {
+                        "type": "string",
+                        "description": "Working directory for the command (default: current directory). Always specify explicitly when the command depends on a specific directory.",
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "description": "Timeout in milliseconds (default: 120000, max: 600000).",
+                    },
+                },
+                "required": ["command"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List files and directories at the given path. Optionally filter by glob pattern. Use to explore directory structure before reading specific files. Returns files sorted by modification time.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Directory path (default: current directory).",
+                    },
+                    "pattern": {
+                        "type": "string",
+                        "description": "Optional glob pattern filter (e.g. '*.py' for Python files, '**/*.ts' for all TypeScript recursively).",
+                    },
+                },
+                "required": [],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "grep_search",
+            "description": "A powerful content search tool using regex. Searches file contents and returns matching lines with file paths and line numbers. Use for finding relevant code, references, and patterns across the codebase. ALWAYS use this instead of invoking grep/rg via shell. Supports full regex syntax. Filter files with the include parameter (e.g. '*.py', '*.{ts,tsx}'). Results are capped at 200 matches.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Regex pattern to search for in file contents. Uses ripgrep syntax — escape literal braces.",
+                    },
+                    "include": {
+                        "type": "string",
+                        "description": "Optional file glob pattern to filter by (e.g. '*.py', '*.{ts,tsx}').",
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "Directory to search (default: current directory).",
+                    },
+                },
+                "required": ["pattern"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": "Search the web for current information. Use for finding docs, APIs, news, and other information not available locally. Results include titles and snippets from relevant pages.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "Search query string.",
+                    },
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_fetch",
+            "description": "Fetch and extract content from a URL. Returns the page content up to 50000 chars. Use for reading documentation, blog posts, and web APIs.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The fully-formed valid URL to fetch content from.",
+                    },
+                },
+                "required": ["url"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "todo_write",
+            "description": "Create and manage a structured task list for the current session. Use at the start of complex multi-step tasks (3+ steps). Helps track progress and demonstrate thoroughness. Each task has a content, status (pending/in_progress/completed/cancelled), and priority. Mark items complete as you finish them. Exactly one task should be in_progress at a time. Skip for trivial/single-step tasks.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "todos": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "content": {"type": "string", "description": "Brief imperative description of the task item."},
+                                "status": {"type": "string", "enum": ["pending", "in_progress", "completed", "cancelled"], "description": "Current status."},
+                                "priority": {"type": "string", "enum": ["high", "medium", "low"], "description": "Priority level."},
+                            },
+                            "required": ["content", "status", "priority"],
+                        },
+                        "description": "List of todo items. Use proactively for complex work.",
+                    },
+                },
+                "required": ["todos"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_save",
+            "description": "Save a persistent file-based memory across sessions. Each memory is one file holding one fact. A good memory is applicable (improves future actions), durable (matters beyond this session), and legible (readable without the original session). Types: user (who the user is), feedback (corrections, preferences), project (goals, constraints), reference (external resources). Save corrections in the same reply — before treating your turn as finished. Do not save what the repo already records.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "Short kebab-case slug (e.g. 'user-prefers-pytest')."},
+                    "content": {"type": "string", "description": "The fact to remember. Include why it matters and how to apply it. Write in connected full sentences."},
+                    "type": {"type": "string", "enum": ["user", "feedback", "project", "reference"], "description": "Memory type — determines when it's recalled."},
+                    "description": {"type": "string", "description": "One-line summary used for relevance during recall."},
+                    "pinned": {"type": "boolean", "description": "If true, applies to ALL future sessions, not just this project. Pin memories that should always apply."},
+                },
+                "required": ["name", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_list",
+            "description": "List all saved memories, optionally filtered by type. Use to see what memories exist before deciding what to search or update.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "type": {"type": "string", "enum": ["user", "feedback", "project", "reference"], "description": "Optional memory type filter."},
+                },
+                "required": [],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_search",
+            "description": "Search through saved memories across all sessions. Use before asking the user questions — you may already know the answer. Returns matching memories with their content.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query to find relevant memories."},
+                },
+                "required": ["query"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "memory_delete",
+            "description": "Delete a memory by name/slug. Use when a memory turns out to be wrong, outdated, or superseded.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "name": {"type": "string", "description": "The kebab-case slug of the memory to delete."},
+                },
+                "required": ["name"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_create",
+            "description": "Create a subagent task to do work asynchronously. Use for parallel research, isolated implementation, or background verification. The task runs independently and reports via notification when complete. Brief the subagent like a smart colleague who hasn't seen the conversation — include file paths, what to do, what done looks like. Don't duplicate work a subagent is doing.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "description": {"type": "string", "description": "Short actionable description of the task (shown in task list)."},
+                    "prompt": {"type": "string", "description": "Self-contained instructions for the subagent. Include file paths, what to do, what done looks like."},
+                    "subagent_type": {"type": "string", "enum": ["worker", "fork", "explore"], "description": "Type of subagent: worker for implementation, fork for research (inherits context), explore for codebase search."},
+                },
+                "required": ["description", "prompt"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_stop",
+            "description": "Stop a running subagent task by ID. Use when requirements change mid-task or a worker is going in the wrong direction.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "task_id": {"type": "string", "description": "The task ID to stop."},
+                },
+                "required": ["task_id"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "task_list",
+            "description": "List all subagent tasks and their statuses. Optionally filter by status. Returns task IDs, descriptions, statuses, and durations.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "status": {"type": "string", "enum": ["pending", "running", "completed", "failed", "stopped"], "description": "Optional status filter."},
+                },
+                "required": [],
+            },
+        },
+    },
+]
+
+# compact versions for tool lists with token constraints
+COMPACT_TOOL_DEFINITIONS = [
+    {
+        "type": "function",
+        "function": {
+            "name": t["function"]["name"],
+            "description": t["function"]["description"].split(".")[0] + ".",
+            "parameters": {
+                "type": "object",
+                "properties": {k: {"type": v.get("type", "string")} for k, v in t["function"]["parameters"]["properties"].items()},
+                "required": t["function"]["parameters"]["required"],
+            },
+        },
+    }
+    for t in TOOL_DEFINITIONS
+]