@scemoon/cdh 1.0.5 → 1.0.7

package/onecode/agent/tools/schema_validation.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Mapping
-
-from onecode.agent.tools.errors import ToolInputError
-
-
-def validate_json_schema(
-    input_data: dict[str, Any],
-    schema: Mapping[str, Any],
-    tool_name: str = "",
-) -> None:
-    """Validate input against JSON Schema.
-
-    Supports: required fields, type checks, string patterns, enums,
-    nested objects, and arrays.
-    """
-    if not schema:
-        return
-
-    errors: list[str] = []
-    props = schema.get("properties", {})
-    required = set(schema.get("required", []))
-
-    # Check required fields
-    for field in required:
-        if field not in input_data or input_data[field] is None:
-            errors.append(f"missing required field: '{field}'")
-
-    # Validate each present field
-    for field, value in input_data.items():
-        prop_schema = props.get(field)
-        if prop_schema is None:
-            continue
-        _validate_field(field, value, prop_schema, errors, input_data)
-
-    if errors:
-        prefix = f" in tool '{tool_name}'" if tool_name else ""
-        msg = f"input validation failed{prefix}:\n" + "\n".join(f"  - {e}" for e in errors)
-        raise ToolInputError(msg)
-
-
-def _validate_field(
-    field: str,
-    value: Any,
-    schema: dict[str, Any],
-    errors: list[str],
-    root_input: dict[str, Any],
-) -> None:
-    json_type = schema.get("type", "")
-
-    if json_type == "string":
-        if not isinstance(value, str):
-            errors.append(f"'{field}': expected string, got {type(value).__name__}")
-        else:
-            pattern = schema.get("pattern")
-            if pattern:
-                import re
-                if not re.match(pattern, value):
-                    errors.append(f"'{field}': does not match pattern {pattern!r}")
-
-    elif json_type == "integer":
-        if not isinstance(value, int) or isinstance(value, bool):
-            errors.append(f"'{field}': expected integer, got {type(value).__name__}")
-
-    elif json_type == "number":
-        if not isinstance(value, (int, float)) or isinstance(value, bool):
-            errors.append(f"'{field}': expected number, got {type(value).__name__}")
-
-    elif json_type == "boolean":
-        if not isinstance(value, bool):
-            errors.append(f"'{field}': expected boolean, got {type(value).__name__}")
-
-    elif json_type == "array":
-        if not isinstance(value, list):
-            errors.append(f"'{field}': expected array, got {type(value).__name__}")
-        else:
-            items_schema = schema.get("items")
-            if items_schema:
-                for i, item in enumerate(value):
-                    _validate_field(f"{field}[{i}]", item, items_schema, errors, root_input)
-
-    elif json_type == "object":
-        if not isinstance(value, dict):
-            errors.append(f"'{field}': expected object, got {type(value).__name__}")
-        else:
-            sub_required = set(schema.get("required", []))
-            sub_props = schema.get("properties", {})
-            for sub_field in sub_required:
-                if sub_field not in value:
-                    errors.append(f"'{field}.{sub_field}': missing required field")
-            for sub_field, sub_value in value.items():
-                sub_schema = sub_props.get(sub_field)
-                if sub_schema:
-                    _validate_field(f"{field}.{sub_field}", sub_value, sub_schema, errors, root_input)
-
-    # Check enum values
-    enum_values = schema.get("enum")
-    if enum_values is not None and value not in enum_values:
-        errors.append(f"'{field}': must be one of {enum_values}, got {value!r}")

package/onecode/agent/tools/skill_tools.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import Tool, ToolSpec
-from onecode.skills.loader import SkillLoader
-from onecode.skills.argument_substitution import substitute_arguments
-
-
-class SkillTool(Tool):
-    """Run a SKILL.md skill (Clawd-Code pattern)."""
-
-    def __init__(self, loader: SkillLoader):
-        self._loader = loader
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="Skill",
-            description="Run a registered skill by name with optional arguments. Skills are markdown-based instruction sets with YAML frontmatter.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "name": {"type": "string", "description": "Skill name to run"},
-                    "arguments": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "Optional positional arguments ($0, $1, $path, $ARGUMENTS)",
-                    },
-                },
-                "required": ["name"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        name = tool_input.get("name", "")
-        args = tool_input.get("arguments") or []
-        skill = self._loader.get(name)
-        if not skill:
-            return ToolResult(
-                name="Skill",
-                output={"error": f"skill '{name}' not found"},
-                is_error=True,
-            )
-        content = skill.content
-        if args:
-            content = substitute_arguments(content, args)
-        return ToolResult(
-            name="Skill",
-            output={"name": name, "content": content, "description": skill.description},
-        )
-

package/onecode/agent/tools/todo_tools.py

@@ -1,207 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import Tool, ToolSpec
-
-
-class TodoCreateTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoCreate",
-            description=(
-                "Create a todo (plan item) for tracking progress. ALL tasks — simple "
-                "or complex — are created via TodoCreate, persisted to .cdh/todos.json, "
-                "and mirrored to the sidebar Plan widget. At execution time, route by "
-                "complexity: simple todos are executed directly; complex todos are "
-                "delegated via `Spawn` (mark with metadata={\"delegate_to\": \"general\"}). "
-                "Returns todo 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), effort (small/medium/large), and delegate_to (general|explore|scout|main) to flag complex todos for Spawn subagent execution.'},
-                },
-                "required": ["subject", "description"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo = self._tm.create_todo(
-            subject=tool_input.get("subject", ""),
-            description=tool_input.get("description", ""),
-            active_form=tool_input.get("activeForm", ""),
-            metadata=tool_input.get("metadata"),
-        )
-        return ToolResult(name="TodoCreate", output={"task": {"id": todo["id"], "subject": todo["subject"]}})
-
-
-
-class TodoGetTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoGet",
-            description="Retrieve a todo by ID.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Todo id to retrieve"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("taskId", "")
-        todo = self._tm.get_todo(todo_id)
-        if todo is None:
-            return ToolResult(name="TodoGet", output={"task": None})
-        info = {k: todo[k] for k in ("id", "subject", "description", "status", "blocks", "blockedBy")}
-        return ToolResult(name="TodoGet", output={"task": info})
-
-
-
-class TodoListTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoList",
-            description="List all todos with their current status and dependencies.",
-            input_schema={"type": "object", "properties": {}, "required": []},
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todos = self._tm.list_todos()
-        if not todos:
-            return ToolResult(name="TodoList", output={"tasks": []})
-        summaries = []
-        for t in todos:
-            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="TodoList", output={"tasks": summaries})
-
-
-
-class TodoUpdateTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoUpdate",
-            description="Update a todo: subject, description, status, owner, dependencies, output.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Todo 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": "Todo IDs this todo blocks"},
-                    "addBlockedBy": {"type": "array", "items": {"type": "string"}, "description": "Todo IDs that block this"},
-                    "metadata": {"type": "object"},
-                    "output": {"type": "string", "description": "Key results to pass to downstream todos"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_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_todo(todo_id, **updates)
-        if result is None:
-            return ToolResult(name="TodoUpdate", output={"success": False, "taskId": todo_id, "error": "Todo not found"}, is_error=True)
-        if result.get("deleted"):
-            return ToolResult(name="TodoUpdate", output={"success": True, "taskId": todo_id, "updatedFields": ["deleted"]})
-        return ToolResult(name="TodoUpdate", output={"success": True, "taskId": todo_id, "task": {"id": result["id"], "subject": result["subject"], "status": result["status"]}})
-
-
-
-class TodoOutputTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoOutput",
-            description="Get output for a todo.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Todo id to get output for"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("taskId", "")
-        result = self._tm.get_todo_output(todo_id)
-        return ToolResult(name="TodoOutput", output=result)
-
-
-
-class TodoStopTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoStop",
-            description="Stop/cancel a running todo.",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "taskId": {"type": "string", "description": "Todo id to stop"},
-                },
-                "required": ["taskId"],
-            },
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("taskId", "")
-        result = self._tm.update_todo(todo_id, status="completed")
-        if result is None:
-            return ToolResult(name="TodoStop", output={"success": False, "stopped": False, "error": "Todo not found"}, is_error=True)
-        if result.get("deleted"):
-            return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "taskId": todo_id})
-        return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "taskId": todo_id})
-
-
-class TodoClearTool(Tool):
-    def __init__(self, todo_manager):
-        self._tm = todo_manager
-
-    def spec(self) -> ToolSpec:
-        return ToolSpec(
-            name="TodoClear",
-            description="Clear all todos. Resets the entire plan — all pending, in-progress, and completed todos are removed and the plan starts fresh.",
-            input_schema={"type": "object", "properties": {}, "required": []},
-        )
-
-    def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        count = len(self._tm.list_todos())
-        self._tm.clear_todos()
-        return ToolResult(name="TodoClear", output={"cleared": count})

package/onecode/agent/tools/web_tools.py

@@ -1,169 +0,0 @@
-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 Tool, 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, query)
-                if results:
-                    return results
-            except Exception:
-                continue
-
-        return self._search_fallback(query, num_results)
-
-    def _search_duckduckgo(self, url: str, num_results: int, query: str) -> 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 = []
-
-        snippets = re.findall(r'<a class="result__a" href="([^"]+)">([^<]+)</a>', html_content)
-
-        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:
-        """Fallback search using a different method."""
-        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(Tool):
-    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(Tool):
-    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)