@scemoon/cdh 1.0.0

package/onecode/agent/tools/task_tools.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+
+
+class TaskCreateTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskCreate",
+            description="Create a fine-grained task (1-3 tool calls each). For large work, split into multiple smaller tasks with dependencies. Returns task id.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "subject": {"type": "string", "description": "Short, action-oriented title (verb + noun, e.g. 'Create User model')"},
+                    "description": {"type": "string", "description": "What needs to be done + acceptance criteria"},
+                    "activeForm": {"type": "string", "description": "Active form description"},
+                    "metadata": {"type": "object", "description": 'Optional metadata. Supports priority (high/medium/low) and effort (small/medium/large)'},
+                },
+                "required": ["subject", "description"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        task = self._tm.create_task(
+            subject=tool_input.get("subject", ""),
+            description=tool_input.get("description", ""),
+            active_form=tool_input.get("activeForm", ""),
+            metadata=tool_input.get("metadata"),
+        )
+        return ToolResult(name="TaskCreate", output={"task": {"id": task["id"], "subject": task["subject"]}})
+
+
+
+class TaskGetTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskGet",
+            description="Retrieve a task by ID.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "taskId": {"type": "string", "description": "Task id to retrieve"},
+                },
+                "required": ["taskId"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        task_id = tool_input.get("taskId", "")
+        task = self._tm.get_task(task_id)
+        if task is None:
+            return ToolResult(name="TaskGet", output={"task": None})
+        info = {k: task[k] for k in ("id", "subject", "description", "status", "blocks", "blockedBy")}
+        return ToolResult(name="TaskGet", output={"task": info})
+
+
+
+class TaskListTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskList",
+            description="List all tasks with their current status and dependencies.",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        tasks = self._tm.list_tasks()
+        if not tasks:
+            return ToolResult(name="TaskList", output={"tasks": []})
+        summaries = []
+        for t in tasks:
+            s = {"id": t["id"], "subject": t["subject"], "status": t["status"]}
+            if t.get("owner"):
+                s["owner"] = t["owner"]
+            s["blockedBy"] = list(t.get("blockedBy") or [])
+            summaries.append(s)
+        return ToolResult(name="TaskList", output={"tasks": summaries})
+
+
+
+class TaskUpdateTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskUpdate",
+            description="Update a task: subject, description, status, owner, dependencies, output.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "taskId": {"type": "string", "description": "Task id to update"},
+                    "subject": {"type": "string"},
+                    "description": {"type": "string"},
+                    "activeForm": {"type": "string"},
+                    "status": {"type": "string", "description": "pending|in_progress|completed|deleted"},
+                    "owner": {"type": "string"},
+                    "addBlocks": {"type": "array", "items": {"type": "string"}, "description": "Task IDs this task blocks"},
+                    "addBlockedBy": {"type": "array", "items": {"type": "string"}, "description": "Task IDs that block this"},
+                    "metadata": {"type": "object"},
+                    "output": {"type": "string", "description": "Key results to pass to downstream tasks"},
+                },
+                "required": ["taskId"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        task_id = tool_input.get("taskId", "")
+        updates = {k: v for k, v in tool_input.items() if k != "taskId" and v is not None}
+        if "subject" not in updates and "title" in updates:
+            updates["subject"] = updates.pop("title")
+        if "addBlocks" not in updates and "blocks" in updates and isinstance(updates.get("blocks"), list):
+            updates["addBlocks"] = updates.pop("blocks")
+        result = self._tm.update_task(task_id, **updates)
+        if result is None:
+            return ToolResult(name="TaskUpdate", output={"success": False, "taskId": task_id, "error": "Task not found"}, is_error=True)
+        if result.get("deleted"):
+            return ToolResult(name="TaskUpdate", output={"success": True, "taskId": task_id, "updatedFields": ["deleted"]})
+        return ToolResult(name="TaskUpdate", output={"success": True, "taskId": task_id, "task": {"id": result["id"], "subject": result["subject"], "status": result["status"]}})
+
+
+
+class TaskOutputTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskOutput",
+            description="Get output for a task.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "task_id": {"type": "string", "description": "Task id to get output for"},
+                },
+                "required": ["task_id"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        task_id = tool_input.get("task_id", "")
+        result = self._tm.get_task_output(task_id)
+        return ToolResult(name="TaskOutput", output=result)
+
+
+
+class TaskStopTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TaskStop",
+            description="Stop/cancel a running task.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "task_id": {"type": "string", "description": "Task id to stop"},
+                },
+                "required": ["task_id"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        task_id = tool_input.get("task_id", "")
+        result = self._tm.update_task(task_id, status="completed")
+        if result is None:
+            return ToolResult(name="TaskStop", output={"success": False, "stopped": False, "error": "Task not found"}, is_error=True)
+        if result.get("deleted"):
+            return ToolResult(name="TaskStop", output={"success": True, "stopped": True, "task_id": task_id})
+        return ToolResult(name="TaskStop", output={"success": True, "stopped": True, "task_id": task_id})
+
+
+
+class TodoCreateTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TodoCreate",
+            description="Create a todo item. Returns todo id.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Todo item text"},
+                },
+                "required": ["text"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        text = tool_input.get("text", "")
+        todo_id = self._tm.add_todo(text)
+        return ToolResult(name="TodoCreate", output={"id": todo_id, "text": text})
+
+
+
+class TodoListTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TodoList",
+            description="List all todo items.",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        todos = self._tm.list_todos()
+        return ToolResult(name="TodoList", output=todos)
+
+
+
+class TodoCompleteTool:
+    def __init__(self, task_manager):
+        self._tm = task_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TodoComplete",
+            description="Mark a todo as completed.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "todo_id": {"type": "string", "description": "Todo id to complete"},
+                },
+                "required": ["todo_id"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        todo_id = tool_input.get("todo_id", tool_input.get("id", ""))
+        ok = self._tm.complete_todo(str(todo_id))
+        return ToolResult(name="TodoComplete", output={"success": ok, "todo_id": todo_id}, is_error=not ok)
+

package/onecode/agent/tools/web_tools.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import re
+import html
+from dataclasses import dataclass
+from typing import Any, Optional
+
+import httpx
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+
+
+@dataclass
+class WebResult:
+    url: str
+    title: str
+    snippet: str
+    content: Optional[str] = None
+
+
+class WebFetcher:
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout
+
+    def fetch(self, url: str, prompt: Optional[str] = None) -> str:
+        try:
+            with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
+                resp = client.get(url)
+                resp.raise_for_status()
+
+            content_type = resp.headers.get("content-type", "").lower()
+            if "text/html" in content_type:
+                text = self._extract_text_from_html(resp.text)
+            else:
+                text = resp.text[:5000]
+
+            if prompt:
+                return f"URL: {url}\nContent (relevant to '{prompt}'):\n{text[:3000]}"
+            return f"URL: {url}\nContent:\n{text[:3000]}"
+
+        except httpx.TimeoutException:
+            return f"Error: Timeout fetching {url}"
+        except httpx.HTTPStatusError as e:
+            return f"Error: HTTP {e.response.status_code} for {url}"
+        except Exception as e:
+            return f"Error: {str(e)} for {url}"
+
+    def _extract_text_from_html(self, html_content: str) -> str:
+        text = re.sub(r"<script[^>]*>.*?</script>", "", html_content, flags=re.DOTALL | re.IGNORECASE)
+        text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL | re.IGNORECASE)
+        text = re.sub(r"<[^>]+>", " ", text)
+        text = html.unescape(text)
+        text = re.sub(r"\s+", " ", text).strip()
+        return text[:5000]
+
+
+class WebSearch:
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout
+        self._fetcher = WebFetcher(timeout)
+
+    def search(self, query: str, num_results: int = 5) -> str:
+        search_urls = [
+            f"https://duckduckgo.com/html/?q={self._quote(query)}",
+            f"https://html.duckduckgo.com/html/?q={self._quote(query)}",
+        ]
+
+        for url in search_urls:
+            try:
+                results = self._search_duckduckgo(url, num_results)
+                if results:
+                    return results
+            except Exception:
+                continue
+
+        return self._search_fallback(query, num_results)
+
+    def _search_duckduckgo(self, url: str, num_results: int) -> str:
+        with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
+            resp = client.get(url)
+            resp.raise_for_status()
+
+        html_content = resp.text
+        results = []
+
+        result_pattern = re.compile(r'<a class="result__a" href="([^"]+)">([^<]+)</a>.*?<a class="result__snippet"[^>]*>([^<]+)</a>', re.DOTALL)
+        snippets = re.findall(r'<a class="result__a" href="([^"]+)">([^<]+)</a>', html_content)
+        snippet_pattern = re.compile(r'<a class="result__a" href="[^"]+">[^<]+</a>.*?(?:<p class="result__snippet">([^<]+)</p>)?', re.DOTALL)
+
+        for i, (url, title) in enumerate(snippets[:num_results]):
+            snippet_match = re.search(rf'<a class="result__a" href="{re.escape(url)}"[^>]*>[^<]+</a>.*?(?:<p class="result__snippet">([^<]+)</p>|(?:<a class="result__snippet"[^>]*>([^<]+)</a>))?', html_content, re.DOTALL)
+            snippet = ""
+            if snippet_match:
+                snippet = snippet_match.group(1) or snippet_match.group(2) or ""
+
+            title = re.sub(r'<[^>]+>', '', title)
+            snippet = re.sub(r'<[^>]+>', '', snippet)
+            results.append(f"{i+1}. {title}\n   URL: {url}\n   {snippet[:200]}")
+
+        if results:
+            return f"Search results for '{query}':\n\n" + "\n\n".join(results)
+
+        return f"No results found for '{query}'"
+
+    def _search_fallback(self, query: str, num_results: int) -> str:
+        return f"Web search for '{query}' returned no results. Try using WebFetch to directly access a URL."
+
+    def _quote(self, query: str) -> str:
+        import urllib.parse
+        return urllib.parse.quote_plus(query)
+
+
+def webfetch(url: str, prompt: Optional[str] = None) -> str:
+    fetcher = WebFetcher()
+    return fetcher.fetch(url, prompt)
+
+
+def websearch(query: str, num_results: int = 5) -> str:
+    searcher = WebSearch()
+    return searcher.search(query, num_results)
+
+
+class WebFetchTool:
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="WebFetch",
+            description="Fetch a URL and extract information.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "url": {"type": "string", "description": "URL to fetch"},
+                    "prompt": {"type": "string", "description": "What to extract from the page"},
+                },
+                "required": ["url"],
+            },
+            is_read_only=True,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        url = tool_input.get("url", "")
+        prompt = tool_input.get("prompt")
+        content = webfetch(url, prompt)
+        is_error = str(content).startswith("Error:")
+        return ToolResult(name="WebFetch", output=str(content), is_error=is_error)
+
+
+
+class WebSearchTool:
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="WebSearch",
+            description="Search the web and return results.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"},
+                    "num_results": {"type": "integer", "description": "Number of results", "default": 5},
+                },
+                "required": ["query"],
+            },
+            is_read_only=True,
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        query = tool_input.get("query", "")
+        num_results = tool_input.get("num_results", 5)
+        content = websearch(query, num_results)
+        is_error = "Error" in str(content) and str(content).startswith("Error")
+        return ToolResult(name="WebSearch", output=str(content), is_error=is_error)

package/onecode/builtin_skills/git/SKILL.md

@@ -0,0 +1,64 @@
+# Git Skill
+
+Provides Git version control and GitHub integration capabilities.
+
+## Agent Tools
+
+| Operation | Tool |
+|-----------|------|
+| Clone repo | `exec_shell("git clone ...")` |
+| Commit | `exec_shell("git commit ...")` |
+| Push/Pull | `exec_shell("git push/pull")` |
+| Branch | `exec_shell("git checkout/branch ...")` |
+| GitHub API | via `gh` command |
+
+## Common Commands
+
+### Basic Workflow
+```bash
+git init                    # Initialize repo
+git clone <url>             # Clone repository
+git add .                   # Stage all changes
+git commit -m "message"     # Commit with message
+git push                    # Push to remote
+git pull                    # Pull from remote
+```
+
+### Branching
+```bash
+git branch                  # List branches
+git branch -b new-branch    # Create and switch
+git checkout <branch>       # Switch branch
+git merge <branch>          # Merge branch
+```
+
+### Inspection
+```bash
+git status                  # Show working tree status
+git log --oneline -10       # Recent commits
+git diff                    # Show changes
+git diff --staged           # Staged changes
+git show <commit>           # Commit details
+```
+
+### GitHub CLI (`gh`)
+```bash
+gh repo clone owner/repo    # Clone via gh
+gh pr create                # Create pull request
+gh pr list                  # List PRs
+gh issue list               # List issues
+gh repo view                # View repo info
+```
+
+## Agent Integration
+
+When this skill is active, the agent can:
+1. Clone repos to local via `git clone`
+2. Commit changes with structured messages
+3. Create and manage branches
+4. Interact with GitHub via `gh` CLI
+5. Pull/push code during development
+
+## GitHub Token
+
+Store token at `~/.cloud-harness-tokens.json` or set `GITHUB_TOKEN` env var.

package/onecode/builtin_skills/git/skill.yaml

@@ -0,0 +1,7 @@
+name: git
+description: >-
+  Git skill for version control operations, GitHub integration,
+  and code repository management.
+version: 1.0.0
+enabled: true
+entry: SKILL.md

package/onecode/builtin_skills/shell/SKILL.md

@@ -0,0 +1,58 @@
+# Shell Skill
+
+Provides shell command execution capabilities and common operations.
+
+## Agent Tools
+
+| Operation | Command |
+|-----------|---------|
+| Execute command | `exec_shell("command")` |
+| Check output | read from command result |
+| Working directory | defaults to current workspace |
+
+## Common Commands
+
+### File Operations
+```bash
+ls -la                    # List files with details
+mkdir -p path             # Create directory
+rm -rf path              # Remove directory recursively
+cp -r src dst             # Copy recursively
+mv src dst                # Move/rename
+find . -name "*.py"      # Find files
+```
+
+### Git Operations (see git skill)
+```bash
+git status
+git add .
+git commit -m "message"
+git push
+```
+
+### npm/Node
+```bash
+npm install
+npm run build
+npm test
+```
+
+### Python
+```bash
+python3 -m pip install <package>
+python3 script.py
+```
+
+## Safety
+
+- Agent should confirm destructive commands (rm -rf, etc.) with user
+- Shell whitelist configurable in cdh.config.yaml
+- Interactive commands (vim, less, etc.) may not work in agent mode
+
+## Agent Integration
+
+When this skill is active, the agent can:
+1. Execute commands via `exec_shell` tool
+2. Parse command output for decision making
+3. Chain commands with pipes
+4. Run background tasks with `&`

package/onecode/builtin_skills/shell/skill.yaml

@@ -0,0 +1,8 @@
+name: shell
+description: >-
+  Shell skill for executing system commands, managing processes,
+  and performing file operations. Integrates with the agent's
+  exec_shell tool and provides command templates.
+version: 1.0.0
+enabled: true
+entry: SKILL.md