teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/outbound/local_file_system_adapter.py

@@ -0,0 +1,300 @@
+import logging
+import os
+from pathlib import Path
+from typing import List, Sequence, TextIO
+from teddy_executor.core.domain.models.plan import DEFAULT_SIMILARITY_THRESHOLD
+from teddy_executor.core.ports.inbound.edit_simulator import EditPair, IEditSimulator
+from teddy_executor.core.ports.outbound.file_system_manager import IFileSystemManager
+from teddy_executor.core.utils.string import truncate_lines
+
+# Configure debug logging
+if os.environ.get("TEDDY_DEBUG"):
+    logging.basicConfig(level=logging.DEBUG)
+else:
+    logging.basicConfig(level=logging.INFO)
+
+from teddy_executor.core.domain.models import (
+    FileAlreadyExistsError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class LocalFileSystemAdapter(IFileSystemManager):
+    """
+    An adapter that implements file system operations on the local machine.
+    """
+
+    def __init__(
+        self,
+        edit_simulator: IEditSimulator,
+        root_dir: str = ".",
+        max_read_lines: int = 1000,
+    ):
+        self._edit_simulator = edit_simulator
+        self.root_dir = Path(root_dir)
+        self.max_read_lines = max_read_lines
+
+    def _resolve_path(self, path: str) -> Path:
+        """
+        Resolves a path relative to the root_dir.
+        """
+        path_obj = Path(path)
+        if not hasattr(self, "_resolved_root"):
+            self._resolved_root = self.root_dir.resolve()
+        if path_obj.is_absolute():
+            # Optimization: Only resolve if there are symlinks or ".." components.
+            if ".." in str(path) or path_obj.is_symlink():
+                return path_obj.resolve()
+            return path_obj
+
+        # Systemic Fix: Strictly follow project-root-relative convention.
+        # We strip leading slashes and Windows drive letters to ensure the path
+        # is always joined with our controlled root_dir.
+        clean_path = str(path).replace("\\", "/")
+
+        # Remove drive letter (e.g., C:) if present
+        if ":" in clean_path and clean_path[1] == ":":
+            clean_path = clean_path[2:]
+
+        clean_path = clean_path.lstrip("/")
+
+        # Join and resolve. This ensures we have a canonical, absolute path
+        # within our root_dir, preventing macOS resolution hangs.
+        # Optimization: Pre-resolve root_dir once
+        base = self._resolved_root
+        target = base / clean_path
+
+        # Only resolve if strictly necessary to avoid performance hits in loops
+        if ".." in clean_path or target.is_symlink():
+            return target.resolve()
+        return target
+
+    def get_context_paths(self) -> list[str]:
+        """
+        Reads all .teddy/*.context files and returns a deduplicated list of paths.
+        """
+        teddy_dir = self.root_dir / ".teddy"
+        if not teddy_dir.is_dir():
+            return []
+
+        context_files = [str(p) for p in teddy_dir.glob("*.context")]
+        return self.resolve_paths_from_files(context_files)
+
+    def resolve_paths_from_files(self, file_paths: Sequence[str]) -> list[str]:
+        """
+        Reads a list of context files and returns a deduplicated list of the paths they contain.
+        """
+        all_paths = set()
+        for path in file_paths:
+            try:
+                content = self.read_file(path)
+                for line in content.splitlines():
+                    stripped_line = line.strip()
+                    if stripped_line and not stripped_line.startswith("#"):
+                        # Skip strings with illegal filename characters on Windows/Unix
+                        if any(c in stripped_line for c in '*?"<>|'):
+                            continue
+                        all_paths.add(stripped_line)
+            except (FileNotFoundError, OSError, ValueError):
+                continue
+
+        return sorted(list(all_paths))
+
+    def list_directory(self, path: str) -> list[str]:
+        """
+        Lists the names of files and directories in the specified path.
+        """
+        dir_path = self._resolve_path(path)
+        if not dir_path.is_dir():
+            raise FileNotFoundError(f"Directory not found: {path}")
+        return [p.name for p in dir_path.iterdir()]
+
+    def list_directory_recursive(self, path: str) -> list[str]:
+        """
+        Lists all files in a directory and its subdirectories, respecting ignores.
+        """
+        from teddy_executor.adapters.outbound.filesystem_helpers import walk_recursive
+
+        dir_path = self._resolve_path(path)
+        if not dir_path.is_dir():
+            raise FileNotFoundError(f"Directory not found: {path}")
+
+        if not hasattr(self, "_resolved_root"):
+            self._resolved_root = self.root_dir.resolve()
+
+        spec = self._get_ignore_spec()
+        files = []
+
+        for entry, is_dir in walk_recursive(self._resolved_root, dir_path, spec):
+            if not is_dir and entry.is_file():
+                try:
+                    rel_path = entry.relative_to(self._resolved_root)
+                except ValueError:
+                    rel_path = entry
+                files.append(str(rel_path).replace("\\", "/"))
+
+        return sorted(files)
+
+    def _get_ignore_spec(self):
+        """Loads and caches the ignore specification."""
+        if not hasattr(self, "_ignore_spec"):
+            from teddy_executor.adapters.outbound.filesystem_helpers import (
+                load_ignore_spec,
+            )
+
+            if not hasattr(self, "_resolved_root"):
+                self._resolved_root = self.root_dir.resolve()
+
+            self._ignore_spec = load_ignore_spec(self._resolved_root)
+        return self._ignore_spec
+
+    def get_mtime(self, path: str) -> float:
+        """
+        Returns the modification time of a file or directory as a timestamp.
+        """
+        target = self._resolve_path(path)
+        return target.stat().st_mtime
+
+    def move_directory(self, old_path: str, new_path: str) -> None:
+        """
+        Moves or renames a directory.
+        """
+        import shutil
+
+        source = self._resolve_path(old_path)
+        destination = self._resolve_path(new_path)
+
+        if not source.exists():
+            raise FileNotFoundError(f"Source directory not found: {old_path}")
+        if destination.exists():
+            raise FileExistsError(f"Destination directory already exists: {new_path}")
+
+        shutil.move(str(source), str(destination))
+
+    def open_file_for_append(self, path: str) -> TextIO:
+        """
+        Opens a file for appending, creating parent directories if needed.
+        Returns a TextIO file-like object for writing.
+        """
+        file_path = self._resolve_path(path)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        return open(file_path, "a", encoding="utf-8")
+
+    def read_files_in_vault(self, paths: list[str]) -> dict[str, str | None]:
+        """
+        Reads the content of multiple files specified in a list.
+        Returns content for found files and None for files that are not found.
+        """
+        contents: dict[str, str | None] = {}
+        for path in paths:
+            try:
+                # read_file already calls _resolve_path, which joins with root_dir.
+                contents[path] = self.read_file(path)
+            except FileNotFoundError:
+                contents[path] = None  # Mark not found files with None
+        return contents
+
+    def path_exists(self, path: str) -> bool:
+        """
+        Checks if a path (file or directory) exists relative to the root_dir.
+        """
+        return self._resolve_path(path).exists()
+
+    def is_dir(self, path: str) -> bool:
+        """
+        Returns True if the path exists and is a directory.
+        """
+        return self._resolve_path(path).is_dir()
+
+    def create_directory(self, path: str) -> None:
+        """
+        Creates a directory, including any necessary parent directories.
+        Does not raise an error if the directory already exists.
+        """
+        self._resolve_path(path).mkdir(parents=True, exist_ok=True)
+
+    def write_file(self, path: str, content: str) -> None:
+        """
+        Writes content to a file, creating it if it doesn't exist
+        and overwriting it if it does.
+        """
+        self._resolve_path(path).write_text(content, encoding="utf-8")
+
+    def create_file(self, path: str, content: str, overwrite: bool = False) -> None:
+        """
+        Creates a new file with the given content.
+        """
+        try:
+            file_path = self._resolve_path(path)
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            mode = "w" if overwrite else "x"
+            with open(file_path, mode, encoding="utf-8") as f:
+                f.write(content)
+        except FileExistsError as e:
+            # Raise a domain-specific exception to conform to the port's contract.
+            raise FileAlreadyExistsError(f"File exists: {path}", file_path=path) from e
+        except IOError as e:
+            # In a real-world scenario, we might want a more specific
+            # domain exception here, but for now, this is sufficient.
+            # For example, to handle permission errors.
+            raise IOError(f"Failed to create file at {path}: {e}") from e
+
+    def read_file(self, path: str) -> str:
+        """
+        Reads the content of a file from the specified path.
+        """
+        try:
+            content = self.read_raw_file(path)
+            return truncate_lines(
+                content,
+                max_lines=self.max_read_lines,
+                direction="head",
+                action_type="read",
+            )
+        except FileNotFoundError:
+            # Re-raise to conform to the port's contract
+            raise
+        except IOError as e:
+            raise IOError(f"Failed to read file at {path}: {e}") from e
+
+    def read_raw_file(self, path: str) -> str:
+        """
+        Reads the full content of a file from the specified path.
+        """
+        try:
+            return self._resolve_path(path).read_text(encoding="utf-8")
+        except FileNotFoundError:
+            raise
+        except IOError as e:
+            raise IOError(f"Failed to read raw file at {path}: {e}") from e
+
+    def edit_file(
+        self,
+        path: str,
+        edits: list[dict[str, str]],
+        similarity_threshold: float = DEFAULT_SIMILARITY_THRESHOLD,
+        match_all: bool = False,
+    ) -> list[float]:
+        """
+        Modifies an existing file by applying a list of find-and-replace blocks.
+        """
+        file_path = self._resolve_path(path)
+        content = file_path.read_text(encoding="utf-8")
+
+        # Cast to match the port's expected EditPair structure
+        cast_edits: List[EditPair] = []
+        for e in edits:
+            pair: EditPair = {"find": e["find"], "replace": e["replace"]}
+            cast_edits.append(pair)
+
+        new_content, scores = self._edit_simulator.simulate_edits(
+            content,
+            cast_edits,
+            threshold=similarity_threshold,
+            match_all=match_all,
+        )
+
+        file_path.write_text(new_content, encoding="utf-8")
+        return scores

teddy_executor/adapters/outbound/local_repo_tree_generator.py

@@ -0,0 +1,96 @@
+import os
+from pathlib import Path
+from teddy_executor.core.ports.outbound.repo_tree_generator import IRepoTreeGenerator
+
+
+class _RecursiveListFormatter:
+    """
+    A helper class to format a set of paths into a recursive "ls -R" style list.
+    """
+
+    def __init__(self, root_dir: Path, included_paths: set[Path]):
+        self.root_dir = root_dir
+        self.included_paths = included_paths
+
+    def format(self) -> str:
+        """Generates the recursive list string."""
+        sections: list[str] = []
+        # Gather all directories that are included (including root)
+        directories = sorted(
+            [p for p in self.included_paths if p.is_dir() and not p.is_symlink()]
+            + [self.root_dir],
+            key=lambda p: str(p.relative_to(self.root_dir)).lower(),
+        )
+
+        for directory in directories:
+            section_content = self._format_section(directory)
+            if section_content:
+                sections.append(section_content)
+
+        return "\n\n".join(sections)
+
+    def _format_section(self, directory: Path) -> str:
+        """Formats a single directory section."""
+        children = sorted(
+            [p for p in directory.iterdir() if p in self.included_paths],
+            key=lambda p: p.name.lower(),
+        )
+
+        if not children:
+            return ""
+
+        lines = []
+        if directory != self.root_dir:
+            rel_path = directory.relative_to(self.root_dir)
+            # Poka-Yoke: Always use forward slashes for the tree protocol
+            posix_rel_path = str(rel_path).replace(os.sep, "/")
+            lines.append(f"./{posix_rel_path}:")
+
+        for child in children:
+            lines.append(child.name)
+
+        return "\n".join(lines)
+
+
+class LocalRepoTreeGenerator(IRepoTreeGenerator):
+    """
+    An adapter that generates a file tree for the local repository,
+    respecting .gitignore and .teddyignore rules.
+    """
+
+    def __init__(self, root_dir: str = "."):
+        from teddy_executor.adapters.outbound.filesystem_helpers import (
+            load_ignore_spec,
+        )
+
+        self.root_dir = Path(root_dir).resolve()
+        self.ignore_spec = load_ignore_spec(self.root_dir)
+
+    def _get_included_paths(self) -> set[Path]:
+        """
+        Walks the directory and returns a set of all files and parent directories
+        that are not excluded by the ignore spec.
+        """
+        from teddy_executor.adapters.outbound.filesystem_helpers import walk_recursive
+
+        included_paths: set[Path] = set()
+        for entry, _ in walk_recursive(self.root_dir, self.root_dir, self.ignore_spec):
+            # If not ignored, add to set
+            included_paths.add(entry)
+
+            # Ensure parent connectivity
+            for parent in entry.parents:
+                if parent == self.root_dir:
+                    break
+                included_paths.add(parent)
+
+        return included_paths
+
+    def generate_tree(self) -> str:
+        """
+        Generates a string representation of the file tree by gathering paths
+        and then delegating to a formatter.
+        """
+        included_paths = self._get_included_paths()
+        formatter = _RecursiveListFormatter(self.root_dir, included_paths)
+        return formatter.format()

teddy_executor/adapters/outbound/openrouter_hydrator.py

@@ -0,0 +1,89 @@
+import re
+import requests
+from typing import Any, Dict, List, Optional
+from teddy_executor.adapters.outbound.litellm_adapter import IOpenRouterHydrator
+
+
+class OpenRouterMetadataHydrator(IOpenRouterHydrator):
+    """
+    Fetches and caches model metadata from the OpenRouter API.
+    Supports suffix-stripping for versioned models.
+    """
+
+    API_URL = "https://openrouter.ai/api/v1/models"
+    TIMEOUT = 10.0
+
+    def __init__(self):
+        self._cached_models: Optional[List[Dict[str, Any]]] = None
+
+    def _fetch_models(self) -> List[Dict[str, Any]]:
+        """Fetches the live catalog from OpenRouter with a timeout."""
+        if self._cached_models is not None:
+            return self._cached_models
+
+        try:
+            # Note: In tests, the fixture will point to the local mock server
+            # if we use a relative URL or handle the base URL correctly.
+            # To allow testing, we check for an environment variable or just use the URL.
+            # However, since the test fixture provides a URL, we'll let the test
+            # pass the instance the URL or just rely on the fact that requests
+            # can be mocked at the session level if needed.
+            # For this implementation, we follow the slice requirements.
+            response = requests.get(self.API_URL, timeout=self.TIMEOUT)
+            response.raise_for_status()
+            data = response.json()
+            self._cached_models = data.get("data", [])
+            return self._cached_models or []
+        except (requests.RequestException, ValueError):
+            return []
+
+    def get_metadata(self, model_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Returns metadata for a model, stripping suffixes if necessary.
+        """
+        models = self._fetch_models()
+        if not models:
+            return None
+
+        # Strip openrouter/ prefix if present to match catalog IDs
+        clean_id = model_id.removeprefix("openrouter/")
+
+        # Strip colon-based routing shortcuts (e.g., :nitro, :floor)
+        # OpenRouter appends these to route requests; they must be removed before ID lookup.
+        clean_id = re.sub(r":[^/:]+$", "", clean_id)
+
+        # 1. Try exact match
+        metadata = self._find_model(models, clean_id)
+        if metadata:
+            return metadata
+
+        # 2. Try suffix stripping (e.g. -20240525)
+        # Matches patterns like -20240525 or -202405251230
+        stripped_id = re.sub(r"-\d{8,12}$", "", clean_id)
+        if stripped_id != clean_id:
+            metadata = self._find_model(models, stripped_id)
+            if metadata:
+                return metadata
+
+        return None
+
+    def _find_model(
+        self, models: List[Dict[str, Any]], model_id: str
+    ) -> Optional[Dict[str, Any]]:
+        """Helper to find a model in the list and format the result."""
+        for m in models:
+            if m.get("id") == model_id:
+                pricing = m.get("pricing", {})
+                try:
+                    input_cost = float(pricing.get("prompt", 0))
+                    output_cost = float(pricing.get("completion", 0))
+                except (ValueError, TypeError):
+                    return None
+                return {
+                    "context_window": m.get("context_length", 0),
+                    "pricing": {
+                        "input_cost_per_token": input_cost,
+                        "output_cost_per_token": output_cost,
+                    },
+                }
+        return None