teddy-cli 0.1.17.dev1383__tar.gz → 0.1.17.dev1384__tar.gz

{teddy_cli-0.1.17.dev1383 → teddy_cli-0.1.17.dev1384}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1383
+Version: 0.1.17.dev1384
 Summary: The local-first, test-driven agentic engineering harness. Because you should own the means of development.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.1.17.dev1383 → teddy_cli-0.1.17.dev1384}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1383"
+version = "0.1.17.dev1384"
 description = "The local-first, test-driven agentic engineering harness. Because you should own the means of development."
 readme = "README.md"
 keywords = [

{teddy_cli-0.1.17.dev1383 → teddy_cli-0.1.17.dev1384}/src/teddy_executor/core/services/markdown_plan_parser.py

@@ -110,6 +110,15 @@ class MarkdownPlanParser(IPlanParser):
         if current_disk is not None and current_disk.rstrip() != clean_content:
             path_obj.write_text(clean_content, encoding="utf-8", newline="")
 
+    @staticmethod
+    def _truncate_plan_content(clean_content: str, first_trailing_line: int) -> str:
+        """Drop the trailing paragraph run that starts at the given line."""
+        # Keep the splitlines basis. Mistletoe splits the document with
+        # splitlines(keepends=True), so form feeds and Unicode separators
+        # already advance its line numbers.
+        lines = clean_content.splitlines()
+        return "\n".join(lines[: first_trailing_line - 1]).rstrip()
+
     def parse(self, plan_content: str, plan_path: Optional[str] = None) -> Plan:
         """
         Parses the specified Markdown plan string into a structured Plan object.
@@ -135,10 +144,15 @@ class MarkdownPlanParser(IPlanParser):
 
             self._validate_mutual_exclusivity(doc)
 
-            actions = self._parse_section_content(
+            actions, trailing_line = self._parse_section_content(
                 stream, clean_content, section_heading, doc
             )
 
+            if trailing_line is not None:
+                clean_content = self._truncate_plan_content(
+                    clean_content, trailing_line
+                )
+
             is_session = self._is_session_plan(plan_path)
 
             plan = Plan(
@@ -255,7 +269,7 @@ class MarkdownPlanParser(IPlanParser):
         clean_content: str,
         section_heading: Any,
         doc: Document,
-    ) -> List[ActionData]:
+    ) -> tuple[List[ActionData], Optional[int]]:
         """Parses the content of either a ## Message or ## Action Plan section."""
         section_name = get_child_text(section_heading).strip()
         if "Message" in section_name:
@@ -270,14 +284,18 @@ class MarkdownPlanParser(IPlanParser):
                     stream, node=section_heading, raw_content=raw_content
                 )
             ]
-        else:
-            actions = self._parse_actions(stream, doc)
-        return actions
+            return actions, None
+        return self._parse_actions(stream, doc)
 
     def _parse_actions(
         self, stream: _PeekableStream, doc: Document
-    ) -> List[ActionData]:
-        from mistletoe.block_token import BlockCode, CodeFence, ThematicBreak
+    ) -> tuple[List[ActionData], Optional[int]]:
+        from mistletoe.block_token import (
+            BlockCode,
+            CodeFence,
+            Paragraph,
+            ThematicBreak,
+        )
 
         actions: List[ActionData] = []
         # 'Action Plan' heading is already consumed by _parse_strict_top_level.
@@ -294,6 +312,12 @@ class MarkdownPlanParser(IPlanParser):
                     stream.next()
                     continue
 
+                # A paragraph run that reaches the document end carries no plan
+                # instruction. Report where the real plan ends so the caller can
+                # persist the stripped content.
+                if isinstance(node, Paragraph):
+                    return actions, self._trailing_run_strip_line(stream, actions, doc)
+
                 # Accumulate offending node and raise structural error
                 offending_nodes = consume_content_until_next_action(
                     stream, self._valid_actions
@@ -333,6 +357,27 @@ class MarkdownPlanParser(IPlanParser):
             parse_method = self._dispatch_map[cleaned_action_type]
             actions.append(parse_method(stream, node=action_heading))
 
-        return actions
+        return actions, None
+
+    def _trailing_run_strip_line(
+        self, stream: _PeekableStream, actions: List[ActionData], doc: Document
+    ) -> int:
+        """Return the first line of a trailing paragraph run, or raise."""
+        from mistletoe.block_token import Paragraph
+
+        trailing_run: List[Any] = [stream.next()]
+        while stream.has_next() and isinstance(stream.peek(), Paragraph):
+            trailing_run.append(stream.next())
+
+        first_line = getattr(trailing_run[0], "line_number", None)
+        if actions and not stream.has_next() and first_line:
+            return first_line
+
+        raise InvalidPlanError(
+            format_structural_mismatch_msg(
+                doc, "a Level 3 Action Heading", -1, trailing_run
+            ),
+            offending_nodes=trailing_run,
+        )
 
     # Structural formatting logic moved to parser_infrastructure.py

{teddy_cli-0.1.17.dev1383 → teddy_cli-0.1.17.dev1384}/src/teddy_executor/core/services/parser_infrastructure.py

@@ -3,6 +3,8 @@ import re
 from typing import Any, List, Optional, Iterator, TYPE_CHECKING
 from urllib.parse import unquote
 
+from teddy_executor.core.utils.paths import strip_format_characters
+
 
 # Insert a space after `#` on the first line if missing (e.g., `#Title` -> `# Title`)
 # Only normalizes the first line to avoid corrupting code fences or shebangs.
@@ -111,15 +113,18 @@ def _looks_like_url(path: str) -> bool:
 
 
 def normalize_path(path: str) -> str:
-    result = path.replace("\\", "/")
+    result = strip_format_characters(path).replace("\\", "/")
     # Preserve URLs intact — percent-encoded symbols (%20, %23, %3F, etc.)
     # have structural meaning in URLs and must not be decoded.
     if _looks_like_url(result):
         return result
-    return unquote(result)
+    # Percent-encoded invisible characters decode into the same trap, so the
+    # scrubbing runs again on the decoded result.
+    return strip_format_characters(unquote(result))
 
 
 def normalize_link_target(target: str) -> str:
+    target = strip_format_characters(target)
     if target.startswith(("http://", "https://")):
         return target
     is_abs = os.path.isabs(target)
@@ -244,34 +249,36 @@ def translate_setup_commands(
     return cwd, env
 
 
+def _coerce_numeric(value: Any, expected_type: type) -> Any:
+    """Coerce a value to int or float, falling back to a leading-number match."""
+    try:
+        return expected_type(value)
+    except (ValueError, TypeError):
+        pattern = r"^(\d+)" if expected_type is int else r"^(\d+(?:\.\d+)?)"
+        match = re.match(pattern, str(value).strip())
+        return expected_type(match.group(1)) if match else None
+
+
+def _coerce_bool(value: Any) -> bool:
+    """Treat the case-insensitive text ``true`` as the only truthy string."""
+    if isinstance(value, str):
+        return value.strip().lower() == "true"
+    return bool(value)
+
+
 def coerce_param(value: Any, expected_type: type) -> Any:
     """
     Best-effort coercion of a raw parameter value to the expected type.
     If coercion fails entirely, returns None (caller should remove/ignore param).
     """
-    if value is None:
-        return None
-    if isinstance(value, expected_type):
+    if value is None or isinstance(value, expected_type):
         return value
 
-    if expected_type is int:
-        try:
-            return int(value)
-        except (ValueError, TypeError):
-            match = re.match(r"^(\d+)", str(value).strip())
-            return int(match.group(1)) if match else None
-
-    if expected_type is float:
-        try:
-            return float(value)
-        except (ValueError, TypeError):
-            match = re.match(r"^(\d+(?:\.\d+)?)", str(value).strip())
-            return float(match.group(1)) if match else None
+    if expected_type is int or expected_type is float:
+        return _coerce_numeric(value, expected_type)
 
     if expected_type is bool:
-        if isinstance(value, str):
-            return value.strip().lower() == "true"
-        return bool(value)
+        return _coerce_bool(value)
 
     return value
 

{teddy_cli-0.1.17.dev1383 → teddy_cli-0.1.17.dev1384}/src/teddy_executor/core/utils/paths.py

@@ -2,13 +2,15 @@
 
 Single-sources the path-normalization pipeline (Markdown-link target
 extraction plus backslash -> slash conversion, exact ``./`` prefix stripping,
-and leading-slash stripping) so every consumer delegates to one implementation
-and the behaviour cannot drift across modules. Also hosts ``prefer_markdown``,
-the single source of the "a pre-authored ``.md`` prompt wins over a stale
-``.xml`` with the same stem" rule shared by every prompt resolver.
+leading-slash stripping, and format-character scrubbing) so every consumer
+delegates to one implementation and the behaviour cannot drift across modules.
+Also hosts ``prefer_markdown``, the single source of the "a pre-authored
+``.md`` prompt wins over a stale ``.xml`` with the same stem" rule shared by
+every prompt resolver.
 """
 
 import re
+import unicodedata
 from pathlib import Path
 from typing import Iterable, Optional, TypeVar
 
@@ -16,6 +18,26 @@ _LINK_PATTERN = re.compile(r"\[.*\]\((.*)\)")
 _MARKDOWN_SUFFIX = ".md"
 _T = TypeVar("_T", str, Path)
 
+# The zero-width joiner and non-joiner are format characters, but they carry
+# shaping semantics: they bind emoji sequences and control cursive joining in
+# Arabic and Indic scripts, so a real file name can legitimately contain them.
+_PRESERVED_FORMAT_CHARACTERS = frozenset("\u200c\u200d")
+
+
+def strip_format_characters(value: str) -> str:
+    """Remove format characters that occupy space but render as nothing.
+
+    Zero-width spaces, byte-order marks, soft hyphens, and bidi controls survive
+    every other normalization step. A path that carries one names a different
+    file than the one it displays, so the removal happens before any other
+    transformation. Shaping joiners stay because they change adjacent glyphs.
+    """
+    return "".join(
+        char
+        for char in value
+        if char in _PRESERVED_FORMAT_CHARACTERS or unicodedata.category(char) != "Cf"
+    )
+
 
 def normalize_resource_path(resource_str: str) -> str:
     """Extracts the path from a Markdown link, or normalizes a raw path string.
@@ -24,16 +46,18 @@ def normalize_resource_path(resource_str: str) -> str:
     other input is treated as a raw path and stripped of surrounding whitespace.
     Both branches then normalize backslashes to forward slashes, strip an exact
     leading ``./`` (preserving leading dots such as ``.hidden``), and strip any
-    leading ``/``.
+    leading ``/``. Invisible format characters are removed first, so a path
+    never names a different file than the one it displays.
     """
-    match = _LINK_PATTERN.search(resource_str)
+    scrubbed = strip_format_characters(resource_str)
+    match = _LINK_PATTERN.search(scrubbed)
     if match:
         normalized = match.group(1).replace("\\", "/")
         if normalized.startswith("./"):
             normalized = normalized.removeprefix("./")
         return normalized.lstrip("/")
 
-    normalized = resource_str.strip().replace("\\", "/")
+    normalized = scrubbed.strip().replace("\\", "/")
     if normalized.startswith("./"):
         normalized = normalized.removeprefix("./")
     return normalized.lstrip("/")