teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/validation_rules/edit_matcher.py

@@ -0,0 +1,247 @@
+"""
+Heuristic matching logic for the EDIT action validator.
+"""
+
+import difflib
+import os
+import time
+from typing import List, Set
+
+from teddy_executor.core.domain.models.plan import DEFAULT_SIMILARITY_THRESHOLD
+from teddy_executor.core.services.validation_rules.edit_matcher_heuristics import (
+    gather_candidate_starts,
+)
+
+# Performance Heuristic Constants
+LARGE_BLOCK_LINE_LIMIT = 20
+SUB_SAMPLE_RATIO_THRESHOLD = 0.7
+SUB_SAMPLE_PASS_THRESHOLD = 0.7
+CANDIDATE_EVALUATION_CAP = 5
+
+
+def find_best_match(
+    file_content: str,
+    find_block: str,
+    threshold: float = DEFAULT_SIMILARITY_THRESHOLD,
+) -> tuple[str, float, bool, int]:
+    """
+    Finds the most similar block of text in the file content.
+
+    Returns:
+        tuple[str, float, bool, int]: (best_match_string, best_score, is_ambiguous, offset)
+    """
+    file_lines = file_content.splitlines(keepends=True)
+    find_lines = find_block.splitlines(keepends=True)
+    num_find_lines = len(find_lines)
+
+    if not file_lines or not find_lines:
+        return "", 0.0, False, 0
+
+    # If the file is smaller than the find block, just compare against the whole file
+    if len(file_lines) < num_find_lines:
+        matcher = difflib.SequenceMatcher(None, find_lines, file_lines)
+        score = matcher.ratio()
+        return "".join(file_lines), round(score, 2), False, 0
+
+    candidate_starts = gather_candidate_starts(file_lines, find_lines, threshold)
+    best_match_lines, score, is_ambiguous, offset = _evaluate_candidates(
+        file_lines, find_lines, candidate_starts, find_block
+    )
+
+    return "".join(best_match_lines), round(score, 2), is_ambiguous, offset
+
+
+def find_best_match_and_diff(
+    file_content: str,
+    find_block: str,
+    threshold: float = DEFAULT_SIMILARITY_THRESHOLD,
+) -> tuple[str, float, bool, int]:
+    """
+    Finds the most similar block of text in the file content and generates a diff.
+    Uses character-level ndiff (with ? markers) for fuzzy matches.
+
+    Returns:
+        tuple[str, float, bool, int]: (diff_text, best_score, is_ambiguous, offset)
+    """
+    debug = os.environ.get("TEDDY_DEBUG")
+    start_total = time.perf_counter()
+
+    best_match_str, score, is_ambiguous, offset = find_best_match(
+        file_content, find_block, threshold
+    )
+
+    res = ""
+    if best_match_str and not is_ambiguous:
+        # Generate character-level diff only for non-perfect matches
+        # Note: score is already rounded to 2 decimal places by find_best_match
+        if 0 < score < 1.0:
+            find_lines = find_block.splitlines(keepends=True)
+            match_lines = best_match_str.splitlines(keepends=True)
+            # ndiff provides the '?' lines for intra-line changes
+            diff = difflib.ndiff(find_lines, match_lines)
+            res = "\n".join(line.rstrip("\n\r") for line in diff)
+
+        if debug:
+            print("--- MATCHER PROFILING ---")
+            print(f"Total:  {time.perf_counter() - start_total:.4f}s")
+            print("-------------------------")
+
+    return res, score, is_ambiguous, offset
+
+
+def _evaluate_candidates(
+    file_lines: List[str],
+    find_lines: List[str],
+    candidate_starts: Set[int],
+    find_block: str,
+) -> tuple[List[str], float, bool, int]:
+    """Evaluates candidates using difflib ratio, with sub-sampling and priority capping."""
+    num_find_lines = len(find_lines)
+    scored_candidates = []
+
+    for start in candidate_starts:
+        window = file_lines[start : start + num_find_lines]
+        if num_find_lines > LARGE_BLOCK_LINE_LIMIT:
+            score = _calculate_sub_sample_score(window, find_lines)
+            if score >= SUB_SAMPLE_PASS_THRESHOLD:
+                scored_candidates.append((score, window))
+        else:
+            window_str = "".join(window)
+            matcher = difflib.SequenceMatcher(None, window_str, find_block)
+            score = matcher.ratio()
+            scored_candidates.append((score, window))
+
+    # Sort by score descending and cap evaluation
+    scored_candidates.sort(key=lambda x: x[0], reverse=True)
+    candidates_to_refine = scored_candidates[:CANDIDATE_EVALUATION_CAP]
+
+    # FALLBACK: pick first block if no candidates found
+    if not candidates_to_refine and file_lines:
+        candidates_to_refine = [(0.0, file_lines[:num_find_lines])]
+
+    return _refine_and_select_best(
+        candidates_to_refine, find_lines, num_find_lines, find_block
+    )
+
+
+def _refine_and_select_best(
+    candidates: List[tuple[float, List[str]]],
+    find_lines: List[str],
+    num_find_lines: int,
+    find_block: str,
+) -> tuple[List[str], float, bool, int]:
+    """Refines top candidates and returns the best match with ambiguity info."""
+    best_ratio = -1.0
+    best_match_lines: List[str] = []
+    is_ambiguous = False
+    best_offset = 0
+    ratio_calls = 0
+
+    for score, window in candidates:
+        if num_find_lines > LARGE_BLOCK_LINE_LIMIT:
+            matcher = difflib.SequenceMatcher(None, window, find_lines)
+            ratio = matcher.ratio()
+        else:
+            ratio = score
+
+        # Whitespace Indifference Bonus & Indentation Offset
+        ratio, current_offset = _apply_indentation_bonus(window, find_block, ratio)
+
+        current_match_lines, ratio, current_is_ambiguous = _apply_substring_boost(
+            window, find_lines, ratio
+        )
+
+        ratio_calls += 1
+        if ratio > best_ratio:
+            best_ratio = ratio
+            best_match_lines = current_match_lines
+            is_ambiguous = current_is_ambiguous
+            best_offset = current_offset
+        elif ratio == best_ratio and ratio > 0:
+            is_ambiguous = True
+
+    if os.environ.get("TEDDY_DEBUG"):
+        print(f"Top Candidates Refined: {len(candidates)}")
+        print(f"Ratio Calls: {ratio_calls}")
+
+    return best_match_lines, best_ratio, is_ambiguous, best_offset
+
+
+def _apply_indentation_bonus(
+    window: List[str], find_block: str, current_ratio: float
+) -> tuple[float, int]:
+    """
+    Applies 1.0 score boost if window matches find_block logic exactly,
+    ignoring trailing whitespace and constant relative indentation.
+    """
+    ratio = current_ratio
+    offset = 0
+    if ratio >= 1.0:
+        return ratio, offset
+
+    w_lines = [line.rstrip() for line in window]
+    f_lines = [line.rstrip() for line in find_block.splitlines(keepends=True)]
+
+    if len(w_lines) != len(f_lines):
+        return ratio, offset
+
+    offsets = []
+    for w_line, f_line in zip(w_lines, f_lines):
+        w_stripped = w_line.lstrip()
+        f_stripped = f_line.lstrip()
+        if w_stripped != f_stripped:
+            return ratio, offset
+        if w_stripped:  # Only calculate offset for non-empty lines
+            offsets.append(
+                len(w_line) - len(w_stripped) - (len(f_line) - len(f_stripped))
+            )
+
+    if offsets and len(set(offsets)) == 1:
+        ratio = 1.0
+        offset = offsets[0]
+
+    return ratio, offset
+
+
+def _apply_substring_boost(
+    window: List[str], find_lines: List[str], current_ratio: float
+) -> tuple[List[str], float, bool]:
+    """
+    Applies Substring Boost: If a single-line block matches a substring exactly,
+    ratio is 1.0. This handles surgical intra-line replacements.
+    """
+    ratio = current_ratio
+    match_lines = window
+    is_ambiguous = False
+
+    if ratio < 1.0 and len(find_lines) == 1:
+        find_text = find_lines[0].rstrip("\n\r")
+        if find_text and find_text in window[0]:
+            match_count = window[0].count(find_text)
+            ratio = 1.0
+            match_lines = [find_text]
+            if match_count > 1:
+                # Intra-line ambiguity detected
+                is_ambiguous = True
+
+    return match_lines, ratio, is_ambiguous
+
+
+def _calculate_sub_sample_score(window: List[str], find_lines: List[str]) -> float:
+    """
+    Calculates a lightning-fast similarity score for large blocks.
+    Uses simple string equality on a sub-sample of lines to avoid the
+    overhead of difflib.SequenceMatcher.quick_ratio() during the filter phase.
+    """
+    num_find_lines = len(find_lines)
+    sub_sample_matches = 0
+    total_checks = 0
+    # Check up to 10 representative lines distributed across the block.
+    step = max(1, num_find_lines // 10)
+    for k in range(0, num_find_lines, step):
+        total_checks += 1
+        # Simple equality is O(N) where N is line length, much faster than quick_ratio
+        if window[k].strip() == find_lines[k].strip():
+            sub_sample_matches += 1
+
+    return sub_sample_matches / total_checks

teddy_executor/core/services/validation_rules/edit_matcher_heuristics.py

@@ -0,0 +1,84 @@
+"""
+Tiered heuristic search for candidate window start positions in EditMatcher.
+"""
+
+import difflib
+from collections import defaultdict
+from typing import List, Set
+
+
+def gather_candidate_starts(
+    file_lines: List[str], find_lines: List[str], threshold: float
+) -> Set[int]:
+    """Orchestrates tiered heuristic search for candidate window start positions."""
+    num_find_lines = len(find_lines)
+
+    # Tier 1: Exact Priority Anchors
+    candidate_starts = _find_starts_by_anchors(file_lines, find_lines)
+
+    # Tier 2: Incremental Fuzzy Cascade (Fallback)
+    if not candidate_starts:
+        candidate_starts = _find_starts_by_fuzzy_cascade(
+            file_lines, num_find_lines, find_lines[0], threshold
+        )
+
+    # Tier 3: Substring Fallback (For single-word or intra-line matches)
+    if not candidate_starts and num_find_lines == 1:
+        find_text = find_lines[0].strip()
+        for i, line in enumerate(file_lines):
+            if find_text in line:
+                candidate_starts.add(i)
+
+    # Tier 4: Exhaustive Fallback
+    if not candidate_starts:
+        candidate_starts = set(range(len(file_lines) - num_find_lines + 1))
+
+    return candidate_starts
+
+
+def _find_starts_by_anchors(file_lines: List[str], find_lines: List[str]) -> Set[int]:
+    """Tier 1: Find candidate windows by matching the longest unique 'anchor' lines."""
+    num_find_lines = len(find_lines)
+    priority_lines = sorted(
+        [(line.strip(), i) for i, line in enumerate(find_lines) if line.strip()],
+        key=lambda x: len(x[0]),
+        reverse=True,
+    )[:5]
+
+    file_line_map = defaultdict(list)
+    for i, line in enumerate(file_lines):
+        trimmed = line.strip()
+        if trimmed:
+            file_line_map[trimmed].append(i)
+
+    candidate_starts: Set[int] = set()
+    for trimmed, find_idx in priority_lines:
+        if trimmed in file_line_map:
+            for file_idx in file_line_map[trimmed]:
+                start = file_idx - find_idx
+                if 0 <= start <= len(file_lines) - num_find_lines:
+                    candidate_starts.add(start)
+    return candidate_starts
+
+
+def _find_starts_by_fuzzy_cascade(
+    file_lines: List[str],
+    num_find_lines: int,
+    first_find_line_raw: str,
+    threshold: float,
+) -> Set[int]:
+    """
+    Tier 2: Find candidate windows by fuzzy matching the first line of the block.
+    Uses real_quick_ratio as a fast pre-filter before checking quick_ratio.
+    """
+    candidate_starts: Set[int] = set()
+    first_find_line = first_find_line_raw.strip()
+    for i, f_line in enumerate(file_lines):
+        f_line_stripped = f_line.strip()
+        # Pre-filter with real_quick_ratio which is O(N+M) and very fast
+        matcher = difflib.SequenceMatcher(None, f_line_stripped, first_find_line)
+        if matcher.real_quick_ratio() >= threshold:
+            if matcher.quick_ratio() >= threshold:
+                if 0 <= i <= len(file_lines) - num_find_lines:
+                    candidate_starts.add(i)
+    return candidate_starts

teddy_executor/core/services/validation_rules/execute.py

@@ -0,0 +1,37 @@
+"""
+Validation rules for the 'EXECUTE' action.
+"""
+
+from typing import Optional
+
+from teddy_executor.core.domain.models.plan import ActionData, ValidationError
+from teddy_executor.core.services.validation_rules.helpers import (
+    BaseActionValidator,
+    ContextPaths,
+    ValidationResult,
+)
+
+
+class ExecuteActionValidator(BaseActionValidator):
+    """Checks for command content and valid working directory."""
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        cmd_text = action.params.get("command", "").strip()
+        errors: ValidationResult = []
+
+        _, path_errs = self._get_validated_path(action, ["cwd"], "EXECUTE")
+        errors.extend(path_errs)
+
+        if not cmd_text:
+            errors.append(
+                ValidationError(message="EXECUTE action must contain a command")
+            )
+
+        return errors
+
+
+# Removed legacy functional validation rule in favor of ExecuteActionValidator class.

teddy_executor/core/services/validation_rules/filesystem.py

@@ -0,0 +1,73 @@
+"""
+Consolidated validation rules for filesystem-related actions (CREATE, READ, PRUNE).
+"""
+
+from typing import Optional
+
+from teddy_executor.core.domain.models.plan import ActionData, ValidationError
+from teddy_executor.core.services.validation_rules.helpers import (
+    BaseActionValidator,
+    ContextPaths,
+    ValidationResult,
+)
+
+
+class CreateActionValidator(BaseActionValidator):
+    """Handles validation for the 'CREATE' action."""
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        """Performs pre-flight checks for CREATE."""
+        target_path, validation_errs = self._get_validated_path(
+            action, ["path"], "CREATE"
+        )
+        if validation_errs:
+            return validation_errs
+
+        if target_path and self._file_system_manager.path_exists(target_path):
+            if not action.params.get("overwrite"):
+                return [
+                    ValidationError(
+                        message=(
+                            f"File already exists: {target_path}. **Hint:** The 'Overwrite: true' "
+                            "parameter can be used with caution to bypass this."
+                        ),
+                        file_path=target_path,
+                        offending_node=action.node,
+                    )
+                ]
+        return []
+
+
+class ReadActionValidator(BaseActionValidator):
+    """Handles validation for the 'READ' action."""
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        """Performs pre-flight checks for READ."""
+        src_resource, read_errors = self._get_validated_path(
+            action, ["resource"], "READ"
+        )
+        if read_errors:
+            return read_errors
+
+        if (
+            isinstance(src_resource, str)
+            and not src_resource.startswith("http://")
+            and not src_resource.startswith("https://")
+        ):
+            if not self._file_system_manager.path_exists(src_resource):
+                return [
+                    ValidationError(
+                        message=f"File to read does not exist: {src_resource}",
+                        file_path=src_resource,
+                        offending_node=action.node,
+                    )
+                ]
+        return read_errors

teddy_executor/core/services/validation_rules/helpers.py

@@ -0,0 +1,178 @@
+"""
+Shared helper classes and functions for validation rules.
+"""
+
+import os
+from pathlib import Path
+from abc import ABC
+from typing import Dict, List, Optional, Protocol, Sequence
+
+from teddy_executor.core.domain.models.plan import (
+    DEFAULT_SIMILARITY_THRESHOLD,
+    ActionData,
+    ValidationError,
+)
+from teddy_executor.core.ports.outbound import IConfigService, IFileSystemManager
+
+ContextPaths = Dict[str, Sequence[str]]
+ValidationResult = List[ValidationError]
+
+
+class IActionValidator(Protocol):
+    """
+    Protocol for an action-specific validation rule.
+    """
+
+    def can_validate(self, action_type: str) -> bool:
+        """Returns True if this validator can handle the given action type."""
+        ...
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        """Validates the given action."""
+        ...
+
+
+class BaseActionValidator(ABC, IActionValidator):
+    """Base class for action validators to reduce boilerplate."""
+
+    def __init__(self, file_system_manager: IFileSystemManager):
+        self._file_system_manager = file_system_manager
+
+    def can_validate(self, action_type: str) -> bool:
+        # This assumes the class name follows the pattern [ActionType]ActionValidator
+        expected_prefix = self.__class__.__name__.replace("ActionValidator", "").lower()
+        return action_type.lower() == expected_prefix
+
+    def _validate_alias_url_restriction(
+        self, action: ActionData, param_name: str = "resource"
+    ) -> ValidationResult:
+        """Ensures 'File Path' alias doesn't point to a URL."""
+        path_str = action.params.get(param_name)
+        used_alias = action.params.get("metadata_used_file_path_alias", False)
+
+        if (
+            used_alias
+            and isinstance(path_str, str)
+            and (path_str.startswith("http://") or path_str.startswith("https://"))
+        ):
+            return [
+                ValidationError(
+                    message="Strict Local Only: 'File Path' alias does not support URLs",
+                    file_path=path_str,
+                    offending_node=action.node,
+                )
+            ]
+        return []
+
+    def _get_validated_path(
+        self, action: ActionData, param_names: List[str], action_type: str
+    ) -> tuple[Optional[str], ValidationResult]:
+        """Extracts and validates a path from action parameters."""
+        path_str = None
+        primary_param = param_names[0] if param_names else "resource"
+        for name in param_names:
+            if val := action.params.get(name):
+                path_str = val
+                break
+
+        if not isinstance(path_str, str):
+            return None, []
+
+        errors = self._validate_alias_url_restriction(action, param_name=primary_param)
+        if not errors:
+            try:
+                validate_path_is_safe(path_str, action_type)
+            except PlanValidationError as e:
+                errors.append(
+                    ValidationError(
+                        message=e.message,
+                        file_path=e.file_path,
+                        offending_node=action.node,
+                    )
+                )
+
+        return path_str, errors
+
+
+class PlanValidationError(Exception):
+    """Custom exception for plan validation errors."""
+
+    def __init__(self, message: str, file_path: Optional[str] = None):
+        super().__init__(message)
+        self.message = message
+        self.file_path = file_path
+
+
+def validate_path_is_safe(path_str: str, action_type: str):
+    """
+    Ensures a file path is safe by checking for absolute paths and
+    directory traversal attempts.
+    """
+    if os.path.isabs(path_str):
+        raise PlanValidationError(
+            f"Action `{action_type}` contains an absolute path, which is not allowed: {path_str}"
+        )
+    if ".." in Path(path_str).parts:
+        raise PlanValidationError(
+            f"Action `{action_type}` contains a directory traversal attempt ('..'), which is not allowed: {path_str}"
+        )
+
+
+def resolve_similarity_threshold(
+    config_service: IConfigService, action_params: dict
+) -> float:
+    """
+    Centralized resolution logic for the similarity threshold.
+    Resolves in order: Action Params -> Global Config -> Domain Default.
+    """
+    global_threshold_raw = config_service.get_setting(
+        "execution.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
+    )
+    global_threshold = (
+        float(global_threshold_raw)
+        if global_threshold_raw is not None
+        else DEFAULT_SIMILARITY_THRESHOLD
+    )
+
+    threshold_raw = action_params.get(
+        "execution.similarity_threshold", global_threshold
+    )
+    return float(threshold_raw) if threshold_raw is not None else global_threshold
+
+
+def is_path_in_context(
+    path_str: str,
+    context_paths: Optional[Dict[str, Sequence[str]]],
+    check_session: bool = True,
+    check_turn: bool = True,
+) -> bool:
+    """
+    Checks if a path (normalized) is present in the specified context scopes.
+    Normalizes both target and context paths to use forward slashes.
+    """
+    if not context_paths or not path_str:
+        return False
+
+    scopes = []
+    if check_session:
+        scopes.append("Session")
+    if check_turn:
+        scopes.append("Turn")
+
+    # Normalize target: convert backslashes BEFORE removing leading slash/dot-slash
+    normalized_target = path_str.replace("\\", "/").removeprefix("./").lstrip("/")
+
+    for scope in scopes:
+        context_files = context_paths.get(scope, [])
+        # Normalize context: convert backslashes BEFORE removing leading slash/dot-slash
+        normalized_context = [
+            p.replace("\\", "/").removeprefix("./").lstrip("/") for p in context_files
+        ]
+        if normalized_target in normalized_context:
+            return True
+
+    return False

teddy_executor/core/services/validation_rules/message.py

@@ -0,0 +1,29 @@
+from typing import Optional
+
+from teddy_executor.core.domain.models.plan import ActionData, ValidationError
+from teddy_executor.core.services.validation_rules.helpers import (
+    BaseActionValidator,
+    ContextPaths,
+    ValidationResult,
+)
+
+
+class MessageActionValidator(BaseActionValidator):
+    """
+    Validates MESSAGE actions.
+    """
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        content = action.params.get("content")
+        if not content or not isinstance(content, str) or not content.strip():
+            return [
+                ValidationError(
+                    message="MESSAGE action must have non-empty content.",
+                    offending_node=action.node,
+                )
+            ]
+        return []

teddy_executor/core/utils/__init__.py

@@ -0,0 +1 @@
+# Init for core utils