teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/templates/execution_report.md.j2

@@ -0,0 +1,290 @@
+{#
+  Unified template for the concise Markdown report.
+  Renders both execution outcomes and pre-flight validation failures.
+
+  NOTE ON WHITESPACE CONTROL:
+  This template uses manual whitespace control (`-%}`) on blocks that are
+  followed by blank lines. The Jinja2 `trim_blocks=True` setting only
+  removes the *first* newline after a tag, not subsequent blank lines.
+  The manual control is necessary to prevent extra newlines in the final
+  rendered output when conditional sections are not rendered.
+#}
+{% macro render_resource(path, content) %}
+{% if path.startswith('http:') or path.startswith('https:') %}
+### [{{ path }}]({{ path }})
+{% else %}
+### [{{ path }}]({% if not path.startswith('/') %}/{% endif %}{{ path }})
+{% endif %}
+{{ content | fence }}{{ path | language_from_path }}
+{{ content }}
+{{ content | fence }}
+{% endmacro %}
+
+{% macro render_action_details(log) %}
+{# Handle MESSAGE actions first: render content in a fenced codeblock #}
+{% if log.action_type.upper() == 'MESSAGE' and log.details %}
+{% if log.details is mapping and log.details.get('content') %}
+- **User Reply:**
+{{ log.details.content | trim | fence }}
+{{ log.details.content | trim }}
+{{ log.details.content | trim | fence }}
+{% else %}
+- **User Reply:**
+{{ log.details | trim | fence }}
+{{ log.details | trim }}
+{{ log.details | trim | fence }}
+{% endif %}
+
+{% elif log.details -%}
+{% if log.details is mapping -%}
+{% if log.details.get("error") -%}
+- **Error:** {{ log.details.error }}
+{% endif -%}
+{% if log.details.get("original_details") -%}
+- **Error:** {{ log.details.original_details }}
+{% endif -%}
+{% if log.details.get("return_code") is not none -%}
+- **Return Code:** `{{ log.details.return_code }}`
+{% endif -%}
+{% if log.details.get("failed_command") -%}
+- **Failed Command:** `{{ log.details.failed_command }}`
+{% endif -%}
+{% if log.details.get("similarity_scores") -%}
+{% set scores_list = log.details.get("similarity_scores") -%}
+{% if scores_list | length == 1 -%}
+- **Similarity Score:** {{ "%.2f" | format(scores_list[0]) }}
+{% else -%}
+- **Similarity Scores:** {% for s in scores_list %}{{ "%.2f" | format(s) }}{% if not loop.last %}, {% endif %}{% endfor %}
+{% endif %}
+
+{% elif log.details.get("similarity_score") is not none -%}
+- **Similarity Score:** {{ "%.2f" | format(log.details.get("similarity_score")) }}
+
+{% endif -%}
+{% if log.details.get("stdout") -%}
+#### `stdout`
+{{ log.details.stdout | trim | fence }}text
+{{ log.details.stdout | trim }}
+{{ log.details.stdout | trim | fence }}
+
+{% endif -%}
+{% if log.details.get("stderr") -%}
+#### `stderr`
+{{ log.details.stderr | trim | fence }}text
+{{ log.details.stderr | trim }}
+{{ log.details.stderr | trim | fence }}
+
+{% endif -%}
+{% if log.details.get("diff") -%}
+#### `diff`
+{{ log.details.diff | trim | fence }}diff
+{{ log.details.diff | trim }}
+{{ log.details.diff | trim | fence }}
+
+{% endif -%}
+{# Render generic details if no specific fields matched, but avoid rendering if it's just content #}
+{% if not log.details.get("error") and not log.details.get("return_code") and not log.details.get("stdout") and not log.details.get("stderr") and not log.details.get("content") and not log.details.get("diff") and not log.details.get("failed_command") and not log.details.get("similarity_scores") and not log.details.get("similarity_score") and not log.details.get("query_results") %}
+- **Details:** `{{ log.details }}`
+{% endif -%}
+{% else -%}
+- **Details:** `{{ log.details }}`
+{% endif -%}
+{% endif %}
+{% endmacro -%}
+
+{% macro render_header(report) -%}
+# Execution Report: {{ report.plan_title | default('Untitled Plan') }}
+{% set status_val = report.run_summary.status.value | default(report.run_summary.status) -%}
+- **Overall Status:** {{ "Validation Failed" if status_val == "VALIDATION_FAILED" else status_val }}
+- **Execution Start Time:** {{ format_datetime(report.run_summary.start_time) }}
+- **Execution End Time:** {{ format_datetime(report.run_summary.end_time) }}
+{%- endmacro %}
+
+
+{{ render_header(report) }}
+
+{% if report.validation_result -%}
+## Validation Errors:
+{% for error in report.validation_result -%}
+{{ error | trim }}
+{% if not loop.last %}
+
+---
+
+{% endif %}
+{% endfor %}
+{% endif -%}
+
+{% if report.validation_ast -%}
+{{ report.validation_ast }}
+{% endif -%}
+{% if report.failed_resources and not is_session %}
+
+## Resource Contents
+{% for path, content in report.failed_resources.items() %}
+{{ render_resource(path, content) }}
+{% endfor %}
+{%- endif %}
+{% if report.user_request %}
+
+## User Request
+{{ report.user_request | fence }}text
+{{ report.user_request }}
+{{ report.user_request | fence }}
+{% endif %}
+
+{# Extract logs that should display resource content #}
+{% set report_ns = namespace(content_logs=[]) %}
+{% for log in report.action_logs %}
+  {% if log.details and log.details is mapping and log.details.get('content') %}
+    {# Always include content for failed actions or successful READ actions (unless in a session). #}
+    {% set is_read = log.action_type.lower() == 'read' %}
+    {% set is_success = log.status.value == 'SUCCESS' %}
+    {% set is_failure = log.status.value == 'FAILURE' %}
+
+    {% if is_failure or (is_read and is_success) %}
+      {% set report_ns.content_logs = report_ns.content_logs + [log] %}
+    {% endif %}
+  {% endif %}
+{% endfor -%}
+
+{% if report_ns.content_logs and not is_session %}
+## Resource Contents
+{% for log in report_ns.content_logs %}
+{% set res_path = log.params.get('File Path') or log.params.get('Resource') or log.params.get('resource') or log.params.get('path') %}
+{{ render_resource(res_path, log.details.content) }}
+{% endfor %}
+{% endif -%}
+## Action Log
+{% for log in report.action_logs %}
+{% set action_type = log.action_type.upper() %}
+{% set params = log.params or {} %}
+{% set target = '' %}
+
+{# Determine Header Target #}
+{% if action_type == 'EXECUTE' %}
+  {% set target = '"' ~ (params.get('description') or params.get('Description') or 'Execute Command') ~ '"' %}
+{% elif action_type == 'RESEARCH' %}
+  {% set target = params.get('description') or params.get('Description') or 'Research' %}
+{% else %}
+  {# Use Markdown Link for CREATE/EDIT/READ #}
+  {% set full_path = params.get('File Path') or params.get('file_path') or params.get('Resource') or params.get('resource') or params.get('path') or '' %}
+  {# Check for URL schemes http and https #}
+  {% if full_path.startswith('http:') or full_path.startswith('https:') %}
+    {% set target = '[' ~ full_path ~ '](' ~ full_path ~ ')' %}
+  {% else %}
+    {% set target = '[' ~ (full_path | basename) ~ '](' ~ ('/' ~ full_path if not full_path.startswith('/') else full_path) ~ ')' %}
+  {% endif %}
+{% endif %}
+
+{% if log.modified_fields -%}
+  {% set modified_tag = " (user modified: " ~ (log.modified_fields | join(', ')) ~ ")" -%}
+{% elif log.modified -%}
+  {% set modified_tag = " (modified)" -%}
+{% else -%}
+  {% set modified_tag = "" -%}
+{% endif -%}
+{% if target %}
+### `{{ action_type }}`{{ modified_tag }}: {{ target }}
+{% else -%}
+### `{{ action_type }}`{{ modified_tag }}
+{% endif -%}
+{% set log_status = log.status.value | default(log.status) -%}
+- **Status:** {{ log_status }}
+{% if action_type == 'READ' and not params.get('lines') %}
+- **Note:** Up-to-date contents are provided under `Resource Contents`.
+{% endif %}
+{% if action_type in ['CREATE', 'EDIT'] -%}
+  {% set path_val = params.get('File Path') or params.get('file_path') or params.get('path') -%}
+  {% if path_val -%}
+- **File Path:** `{{ path_val }}`
+  {%- endif %}
+{%- endif %}
+{# Params Rendering - Flattened #}
+{% if action_type == 'EXECUTE' %}
+  {% set outcome = params.get('expected_outcome') or params.get('Expected Outcome') %}
+  {% if outcome %}
+- **Expected outcome:** {{ outcome }}
+  {% endif %}
+
+  {% set setup = params.get('setup') or params.get('Setup') %}
+  {% if setup %}
+- **Setup:** `{{ setup }}`
+  {% endif %}
+
+  {% set allow_failure = params.get('allow_failure') or params.get('Allow Failure') %}
+  {% if allow_failure is not none %}
+- **Allow Failure:** `{{ allow_failure | lower }}`
+  {% endif %}
+
+  {% set cmd = params.get('command') or params.get('cmd') %}
+  {% if cmd %}
+
+- **Command:** {% if '\n' in cmd %}
+{{ '\n' }}{{ cmd | fence }}shell
+{{ cmd }}
+{{ cmd | fence }}
+{% else %}`{{ cmd }}`{% endif %}
+  {% endif %}
+
+{% else %}
+{# Generic Params for CREATE, EDIT, READ, RESEARCH etc #}
+{% if params %}
+  {# Use namespace for persistent ignored_keys across if-blocks #}
+  {% set param_ns = namespace(ignored=['content', 'find', 'replace', 'edits', 'similarity_scores', 'similarity_score', 'similarity threshold', 'similarity_threshold', 'metadata used file path alias']) %}
+
+  {% if action_type in ['EXECUTE', 'RESEARCH'] %}
+    {% set param_ns.ignored = param_ns.ignored + ['description', 'Description'] %}
+  {% endif %}
+  {% if action_type == 'RESEARCH' %}
+    {% set param_ns.ignored = param_ns.ignored + ['queries'] %}
+  {% endif %}
+
+  {% for key, value in params.items() %}
+    {% set k_lower = key.lower() %}
+    {% if k_lower not in param_ns.ignored %}
+      {# Normalize key to Title Case #}
+      {% set display_key = key.replace('_', ' ').title() %}
+      {# Map plumbing keys back to human readable names for display #}
+      {% if k_lower == 'similarity_threshold' %}{% set display_key = 'Similarity Threshold' %}{% endif %}
+      {% if k_lower == 'match_all' %}{% set display_key = 'Match All' %}{% endif %}
+      {# Skip path params in body since they are in header #}
+      {% if k_lower not in ['file path', 'file_path', 'resource', 'path'] %}
+- **{{ display_key }}:** {{ value }}
+      {% endif %}
+    {% endif %}
+  {% endfor %}
+{% endif %}
+{% endif %}
+
+{% if action_type == 'RESEARCH' and log.details and log.details is mapping and log.details.get('query_results') %}
+{% for qr in log.details.get('query_results', []) %}
+
+#### Query: "{{ qr['query'] }}"
+{% for sr in qr['results'] %}
+{{ loop.index }}. `{{ sr['href'] }}`
+   - **Title:** {{ sr['title'] }}
+   - **Description:** {{ sr['description'] }}
+{% endfor %}
+{% endfor %}
+
+_**Hint:** NOW you MUST use READ on the most promising results)_
+{% endif %}
+
+{% if action_type == 'READ' and log.details and log.details is mapping and log.details.get('content') and params.get('lines') %}
+{{ log.details.content | trim | fence }}
+{{ log.details.content | trim }}
+{{ log.details.content | trim | fence }}
+{% endif %}
+
+{{ render_action_details(log) }}
+{% else %}
+*(No actions were executed.)*
+{% endfor %}
+{% if report.validation_result %}
+
+## Validation Recovery
+1. Identify the root cause of the failure based on your system instructions (MRP) & context.
+2. Submit a corrected plan focusing strictly on the failed/problematic action(s).
+3. Defer the remaining steps of the original plan to subsequent turns.
+{% endif %}

teddy_executor/core/services/validation_rules/__init__.py

@@ -0,0 +1,4 @@
+"""
+This package contains the specific validation rules for different action types,
+refactored from the main PlanValidator.
+"""

teddy_executor/core/services/validation_rules/edit.py

@@ -0,0 +1,207 @@
+"""
+Validation rules for the 'EDIT' action.
+"""
+
+import os
+from typing import Optional
+
+from teddy_executor.core.domain.models.plan import (
+    ActionData,
+    DEFAULT_SIMILARITY_THRESHOLD,
+)
+from teddy_executor.core.ports.outbound import IConfigService, IFileSystemManager
+from teddy_executor.core.services.validation_rules.edit_matcher import (
+    find_best_match_and_diff,
+)
+from teddy_executor.core.services.validation_rules.helpers import (
+    BaseActionValidator,
+    ContextPaths,
+    PlanValidationError,
+    ValidationError,
+    ValidationResult,
+    resolve_similarity_threshold,
+    validate_path_is_safe,
+)
+from teddy_executor.core.utils.markdown import get_fence_for_content
+
+
+class EditActionValidator(BaseActionValidator):
+    """Validator for the 'EDIT' action."""
+
+    def __init__(
+        self, file_system_manager: IFileSystemManager, config_service: IConfigService
+    ):
+        super().__init__(file_system_manager)
+        self._config_service = config_service
+
+    def validate(
+        self,
+        action: ActionData,
+        context_paths: Optional[ContextPaths] = None,
+    ) -> ValidationResult:
+        """
+        Validates an 'edit' action.
+        """
+        path_str = (
+            action.params.get("path")
+            or action.params.get("file_path")
+            or action.params.get("File Path")
+            or action.params.get("path")
+        )
+
+        if not isinstance(path_str, str):
+            return []
+
+        try:
+            validate_path_is_safe(path_str, "EDIT")
+
+            # Context Check: Removed as per 02-04-Context Automation slice.
+            # EDIT actions are now allowed on any valid path, relying on the matcher.
+
+            if not self._file_system_manager.path_exists(path_str):
+                raise PlanValidationError(
+                    f"File to edit does not exist: {path_str}",
+                    file_path=path_str,
+                )
+
+        except (PlanValidationError, FileNotFoundError) as e:
+            return [
+                ValidationError(
+                    message=getattr(e, "message", str(e)),
+                    file_path=getattr(e, "file_path", path_str),
+                    offending_node=action.node,
+                )
+            ]
+
+        action_errors: ValidationResult = []
+        content = self._file_system_manager.read_raw_file(path_str)
+
+        # Use centralized similarity threshold resolution
+        threshold = resolve_similarity_threshold(self._config_service, action.params)
+
+        match_all = action.params.get("match_all", False)
+        edits = action.params.get("edits")
+        if isinstance(edits, list):
+            for edit in edits:
+                # Local override from edit metadata takes precedence
+                local_match_all = edit.get("match_all", match_all)
+                for err in _validate_single_edit(
+                    edit, content, path_str, threshold, match_all=local_match_all
+                ):
+                    # Attach specific FIND CodeBlock node for surgical diagnostics
+                    # Fallback to action node if find_node is missing
+                    offending_node = edit.get("find_node") or action.node
+                    action_errors.append(
+                        ValidationError(
+                            message=err.message,
+                            file_path=err.file_path,
+                            offending_node=offending_node,
+                        )
+                    )
+        return action_errors
+
+
+def _validate_single_edit(
+    edit: dict,
+    content: str,
+    file_path: str,
+    threshold: Optional[float] = None,
+    match_all: bool = False,
+) -> ValidationResult:
+    """Validates a single edit dictionary."""
+    errors: ValidationResult = []
+    find_block = edit.get("find")
+    replace_block = edit.get("replace")
+
+    if os.environ.get("TEDDY_DEBUG"):
+        print("\n--- TEDDY DEBUG: PlanValidator ---")
+        print(f"File: {file_path}")
+        print(f"Content (repr): {repr(content)}")
+        print(f"Find Block (repr): {repr(find_block)}")
+        print("--- END TEDDY DEBUG ---\n")
+
+    if isinstance(find_block, str):
+        if find_block == replace_block:
+            # Treat identical blocks as a successful no-op (02-04-Context Automation slice)
+            return []
+
+        # Use the resilient matcher for all matching logic
+        matcher_kwargs = {}
+        if threshold is not None:
+            matcher_kwargs["threshold"] = threshold
+
+        diff_text, score, is_ambiguous, offset = find_best_match_and_diff(
+            content, find_block, **matcher_kwargs
+        )
+
+        effective_threshold = (
+            threshold if threshold is not None else DEFAULT_SIMILARITY_THRESHOLD
+        )
+        fence = get_fence_for_content(find_block)
+
+        if is_ambiguous and not match_all:
+            errors.append(
+                ValidationError(
+                    message=(
+                        f"The `FIND` block is ambiguous in: {file_path}\n"
+                        f"**Similarity Score:** {score:.2f}\n"
+                        f"**FIND Block:**\n"
+                        f"{fence}\n{find_block}\n{fence}\n"
+                        "**Hint:** Please provide a larger FIND block to uniquely identify the section, refactor the code to avoid duplication. Alternatively you can use `Match All: true` to change all occurrences in the file at once."
+                    ),
+                    file_path=str(file_path),
+                )
+            )
+        elif score < effective_threshold:
+            error_msg = (
+                f"The `FIND` block could not be located in the file: "
+                f"{file_path}\n"
+                f"**Similarity Score:** {score:.2f}\n"
+                f"**Similarity Threshold:** {effective_threshold:.2f}\n"
+                f"**FIND Block:**\n"
+                f"{fence}\n{find_block}\n{fence}\n"
+            )
+            if diff_text:
+                # Prepend standard diff headers for high-clarity diagnostics
+                # ndiff(find, actual) means '-' is Provided and '+' is Actual
+                formatted_diff = f"--- Provided\n+++ Actual\n{diff_text}"
+                diff_fence = get_fence_for_content(formatted_diff)
+                error_msg += (
+                    f"**Closest Match Diff:**\n{diff_fence}diff\n"
+                    f"{formatted_diff}\n{diff_fence}\n"
+                )
+
+            hint = _get_already_applied_hint(
+                content, replace_block, effective_threshold, matcher_kwargs
+            )
+            error_msg += f"**Hint:** {hint}"
+            errors.append(ValidationError(message=error_msg, file_path=str(file_path)))
+    return errors
+
+
+def _get_already_applied_hint(
+    content: str,
+    replace_block: Optional[str],
+    threshold: float,
+    matcher_kwargs: dict,
+) -> str:
+    """Detects if the REPLACE block is already present in the content."""
+    replace_score = 0.0
+    if isinstance(replace_block, str):
+        _, replace_score, _, _ = find_best_match_and_diff(
+            content, replace_block, **matcher_kwargs
+        )
+
+    if replace_score >= threshold:
+        return (
+            "The FIND block was not found, but the REPLACE block is already "
+            "present. This change might have already been applied."
+        )
+
+    return (
+        "Review the provided diff and make sure to match the target content "
+        "exactly, including whitespace and indentations."
+    )
+
+
+# Removed legacy functional validation rule in favor of EditActionValidator class.