codenaut 0.1.0__py3-none-any.whl

skills/registry.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import logging
+
+from config.config import Config
+from skills.models import SkillDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class SkillRegistry:
+    def __init__(self, config: Config):
+        self.config = config
+        self._skills: dict[str, SkillDefinition] = {}
+
+    def register(self, skill: SkillDefinition) -> None:
+        key = skill.name.casefold()
+        if key in self._skills:
+            logger.warning(f"Overwriting existing skill: {skill.name}")
+
+        self._skills[key] = skill
+
+    def get_skills(self) -> list[SkillDefinition]:
+        skills = list(self._skills.values())
+        if self.config.allowed_skills:
+            allowed = {name.casefold() for name in self.config.allowed_skills}
+            skills = [skill for skill in skills if skill.name.casefold() in allowed]
+
+        return skills
+
+    def get_active_skills(self, message: str | None = None) -> list[SkillDefinition]:
+        if not self.config.skills_enabled:
+            return []
+
+        normalized_message = " ".join((message or "").casefold().split())
+        always_loaded = {
+            name.casefold() for name in self.config.always_loaded_skills
+        }
+
+        active_skills: list[SkillDefinition] = []
+        for skill in self.get_skills():
+            skill_name = skill.name.casefold()
+            trigger_match = any(
+                trigger.casefold() in normalized_message for trigger in skill.triggers
+            )
+            name_match = skill_name in normalized_message if normalized_message else False
+
+            if (
+                skill.always_include
+                or skill_name in always_loaded
+                or trigger_match
+                or name_match
+            ):
+                active_skills.append(skill)
+
+        return active_skills

tools/__init__.py

@@ -0,0 +1 @@
+"""Built-in and discovered tool support."""

tools/base.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+import abc
+from pathlib import Path
+from pydantic import BaseModel, ValidationError
+from enum import Enum
+from typing import Any
+from dataclasses import dataclass, field
+from pydantic.json_schema import model_json_schema
+
+from config.config import Config
+
+
+class ToolKind(str, Enum):
+    READ = "read"
+    WRITE = "write"
+    SHELL = "shell"
+    NETWORK = "network"
+    MEMORY = "memory"
+    MCP = "mcp"
+
+
+@dataclass
+class FileDiff:
+    path: Path
+    old_content: str
+    new_content: str
+
+    is_new_file: bool = False
+    is_deletion: bool = False
+
+    def to_diff(self) -> str:
+        import difflib
+
+        old_lines = self.old_content.splitlines(keepends=True)
+        new_lines = self.new_content.splitlines(keepends=True)
+
+        if old_lines and not old_lines[-1].endswith("\n"):
+            old_lines[-1] += "\n"
+        if new_lines and not new_lines[-1].endswith("\n"):
+            new_lines[-1] += "\n"
+        
+        #here /dev/null is used when one of the list is empty either old_line or new_line
+
+        old_name = "/dev/null" if self.is_new_file else str(self.path)
+        new_name = "/dev/null" if self.is_deletion else str(self.path)
+
+        diff = difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile=old_name,
+            tofile=new_name,
+        )
+
+        return "".join(diff)
+
+
+@dataclass
+class ToolResult:
+    success: bool
+    output: str
+    error: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    truncated: bool = False
+    diff: FileDiff | None = None
+    exit_code: int | None = None
+
+    @classmethod
+    def error_result(cls, error: str, output: str = "", **kwargs: Any):
+        return cls(
+            success=False,
+            output=output,
+            error=error,
+            **kwargs,
+        )
+
+    @classmethod
+    def success_result(cls, output: str, **kwargs: Any):
+        return cls(
+            success=True,
+            output=output,
+            error=None,
+            **kwargs,
+        )
+
+    def to_model_output(self) -> str:
+        if self.success:
+            return self.output
+
+        return f"Error: {self.error}\n\nOutput:\n{self.output}"
+
+
+@dataclass
+class ToolInvocation:
+    params: dict[str, Any]
+    cwd: Path
+
+
+@dataclass
+class ToolConfirmation:
+    tool_name: str
+    params: dict[str, Any]
+    description: str
+
+    diff: FileDiff | None = None
+    affected_paths: list[Path] = field(default_factory=list)
+    command: str | None = None
+    is_dangerous: bool = False
+
+
+class Tool(abc.ABC):
+    name: str = "base_tool"
+    description: str = "Base tool"
+    kind: ToolKind = ToolKind.READ
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    @property
+    def schema(self) -> dict[str, Any] | type["BaseModel"]:
+        raise NotImplementedError("Tool must define schema property or class attribute")
+
+    @abc.abstractmethod
+    async def execute(self, invocation: ToolInvocation) -> ToolResult:
+        raise NotImplementedError("Tool must implement execute method")
+
+
+    def validate_params(self, params: dict[str, Any]) -> list[str]:
+        schema = self.schema
+        if isinstance(schema, type) and issubclass(schema, BaseModel):
+            try:
+                schema(**params)
+            except ValidationError as e:
+                errors = []
+                for error in e.errors():
+                    field = ".".join(str(x) for x in error.get("loc", []))
+                    msg = error.get("msg", "Validation error")
+                    errors.append(f"Parameter '{field}': {msg}")
+
+                return errors
+            except Exception as e:
+                return [str(e)]
+
+        return []
+
+    def is_mutating(self, params: dict[str, Any]) -> bool:
+        return self.kind in {
+            ToolKind.WRITE,
+            ToolKind.SHELL,
+            ToolKind.NETWORK,
+            ToolKind.MEMORY,
+        }
+
+    async def get_confirmation(
+        self, invocation: ToolInvocation
+    ) -> ToolConfirmation | None:
+        if not self.is_mutating(invocation.params):
+            return None
+
+        return ToolConfirmation(
+            tool_name=self.name,
+            params=invocation.params,
+            description=f"Execute {self.name} in {invocation.cwd} used for {self.description}",
+        )
+
+    def to_openai_schema(self) -> dict[str, Any]:
+        #There can be two cases - schema is pydatic type(builtin tools) - schema could be dict type(mcp tools)
+
+        schema = self.schema
+
+        if isinstance(schema, type) and issubclass(schema, BaseModel):
+
+            json_schema = model_json_schema(schema, mode="serialization")
+
+            return {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": json_schema.get("properties", {}),
+                    "required": json_schema.get("required", []),
+                },
+            }
+
+        if isinstance(schema, dict):
+            result = {
+                "name": self.name,
+                "description": self.description,
+            }
+
+        #either there will be parameters key
+
+            if "parameters" in schema:
+                result["parameters"] = schema["parameters"]
+            else:
+                result["parameters"] = schema
+
+            return result
+
+        raise ValueError(f"Invalid schema type for tool {self.name}: {type(schema)}")

tools/builtin/__init__.py

@@ -0,0 +1,67 @@
+from tools.builtin.apply_patch import ApplyPatchTool
+from tools.builtin.edit_file import EditTool
+from tools.builtin.glob import GlobTool
+from tools.builtin.grep import GrepTool
+from tools.builtin.list_dir import ListDirTool
+from tools.builtin.memory import MemoryTool
+from tools.builtin.read_file import ReadFileTool
+from tools.builtin.shell import ShellTool
+from tools.builtin.tasks import (
+    ClaimTaskTool,
+    CompleteTaskTool,
+    CreateTaskTool,
+    GetTaskTool,
+    ListTasksTool,
+    UpdateTaskTool,
+    AddTodoTool,
+    CompleteTodoTool,
+)
+from tools.builtin.web_fetch import WebFetchTool
+from tools.builtin.web_search import WebSearchTool
+from tools.builtin.write_file import WriteFileTool
+
+__all__ = [
+    "ApplyPatchTool",
+    "ReadFileTool",
+    "WriteFileTool",
+    "EditTool",
+    "ShellTool",
+    "ListDirTool",
+    "GrepTool",
+    "GlobTool",
+    "WebSearchTool",
+    "WebFetchTool",
+    "CreateTaskTool",
+    "UpdateTaskTool",
+    "ClaimTaskTool",
+    "CompleteTaskTool",
+    "GetTaskTool",
+    "ListTasksTool",
+    "AddTodoTool",
+    "CompleteTodoTool",
+    "MemoryTool",
+]
+
+
+def get_all_builtin_tools() -> list[type]:
+    return [
+        ApplyPatchTool,
+        ReadFileTool,
+        WriteFileTool,
+        EditTool,
+        ShellTool,
+        ListDirTool,
+        GrepTool,
+        GlobTool,
+        WebSearchTool,
+        WebFetchTool,
+        CreateTaskTool,
+        UpdateTaskTool,
+        ClaimTaskTool,
+        CompleteTaskTool,
+        GetTaskTool,
+        ListTasksTool,
+        AddTodoTool,
+        CompleteTodoTool,
+        MemoryTool,
+    ]

tools/builtin/apply_patch.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from tools.base import (
+    FileDiff,
+    ToolConfirmation,
+    ToolInvocation,
+    ToolKind,
+    ToolResult,
+    Tool,
+)
+from utils.paths import resolve_path, ensure_parent_directory
+
+
+class PatchAction(Enum):
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+    RENAME = "rename"
+
+
+@dataclass
+class PatchOperation:
+    action: PatchAction
+    path: Path
+    new_path: Path | None = None  # For renames
+    content: str | None = None  # For create/update
+    move_path: Path | None = None  # Source for renames
+
+
+@dataclass
+class ParsedPatch:
+    operations: list[PatchOperation]
+    errors: list[str]
+
+
+class ApplyPatchParams(BaseModel):
+    patch: str = Field(..., description="The patch content in the specified format")
+    dry_run: bool = Field(
+        False, description="Preview changes without applying them (default: false)"
+    )
+
+
+class ApplyPatchTool(Tool):
+    """
+    Supports a simple patch format:
+
+    ```
+    *** Begin Patch
+    *** Update File: path/to/file.py
+    <<<<<<< SEARCH
+    old content to find
+    =======
+    new content to replace with
+    >>>>>>> REPLACE
+    *** End Patch
+    ```
+
+    Also supports:
+    - *** Create File: path/to/new/file.py
+    - *** Delete File: path/to/file.py
+    - *** Rename File: old/path.py -> new/path.py
+    """
+
+    name = "apply_patch"
+    description = (
+        "Apply a multi-file patch. Supports creating, updating, deleting, and "
+        "renaming files in a single operation. **PREFERRED** when editing 2 or more files "
+        "instead of making multiple separate edit calls. More efficient and allows "
+        "batching multiple file operations atomically.\n\n"
+        "Format:\n"
+        "*** Begin Patch\n"
+        "*** Update File: path/to/file.py\n"
+        "<<<<<<< SEARCH\n"
+        "old content\n"
+        "=======\n"
+        "new content\n"
+        ">>>>>>> REPLACE\n"
+        "*** End Patch\n\n"
+        "Also supports:\n"
+        "*** Create File: path - creates new file with content after it\n"
+        "*** Delete File: path - deletes the file\n"
+        "*** Rename File: old -> new - renames/moves a file"
+    )
+    kind = ToolKind.WRITE
+    schema = ApplyPatchParams
+
+    PATCH_START = re.compile(r"^\*\*\*\s*Begin\s+Patch\s*$", re.IGNORECASE)
+    PATCH_END = re.compile(r"^\*\*\*\s*End\s+Patch\s*$", re.IGNORECASE)
+    UPDATE_FILE = re.compile(r"^\*\*\*\s*Update\s+File:\s*(.+)$", re.IGNORECASE)
+    CREATE_FILE = re.compile(r"^\*\*\*\s*Create\s+File:\s*(.+)$", re.IGNORECASE)
+    DELETE_FILE = re.compile(r"^\*\*\*\s*Delete\s+File:\s*(.+)$", re.IGNORECASE)
+    RENAME_FILE = re.compile(r"^\*\*\*\s*Rename\s+File:\s*(.+)\s*->\s*(.+)$", re.IGNORECASE)
+
+    SEARCH_START = re.compile(r"^<{7}\s*SEARCH\s*$")
+    SEPARATOR = re.compile(r"^={7}\s*$")
+    REPLACE_END = re.compile(r"^>{7}\s*REPLACE\s*$")
+
+    def _parse_patch(self, patch_text: str, cwd: Path) -> ParsedPatch:
+        operations: list[PatchOperation] = []
+        errors: list[str] = []
+
+        lines = patch_text.splitlines()
+        i = 0
+
+        while i < len(lines):
+            if self.PATCH_START.match(lines[i].strip()):
+                i += 1
+                break
+            i += 1
+        else:
+            i = 0
+
+        while i < len(lines):
+            line = lines[i].strip()
+
+            if self.PATCH_END.match(line):
+                break
+
+            if not line:
+                i += 1
+                continue
+
+            if match := self.UPDATE_FILE.match(line):
+                path = resolve_path(cwd, match.group(1).strip())
+                i += 1
+                op, i, err = self._parse_update(lines, i, path)
+                if err:
+                    errors.append(err)
+                elif op:
+                    operations.append(op)
+
+            elif match := self.CREATE_FILE.match(line):
+                path = resolve_path(cwd, match.group(1).strip())
+                i += 1
+                content, i = self._read_until_next_operation(lines, i)
+                operations.append(
+                    PatchOperation(
+                        action=PatchAction.CREATE,
+                        path=path,
+                        content=content,
+                    )
+                )
+
+            elif match := self.DELETE_FILE.match(line):
+                path = resolve_path(cwd, match.group(1).strip())
+                operations.append(
+                    PatchOperation(
+                        action=PatchAction.DELETE,
+                        path=path,
+                    )
+                )
+                i += 1
+
+            elif match := self.RENAME_FILE.match(line):
+                old_path = resolve_path(cwd, match.group(1).strip())
+                new_path = resolve_path(cwd, match.group(2).strip())
+                operations.append(
+                    PatchOperation(
+                        action=PatchAction.RENAME,
+                        path=new_path,
+                        move_path=old_path,
+                    )
+                )
+                i += 1
+
+            else:
+                i += 1
+
+        return ParsedPatch(operations=operations, errors=errors)
+
+    def _parse_update(
+        self,
+        lines: list[str],
+        start: int,
+        path: Path,
+    ) -> tuple[PatchOperation | None, int, str | None]:
+        """Parse an update operation's search/replace block."""
+        i = start
+
+        while i < len(lines) and not self.SEARCH_START.match(lines[i].strip()):
+            i += 1
+        if i >= len(lines):
+            return None, i, f"Missing <<<<<<< SEARCH for {path}"
+        i += 1
+
+        search_lines = []
+        while i < len(lines) and not self.SEPARATOR.match(lines[i].strip()):
+            search_lines.append(lines[i])
+            i += 1
+        if i >= len(lines):
+            return None, i, f"Missing ======= separator for {path}"
+        i += 1
+
+        replace_lines = []
+        while i < len(lines) and not self.REPLACE_END.match(lines[i].strip()):
+            replace_lines.append(lines[i])
+            i += 1
+        if i >= len(lines):
+            return None, i, f"Missing >>>>>>> REPLACE for {path}"
+        i += 1
+
+        search_content = "\n".join(search_lines)
+        replace_content = "\n".join(replace_lines)
+
+        return (
+            PatchOperation(
+                action=PatchAction.UPDATE,
+                path=path,
+                content=f"{search_content}\x00{replace_content}",
+            ),
+            i,
+            None,
+        )
+
+    def _read_until_next_operation(
+        self,
+        lines: list[str],
+        start: int,
+    ) -> tuple[str, int]:
+        """Read content until the next operation directive."""
+        content_lines = []
+        i = start
+
+        while i < len(lines):
+            line = lines[i]
+            stripped = line.strip()
+
+            if (
+                self.UPDATE_FILE.match(stripped)
+                or self.CREATE_FILE.match(stripped)
+                or self.DELETE_FILE.match(stripped)
+                or self.RENAME_FILE.match(stripped)
+                or self.PATCH_END.match(stripped)
+            ):
+                break
+
+            content_lines.append(line)
+            i += 1
+
+        while content_lines and not content_lines[-1].strip():
+            content_lines.pop()
+
+        return "\n".join(content_lines), i
+
+    async def get_confirmation(
+        self,
+        invocation: ToolInvocation,
+    ) -> ToolConfirmation | None:
+        try:
+            params = ApplyPatchParams(**invocation.params)
+        except Exception:
+            return None
+
+        parsed = self._parse_patch(params.patch, invocation.cwd)
+
+        if parsed.errors:
+            return None
+
+        affected_paths = []
+        descriptions = []
+
+        for op in parsed.operations:
+            affected_paths.append(op.path)
+            if op.move_path:
+                affected_paths.append(op.move_path)
+
+            if op.action == PatchAction.CREATE:
+                descriptions.append(f"Create: {op.path}")
+            elif op.action == PatchAction.UPDATE:
+                descriptions.append(f"Update: {op.path}")
+            elif op.action == PatchAction.DELETE:
+                descriptions.append(f"Delete: {op.path}")
+            elif op.action == PatchAction.RENAME:
+                descriptions.append(f"Rename: {op.move_path} -> {op.path}")
+
+        return ToolConfirmation(
+            tool_name=self.name,
+            params=invocation.params,
+            description="\n".join(descriptions) if descriptions else "Apply patch",
+            affected_paths=affected_paths,
+            is_dangerous=any(op.action == PatchAction.DELETE for op in parsed.operations),
+        )
+
+    async def execute(self, invocation: ToolInvocation) -> ToolResult:
+        try:
+            params = ApplyPatchParams(**invocation.params)
+        except Exception as e:
+            return ToolResult.error_result(f"Invalid parameters: {e}")
+
+        parsed = self._parse_patch(params.patch, invocation.cwd)
+
+        if parsed.errors:
+            return ToolResult.error_result(
+                "Patch parsing errors:\n" + "\n".join(f"- {e}" for e in parsed.errors)
+            )
+
+        if not parsed.operations:
+            return ToolResult.error_result("No operations found in patch")
+
+        results = []
+
+        for op in parsed.operations:
+            if op.action == PatchAction.CREATE:
+                result = await self._apply_create(op, params.dry_run)
+            elif op.action == PatchAction.UPDATE:
+                result = await self._apply_update(op, params.dry_run)
+            elif op.action == PatchAction.DELETE:
+                result = await self._apply_delete(op, params.dry_run)
+            elif op.action == PatchAction.RENAME:
+                result = await self._apply_rename(op, params.dry_run)
+            else:
+                result = f"Unknown action: {op.action}"
+
+            results.append(result)
+
+        prefix = "[DRY RUN] " if params.dry_run else ""
+        return ToolResult.success_result(
+            f"{prefix}Applied patch with {len(parsed.operations)} operation(s):\n"
+            + "\n".join(f"- {r}" for r in results),
+            metadata={
+                "operations": len(parsed.operations),
+                "dry_run": params.dry_run,
+            },
+        )
+
+    async def _apply_create(self, op: PatchOperation, dry_run: bool) -> str:
+        if op.path.exists():
+            return f"SKIP: {op.path} already exists"
+
+        if not dry_run:
+            ensure_parent_directory(op.path)
+            op.path.write_text(op.content or "", encoding="utf-8")
+
+        return f"Created: {op.path}"
+
+    async def _apply_update(self, op: PatchOperation, dry_run: bool) -> str:
+        if not op.path.exists():
+            return f"ERROR: {op.path} does not exist"
+
+        if not op.content or "\x00" not in op.content:
+            return f"ERROR: Invalid update content for {op.path}"
+
+        search, replace = op.content.split("\x00", 1)
+
+        try:
+            content = op.path.read_text(encoding="utf-8")
+        except Exception:
+            return f"ERROR: Failed to read {op.path}"
+
+        if search not in content:
+            return f"ERROR: Search content not found in {op.path}"
+
+        new_content = content.replace(search, replace)
+
+        if not dry_run:
+            op.path.write_text(new_content, encoding="utf-8")
+
+        return f"Updated: {op.path}"
+
+    async def _apply_delete(self, op: PatchOperation, dry_run: bool) -> str:
+        if not op.path.exists():
+            return f"SKIP: {op.path} does not exist"
+
+        if not dry_run:
+            op.path.unlink()
+
+        return f"Deleted: {op.path}"
+
+    async def _apply_rename(self, op: PatchOperation, dry_run: bool) -> str:
+        if not op.move_path or not op.move_path.exists():
+            return f"ERROR: Source file {op.move_path} does not exist"
+
+        if op.path.exists():
+            return f"ERROR: Target file {op.path} already exists"
+
+        if not dry_run:
+            ensure_parent_directory(op.path)
+            op.move_path.rename(op.path)
+
+        return f"Renamed: {op.move_path} -> {op.path}"
+