caudate-cli 0.1.0__py3-none-any.whl

execution/tools/find_anywhere_tool.py

@@ -0,0 +1,255 @@
+"""FindAnywhere — unified filesystem search.
+
+Combines glob (filename matching), grep (content matching), and
+metadata filtering (size / mtime) into one tool. Replaces the common
+"chain three tools to find that file" pattern.
+
+Returns a ranked list of matches: each match has the file path plus
+optional snippet showing the content match (when `content` was given).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from pathlib import Path
+from typing import Any
+
+from core.schemas import ToolResult
+from execution.tools.base import BaseTool
+
+
+_DEFAULT_IGNORE_DIRS: frozenset[str] = frozenset({
+    ".git", ".hg", ".svn", "__pycache__", "node_modules", ".venv",
+    "venv", ".tox", ".mypy_cache", ".pytest_cache", "dist", "build",
+    ".cache", ".idea", ".vscode",
+})
+
+_MAX_FILE_BYTES = 5 * 1024 * 1024   # skip files >5MB for content match
+_MAX_RESULTS_DEFAULT = 50
+_DEFAULT_ROOT = "/home/raveuk/cognos"
+
+
+def _parse_age(value: str | None) -> float | None:
+    """Parse a human age string like '7d', '24h', '30m' → seconds."""
+    if not value:
+        return None
+    s = value.strip().lower()
+    if not s:
+        return None
+    try:
+        if s.endswith("d"):
+            return float(s[:-1]) * 86400
+        if s.endswith("h"):
+            return float(s[:-1]) * 3600
+        if s.endswith("m"):
+            return float(s[:-1]) * 60
+        if s.endswith("s"):
+            return float(s[:-1])
+        return float(s)   # bare seconds
+    except ValueError:
+        return None
+
+
+def _parse_size(value: str | int | None) -> int | None:
+    """Parse a size like '1MB', '50KB', '1024' → bytes."""
+    if value is None:
+        return None
+    if isinstance(value, int):
+        return value
+    s = str(value).strip().upper()
+    try:
+        if s.endswith("KB") or s.endswith("K"):
+            return int(float(s.rstrip("KB").rstrip("K")) * 1024)
+        if s.endswith("MB") or s.endswith("M"):
+            return int(float(s.rstrip("MB").rstrip("M")) * 1024 * 1024)
+        if s.endswith("GB") or s.endswith("G"):
+            return int(float(s.rstrip("GB").rstrip("G")) * 1024 * 1024 * 1024)
+        if s.endswith("B"):
+            return int(s.rstrip("B"))
+        return int(s)
+    except ValueError:
+        return None
+
+
+class FindAnywhereTool(BaseTool):
+    name = "FindAnywhere"
+    description = (
+        "Unified filesystem search: combine filename pattern (glob), "
+        "content match (regex), and metadata filters (size, age) in one "
+        "call. Returns ranked matches with optional content snippets. "
+        "Use this when you'd otherwise chain Glob + Grep + ls."
+    )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "description": (
+                        "Filename pattern (glob, e.g. '*.py', '**/main.*'). "
+                        "Optional — omit to search all files."
+                    ),
+                },
+                "content": {
+                    "type": "string",
+                    "description": (
+                        "Regex to match inside file contents. Optional. "
+                        "Files are matched if their content matches."
+                    ),
+                },
+                "path": {
+                    "type": "string",
+                    "description": (
+                        f"Root directory to search. Defaults to {_DEFAULT_ROOT}."
+                    ),
+                },
+                "ignore_case": {
+                    "type": "boolean",
+                    "description": "Case-insensitive content matching. Default true.",
+                    "default": True,
+                },
+                "max_size": {
+                    "type": "string",
+                    "description": "Skip files larger than this (e.g. '1MB', '500KB').",
+                },
+                "modified_within": {
+                    "type": "string",
+                    "description": "Only include files modified within this age (e.g. '7d', '24h').",
+                },
+                "max_results": {
+                    "type": "integer",
+                    "description": f"Cap on results (default {_MAX_RESULTS_DEFAULT}).",
+                    "default": _MAX_RESULTS_DEFAULT,
+                },
+            },
+            "required": [],
+        }
+
+    async def execute(
+        self,
+        name: str = "",
+        content: str = "",
+        path: str = _DEFAULT_ROOT,
+        ignore_case: bool = True,
+        max_size: str | None = None,
+        modified_within: str | None = None,
+        max_results: int = _MAX_RESULTS_DEFAULT,
+        **_: Any,
+    ) -> ToolResult:
+        try:
+            return self._run(
+                name_pattern=name or None,
+                content_pattern=content or None,
+                root=path or _DEFAULT_ROOT,
+                ignore_case=bool(ignore_case),
+                max_size_bytes=_parse_size(max_size),
+                modified_within_seconds=_parse_age(modified_within),
+                max_results=max(1, int(max_results)),
+            )
+        except Exception as e:
+            return ToolResult(tool_name=self.name, status="error", error=str(e))
+
+    def _run(
+        self, *,
+        name_pattern: str | None,
+        content_pattern: str | None,
+        root: str,
+        ignore_case: bool,
+        max_size_bytes: int | None,
+        modified_within_seconds: float | None,
+        max_results: int,
+    ) -> ToolResult:
+        root_path = Path(root).expanduser().resolve()
+        if not root_path.exists():
+            return ToolResult(
+                tool_name=self.name, status="error",
+                error=f"path does not exist: {root_path}",
+            )
+
+        flags = re.IGNORECASE if ignore_case else 0
+        content_re = re.compile(content_pattern, flags) if content_pattern else None
+        cutoff_mtime = (time.time() - modified_within_seconds
+                        if modified_within_seconds else None)
+
+        results: list[dict[str, Any]] = []
+        for candidate in self._walk(root_path):
+            if len(results) >= max_results:
+                break
+
+            # Filename pattern
+            if name_pattern:
+                if not candidate.match(name_pattern):
+                    continue
+
+            # Metadata
+            try:
+                stat = candidate.stat()
+            except OSError:
+                continue
+            if max_size_bytes is not None and stat.st_size > max_size_bytes:
+                continue
+            if cutoff_mtime is not None and stat.st_mtime < cutoff_mtime:
+                continue
+
+            entry: dict[str, Any] = {
+                "path": str(candidate),
+                "size_bytes": stat.st_size,
+                "modified_iso": time.strftime(
+                    "%Y-%m-%dT%H:%M:%SZ", time.gmtime(stat.st_mtime)
+                ),
+            }
+
+            # Content match
+            if content_re is not None:
+                if stat.st_size > _MAX_FILE_BYTES:
+                    continue
+                snippet = self._first_match(candidate, content_re)
+                if snippet is None:
+                    continue
+                entry["snippet"] = snippet
+            results.append(entry)
+
+        # Format human-readable output
+        if not results:
+            return ToolResult(
+                tool_name=self.name, status="success",
+                output=f"No matches under {root_path}",
+            )
+
+        lines = [f"Found {len(results)} match(es) under {root_path}:"]
+        for r in results:
+            line = f"  {r['path']}  ({r['size_bytes']}B  {r['modified_iso']})"
+            if "snippet" in r:
+                line += f"\n    > {r['snippet']}"
+            lines.append(line)
+        return ToolResult(
+            tool_name=self.name, status="success",
+            output="\n".join(lines),
+            metadata={"matches": results},
+        )
+
+    @staticmethod
+    def _walk(root: Path):
+        for dirpath, dirnames, filenames in os.walk(root):
+            # Prune ignored dirs in place
+            dirnames[:] = [d for d in dirnames if d not in _DEFAULT_IGNORE_DIRS]
+            for fn in filenames:
+                yield Path(dirpath) / fn
+
+    @staticmethod
+    def _first_match(file: Path, regex: re.Pattern) -> str | None:
+        try:
+            with file.open("r", errors="replace") as f:
+                for i, line in enumerate(f, start=1):
+                    if regex.search(line):
+                        snippet = line.rstrip()
+                        if len(snippet) > 200:
+                            snippet = snippet[:200] + "…"
+                        return f"L{i}: {snippet}"
+        except (OSError, UnicodeDecodeError):
+            return None
+        return None

execution/tools/forge_feature_tools.py

@@ -0,0 +1,377 @@
+"""Forge feature-CRUD tools — let the agent manage its own backlog mid-run.
+
+Ported from LocalForge's ``lib/agent/feature-crud-tools.ts``. Seven
+tools (list / create / update / delete / add_dependency /
+remove_dependency / set_dependencies) all scoped to whichever Forge
+project the orchestrator has bound for this session.
+
+Project binding uses a ``ContextVar`` set by ``planning/orchestrator.py``
+before it calls ``agent.chat(prompt)``. Outside of a forge session the
+context var is unset and the tools refuse — they have no business
+running in a regular chat.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Iterator
+
+from core.schemas import ToolResult
+from execution.tools.base import BaseTool
+
+logger = logging.getLogger(__name__)
+
+
+_active_project: ContextVar[int | None] = ContextVar(
+    "forge_active_project_id", default=None,
+)
+
+
+@contextmanager
+def forge_project_scope(project_id: int) -> Iterator[None]:
+    """Bind ``project_id`` for any Forge tool calls inside the block."""
+    token = _active_project.set(project_id)
+    try:
+        yield
+    finally:
+        _active_project.reset(token)
+
+
+def _current_project_id() -> int | None:
+    return _active_project.get()
+
+
+# ────────────────────────── Helpers ─────────────────────────────────
+
+
+def _assert_in_project(feature_id: int, project_id: int) -> None:
+    """Raise ValueError if feature does not belong to project."""
+    from planning.forge_models import get_feature
+    row = get_feature(feature_id)
+    if row is None:
+        raise ValueError(f"Feature {feature_id} not found")
+    if row["project_id"] != project_id:
+        raise ValueError(
+            f"Feature {feature_id} belongs to a different project"
+        )
+
+
+def _no_project_error(tool_name: str) -> ToolResult:
+    return ToolResult(
+        tool_name=tool_name, status="error",
+        error="no Forge project bound for this session — this tool is "
+              "only callable when the orchestrator runs the agent on a "
+              "feature.",
+    )
+
+
+# ────────────────────────── Tools ───────────────────────────────────
+
+
+class ForgeListFeaturesTool(BaseTool):
+    name = "forge_list_features"
+    description = (
+        "List every feature in this Forge project's backlog. Call this "
+        "FIRST so you know which features already exist, what ids they "
+        "have, and so you do not create duplicates."
+    )
+    mutates = False
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {"type": "object", "properties": {}, "required": []}
+
+    async def execute(self, **_: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            from planning.forge_models import list_features
+            rows = list_features(pid)
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+        # Slim payload — agent doesn't need acceptance_criteria etc here
+        slim = [
+            {
+                "id": r["id"],
+                "title": r["title"],
+                "description": r["description"],
+                "category": r["category"],
+                "status": r["status"],
+                "priority": r["priority"],
+                "depends_on": r.get("depends_on", []),
+            }
+            for r in rows
+        ]
+        return self._success(slim)
+
+
+class ForgeCreateFeatureTool(BaseTool):
+    name = "forge_create_feature"
+    description = (
+        "Create a new feature in this Forge project. Returns the new id; "
+        "use it with forge_add_dependency / forge_set_dependencies to wire "
+        "prerequisites."
+    )
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string", "minLength": 1, "maxLength": 200,
+                    "description": "Short imperative title.",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "What done looks like for this feature.",
+                },
+                "acceptance_criteria": {
+                    "type": "string",
+                    "description": "Bullet list of testable conditions.",
+                },
+                "category": {
+                    "type": "string", "enum": ["functional", "style"],
+                    "default": "functional",
+                },
+                "priority": {"type": "integer", "default": 0},
+                "verify_command": {"type": "string"},
+                "depends_on": {
+                    "type": "array", "items": {"type": "integer"},
+                    "description": "Optional ids of prerequisites.",
+                },
+            },
+            "required": ["title"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            from planning.forge_models import (
+                create_feature, add_dependency, get_feature,
+            )
+            fid = create_feature(
+                project_id=pid,
+                title=kwargs["title"],
+                description=kwargs.get("description"),
+                acceptance_criteria=kwargs.get("acceptance_criteria"),
+                priority=int(kwargs.get("priority", 0)),
+                category=kwargs.get("category", "functional"),
+                verify_command=kwargs.get("verify_command"),
+            )
+            linked: list[int] = []
+            skipped: list[dict[str, Any]] = []
+            for dep in (kwargs.get("depends_on") or []):
+                try:
+                    _assert_in_project(int(dep), pid)
+                    add_dependency(fid, int(dep))
+                    linked.append(int(dep))
+                except Exception as e:
+                    skipped.append({"id": int(dep), "reason": str(e)})
+            row = get_feature(fid) or {}
+            return self._success({
+                "id": fid,
+                "title": row.get("title"),
+                "linked_dependencies": linked,
+                "skipped_dependencies": skipped,
+            })
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+class ForgeUpdateFeatureTool(BaseTool):
+    name = "forge_update_feature"
+    description = (
+        "Edit fields of an existing feature in this project. Pass only the "
+        "fields you want to change."
+    )
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "id": {"type": "integer", "minimum": 1},
+                "title": {"type": "string", "minLength": 1, "maxLength": 200},
+                "description": {"type": "string"},
+                "acceptance_criteria": {"type": "string"},
+                "category": {"type": "string", "enum": ["functional", "style"]},
+                "priority": {
+                    "type": "integer",
+                    "description": "Lower = higher up in backlog. 0 = top.",
+                },
+                "verify_command": {"type": "string"},
+            },
+            "required": ["id"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            fid = int(kwargs.pop("id"))
+            _assert_in_project(fid, pid)
+            from planning.forge_models import update_feature
+            row = update_feature(fid, **kwargs)
+            if row is None:
+                return self._error(f"Feature {fid} not found.")
+            return self._success({
+                "id": row["id"], "title": row["title"],
+                "priority": row["priority"], "category": row["category"],
+                "status": row["status"],
+            })
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+class ForgeDeleteFeatureTool(BaseTool):
+    name = "forge_delete_feature"
+    description = "Remove a feature from this project's backlog."
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {"id": {"type": "integer", "minimum": 1}},
+            "required": ["id"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            fid = int(kwargs["id"])
+            _assert_in_project(fid, pid)
+            from planning.forge_models import delete_feature
+            ok = delete_feature(fid)
+            return self._success(f"Deleted feature {fid}." if ok
+                                 else f"Feature {fid} not found.")
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+class ForgeAddDependencyTool(BaseTool):
+    name = "forge_add_dependency"
+    description = (
+        "Declare that one feature depends on another. Both must belong "
+        "to this project. Rejected if it would create a cycle."
+    )
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "feature_id": {"type": "integer", "minimum": 1},
+                "depends_on_feature_id": {"type": "integer", "minimum": 1},
+            },
+            "required": ["feature_id", "depends_on_feature_id"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            fid = int(kwargs["feature_id"])
+            did = int(kwargs["depends_on_feature_id"])
+            _assert_in_project(fid, pid)
+            _assert_in_project(did, pid)
+            from planning.forge_models import add_dependency
+            add_dependency(fid, did)
+            return self._success(f"Feature {fid} now depends on {did}.")
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+class ForgeRemoveDependencyTool(BaseTool):
+    name = "forge_remove_dependency"
+    description = "Remove a dependency edge between two features."
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "feature_id": {"type": "integer", "minimum": 1},
+                "depends_on_feature_id": {"type": "integer", "minimum": 1},
+            },
+            "required": ["feature_id", "depends_on_feature_id"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            fid = int(kwargs["feature_id"])
+            did = int(kwargs["depends_on_feature_id"])
+            _assert_in_project(fid, pid)
+            from planning.forge_models import remove_dependency
+            ok = remove_dependency(fid, did)
+            return self._success(
+                f"Removed {fid} -> {did}." if ok else "No such dependency."
+            )
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+class ForgeSetDependenciesTool(BaseTool):
+    name = "forge_set_dependencies"
+    description = (
+        "Replace the full dependency list for a feature in one call. "
+        "Pass depends_on=[] to clear all dependencies."
+    )
+    mutates = True
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "feature_id": {"type": "integer", "minimum": 1},
+                "depends_on": {
+                    "type": "array", "items": {"type": "integer"},
+                },
+            },
+            "required": ["feature_id", "depends_on"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pid = _current_project_id()
+        if pid is None:
+            return _no_project_error(self.name)
+        try:
+            fid = int(kwargs["feature_id"])
+            deps = [int(x) for x in (kwargs.get("depends_on") or [])]
+            _assert_in_project(fid, pid)
+            for d in deps:
+                _assert_in_project(d, pid)
+            from planning.forge_models import set_dependencies
+            out = set_dependencies(fid, deps)
+            return self._success(out)
+        except Exception as e:
+            return self._error(f"{type(e).__name__}: {e}")
+
+
+FORGE_FEATURE_TOOLS: list[type[BaseTool]] = [
+    ForgeListFeaturesTool,
+    ForgeCreateFeatureTool,
+    ForgeUpdateFeatureTool,
+    ForgeDeleteFeatureTool,
+    ForgeAddDependencyTool,
+    ForgeRemoveDependencyTool,
+    ForgeSetDependenciesTool,
+]

execution/tools/glob_tool.py

@@ -0,0 +1,59 @@
+"""Glob tool — find files by glob pattern."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from core.schemas import ToolResult
+from execution.tools.base import BaseTool
+
+
+class GlobTool(BaseTool):
+    name = "Glob"
+    description = (
+        "Find files matching a glob pattern (e.g. '**/*.py', 'src/**/*.ts'). "
+        "Returns a newline-separated list of paths, sorted by modification time."
+    )
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "Glob pattern, e.g. '**/*.py'",
+                },
+                "path": {
+                    "type": "string",
+                    "description": "Root directory to search in. Defaults to cwd.",
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Maximum results (default 200)",
+                    "default": 200,
+                },
+            },
+            "required": ["pattern"],
+        }
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        pattern = kwargs.get("pattern", "")
+        if not pattern:
+            return self._error("No pattern provided")
+
+        root = Path(kwargs.get("path") or ".").resolve()
+        limit = int(kwargs.get("limit", 200))
+
+        try:
+            matches = [p for p in root.glob(pattern) if p.is_file()]
+        except Exception as e:
+            return self._error(str(e))
+
+        if not matches:
+            return self._success(f"No matches for {pattern} in {root}")
+
+        matches.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+        matches = matches[:limit]
+        return self._success("\n".join(str(p) for p in matches))