teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/utils/diff.py

@@ -0,0 +1,57 @@
+import difflib
+
+
+def generate_unified_diff(
+    before: str, after: str, filename: str, from_label: str = "a", to_label: str = "b"
+) -> str:
+    """
+    Generates a unified diff between two strings.
+    """
+    diff_generator = difflib.unified_diff(
+        before.splitlines(keepends=True),
+        after.splitlines(keepends=True),
+        fromfile=f"{from_label}/{filename}",
+        tofile=f"{to_label}/{filename}",
+    )
+
+    diff_lines = []
+    for line in diff_generator:
+        diff_lines.append(line)
+        if not line.endswith("\n"):
+            diff_lines.append("\n")
+
+    return "".join(diff_lines).rstrip()
+
+
+def generate_character_diff(before: str, after: str, context: int = 2) -> str:
+    """
+    Generates a character-level diff using ndiff with hunk-based filtering.
+    Shows changed lines, their context, and joins hunks with '...'.
+    """
+    before_lines = before.splitlines(keepends=True)
+    after_lines = after.splitlines(keepends=True)
+    diff = list(difflib.ndiff(before_lines, after_lines))
+
+    # Identify lines that must be included (changes)
+    must_include = [i for i, line in enumerate(diff) if line[0] in ("-", "+", "?")]
+    if not must_include:
+        return ""
+
+    # Expand to include context around each change
+    included_indices = set()
+    for idx in must_include:
+        for i in range(max(0, idx - context), min(len(diff), idx + context + 1)):
+            included_indices.add(i)
+
+    # Build hunks from sorted indices
+    sorted_indices = sorted(list(included_indices))
+    res_lines = []
+    last_idx = -1
+
+    for idx in sorted_indices:
+        if last_idx != -1 and idx > last_idx + 1:
+            res_lines.append("...")
+        res_lines.append(diff[idx].rstrip("\n\r"))
+        last_idx = idx
+
+    return "\n".join(res_lines)

teddy_executor/core/utils/io.py

@@ -0,0 +1,75 @@
+import logging
+import re
+import sys
+from typing import Optional, TextIO
+
+
+class _TeeWriter:
+    def __init__(self, original: TextIO, log_file: TextIO):
+        self._original = original
+        self._log_file = log_file
+
+    # ANSI escape sequence pattern (e.g., \x1b[31m, \x1b[1;33m, \x1b[A)
+    _ANSI_ESCAPE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+    def write(self, text: str) -> None:
+        # Terminal always gets raw text (colours preserved)
+        self._original.write(text)
+        self._original.flush()
+        # Log file gets cleaned text (ANSI stripped)
+        clean = self._ANSI_ESCAPE.sub("", text)
+        self._log_file.write(clean)
+        self._log_file.flush()
+
+    def flush(self) -> None:
+        self._original.flush()
+        try:
+            self._log_file.flush()
+        except OSError:
+            pass
+
+    def isatty(self) -> bool:
+        return self._original.isatty()
+
+    @property
+    def encoding(self) -> str:
+        return self._original.encoding or "utf-8"
+
+
+class Tee:
+    def __init__(self, log_file: TextIO):
+        self._log_file: Optional[TextIO] = log_file
+        self._original_stdout: Optional[TextIO] = None
+        self._original_stderr: Optional[TextIO] = None
+
+    def __enter__(self) -> "Tee":
+        self._original_stdout = sys.stdout
+        self._original_stderr = sys.stderr
+        if self._log_file is None:
+            return self
+        sys.stdout = _TeeWriter(self._original_stdout, self._log_file)
+        sys.stderr = _TeeWriter(self._original_stderr, self._log_file)
+
+        # Fix for bug 22: Replace root logger handlers with new ones that use
+        # the current sys.stderr (the Tee proxy). This robustly ensures logging
+        # output flows through the Tee, regardless of how handlers were added.
+        old_handlers = list(logging.root.handlers)
+        for h in old_handlers:
+            logging.root.removeHandler(h)
+            h.close()
+        new_handler = logging.StreamHandler(sys.stderr)
+        new_handler.setFormatter(logging.Formatter("%(message)s"))
+        logging.root.addHandler(new_handler)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        if self._original_stdout is not None:
+            sys.stdout = self._original_stdout
+        if self._original_stderr is not None:
+            sys.stderr = self._original_stderr
+        if self._log_file is not None:
+            try:
+                self._log_file.close()
+            except OSError:
+                pass

teddy_executor/core/utils/markdown.py

@@ -0,0 +1,131 @@
+import os
+import re
+
+
+def get_language_from_path(path: str) -> str:
+    """
+    Determines the appropriate markdown code block language identifier based on
+    a file path. Falls back to the extension itself, or 'text' if no
+    extension exists.
+    """
+    _, ext = os.path.splitext(path)
+    if not ext:
+        return "text"
+
+    ext = ext.lower().lstrip(".")
+
+    # Common mappings where extension doesn't match language identifier exactly
+    extension_map = {
+        "py": "python",
+        "js": "javascript",
+        "jsx": "jsx",
+        "ts": "typescript",
+        "tsx": "tsx",
+        "md": "markdown",
+        "sh": "shell",
+        "bash": "shell",
+        "zsh": "shell",
+        "yml": "yaml",
+        "txt": "text",
+        "ps1": "powershell",
+        "cs": "csharp",
+        "tf": "terraform",
+        "ini": "ini",
+        "cfg": "ini",
+        "conf": "ini",
+        "h": "c",
+        "hpp": "cpp",
+        "cxx": "cpp",
+        "cc": "cpp",
+        "rb": "ruby",
+        "rs": "rust",
+    }
+
+    return extension_map.get(ext, ext)
+
+
+def extract_markdown_section(content: str, header: str, level: int = 2) -> str | None:
+    """
+    Extracts the content of a specific Markdown section.
+    Returns None if the section is not found or empty.
+    """
+    prefix = "#" * level
+    # Split by the specified header level
+    sections = re.split(rf"(?m)^{prefix}\s+", content)
+    for section in sections:
+        if section.startswith(header):
+            lines = section.splitlines()
+            if len(lines) > 1:
+                body = "\n".join(lines[1:]).strip()
+                return body if body else None
+    return None
+
+
+def get_fence_for_content(content: str) -> str:
+    """
+    Returns a markdown code fence string (e.g., "```") that is safe to use
+    for enclosing the given content.
+
+    The length of the fence will be at least 3, and strictly greater than
+    the longest sequence of backticks found in the content.
+    """
+    if not content:
+        return "```"
+
+    # Find all sequences of backticks
+    backtick_sequences = re.findall(r"`+", content)
+
+    max_backticks = 0
+    if backtick_sequences:
+        max_backticks = max(len(seq) for seq in backtick_sequences)
+
+    # Ensure fence is at least 3, and at least one longer than max found
+    fence_length = max(3, max_backticks + 1)
+
+    return "`" * fence_length
+
+
+def get_session_history_display_name(path: str) -> str | None:
+    """
+    Returns human-readable display name if it's a recognized session history file.
+    """
+    clean_path = path.lstrip("./")
+    if "initial_request.md" in clean_path:
+        return "Initial Request"
+    plan_match = re.search(r"sessions/[^/]+/(\d+)/plan.md$", clean_path)
+    if plan_match:
+        return f"Turn {int(plan_match.group(1))}: Plan"
+    report_match = re.search(r"sessions/[^/]+/(\d+)/report.md$", clean_path)
+    if report_match:
+        return f"Turn {int(report_match.group(1))}: Report"
+    return None
+
+
+def is_session_file_path(path: str) -> bool:
+    """
+    Determines if a path is inside .teddy/sessions/.
+    """
+    return "sessions/" in path.lstrip("./")
+
+
+def is_session_history_path(path: str) -> bool:
+    """
+    Determines if a path is a session history file.
+    """
+    return get_session_history_display_name(path) is not None
+
+
+def get_session_history_sort_key(path: str) -> tuple[int, int]:
+    """
+    Sort key for chronological session history: (turn_number, sub_order).
+    """
+    clean_path = path.lstrip("./")
+    if "initial_request.md" in clean_path:
+        return (0, 0)
+    plan_match = re.search(r"sessions/[^/]+/(\d+)/plan.md$", clean_path)
+    if plan_match:
+        return (int(plan_match.group(1)), 1)
+    report_match = re.search(r"sessions/[^/]+/(\d+)/report.md$", clean_path)
+    if report_match:
+        return (int(report_match.group(1)), 2)
+    return (999999, 999999)

teddy_executor/core/utils/serialization.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict
+
+
+import dataclasses
+from datetime import datetime
+from enum import Enum
+
+
+def scrub_dict_for_serialization(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively ensures that MagicMocks and complex objects are neutralized
+    for serialization while preserving the structure required by templates.
+    """
+
+    def scrub(v: Any) -> Any:
+        """Neutralizes MagicMocks for serialization (PLR0911)."""
+        # 1. Neutralize Mocks, Primitives, Enums
+        if (
+            hasattr(v, "_mock_return_value")
+            or hasattr(v, "assert_called")
+            or "Mock" in str(type(v))
+        ):
+            return "mock_object"
+        if isinstance(v, (str, int, float, bool, type(None), datetime, Enum)):
+            return v
+
+        # 2. Handle Dataclasses
+        if dataclasses.is_dataclass(v):
+            return {f.name: scrub(getattr(v, f.name)) for f in dataclasses.fields(v)}
+
+        # 3. Recursively handle collections
+        if isinstance(v, dict):
+            return {k: scrub(val) for k, val in v.items()}
+        if isinstance(v, (list, tuple, set)):
+            return [scrub(item) for item in v]
+
+        return str(v)
+
+    return {k: scrub(v) for k, v in data.items()}

teddy_executor/core/utils/string.py

@@ -0,0 +1,351 @@
+import re
+
+# Exhaustive English stopwords to strip from session names for conciseness
+STOPWORDS = {
+    "a",
+    "about",
+    "actually",
+    "above",
+    "after",
+    "again",
+    "all",
+    "also",
+    "am",
+    "an",
+    "and",
+    "any",
+    "are",
+    "as",
+    "at",
+    "be",
+    "because",
+    "been",
+    "before",
+    "being",
+    "below",
+    "between",
+    "both",
+    "but",
+    "by",
+    "can",
+    "could",
+    "did",
+    "do",
+    "does",
+    "doing",
+    "down",
+    "during",
+    "each",
+    "few",
+    "for",
+    "from",
+    "further",
+    "get",
+    "had",
+    "has",
+    "have",
+    "having",
+    "he",
+    "hello",
+    "help",
+    "hey",
+    "hi",
+    "her",
+    "here",
+    "hers",
+    "herself",
+    "him",
+    "himself",
+    "his",
+    "how",
+    "i",
+    "if",
+    "in",
+    "into",
+    "is",
+    "it",
+    "its",
+    "itself",
+    "just",
+    "kindly",
+    "like",
+    "me",
+    "more",
+    "most",
+    "my",
+    "myself",
+    "no",
+    "nor",
+    "now",
+    "of",
+    "off",
+    "on",
+    "once",
+    "only",
+    "or",
+    "other",
+    "please",
+    "our",
+    "ours",
+    "ourselves",
+    "out",
+    "over",
+    "own",
+    "s",
+    "same",
+    "she",
+    "should",
+    "so",
+    "some",
+    "such",
+    "t",
+    "than",
+    "thank",
+    "thanks",
+    "that",
+    "the",
+    "their",
+    "theirs",
+    "them",
+    "themselves",
+    "then",
+    "there",
+    "these",
+    "they",
+    "this",
+    "those",
+    "through",
+    "to",
+    "too",
+    "under",
+    "until",
+    "up",
+    "very",
+    "want",
+    "was",
+    "we",
+    "were",
+    "what",
+    "when",
+    "where",
+    "which",
+    "while",
+    "who",
+    "whom",
+    "why",
+    "will",
+    "with",
+    "would",
+    "you",
+    "your",
+    "yours",
+    "yourself",
+    "yourselves",
+    "using",
+    "basically",
+    "simply",
+    "really",
+    "dont",
+    "arent",
+    "yet",
+    "cant",
+    "wont",
+    "shouldnt",
+    "couldnt",
+    "didnt",
+    "hasnt",
+    "havent",
+    "isnt",
+    "wasnt",
+    "werent",
+    "im",
+    "youre",
+    "hes",
+    "shes",
+    "theyre",
+    "ive",
+    "youve",
+    "weve",
+    "theyve",
+    "ill",
+    "youll",
+    "hell",
+    "shell",
+    "well",
+    "theyll",
+    "id",
+    "youd",
+    "hed",
+    "shed",
+    "wed",
+    "theyd",
+    "going",
+    "gonna",
+    "wanna",
+    "gotta",
+    "ok",
+    "okay",
+    "sure",
+    "surely",
+    "maybe",
+    "perhaps",
+    "already",
+}
+
+
+def slugify(text: str, max_length: int = 40) -> str:
+    """
+    Converts a string into a URL-friendly slug.
+
+    1. Lowercase and strip apostrophes (e.g., don't -> dont).
+    2. Split into words and remove aggressive stopwords.
+    3. Join words with hyphens until max_length is reached (whole-word truncation).
+    """
+    # 1. Lowercase and strip apostrophes
+    s = text.lower().replace("'", "")
+
+    # 2. Split and filter stopwords
+    all_words = [w for w in re.split(r"[^a-z0-9]+", s) if w and w not in STOPWORDS]
+
+    # 3. Build slug word by word to respect max_length
+    slug_words: list[str] = []
+    current_length = 0
+    for word in all_words:
+        # Word length + hyphen (if not first word)
+        added_length = len(word) + (1 if slug_words else 0)
+        if current_length + added_length > max_length:
+            break
+        slug_words.append(word)
+        current_length += added_length
+
+    return "-".join(slug_words)
+
+
+def truncate_lines(
+    content: str,
+    max_lines: int,
+    direction: str = "tail",
+    hint: str = "",
+    action_type: str | None = None,
+) -> str:
+    """
+    Truncates a string to a maximum number of lines.
+
+    Args:
+        content: The text to truncate.
+        max_lines: Maximum number of lines to preserve.
+        direction: "head" (preserve first X) or "tail" (preserve last X).
+        hint: An optional message to include when truncation occurs.
+        action_type: Optional "execute" or "read" to generate a dynamic hint.
+    """
+    if not content or max_lines <= 0:
+        return content
+
+    lines = content.splitlines()
+    total_lines = len(lines)
+    if total_lines <= max_lines:
+        return content
+
+    # Generate dynamic hint if action_type is provided
+    if action_type:
+        hint = get_truncation_hint(action_type, max_lines, total_lines)
+
+    if direction == "tail":
+        truncated = "\n".join(lines[-max_lines:])
+        return f"{hint}\n{truncated}" if hint else truncated
+    elif direction == "head":
+        truncated = "\n".join(lines[:max_lines])
+        return f"{truncated}\n{hint}" if hint else truncated
+    else:
+        raise ValueError(f"Invalid truncation direction: {direction}")
+
+
+def get_truncation_hint(action_type: str, max_lines: int, total_lines: int) -> str:
+    """
+    Returns a context-specific hint for truncated output based on the action type.
+    """
+    action_type = action_type.lower()
+    if action_type == "execute":
+        return (
+            f"[Output truncated: Showing last {max_lines} of {total_lines} lines. "
+            "Use the 'Tail' parameter to increase the output limit.]"
+        )
+    if action_type == "read":
+        return (
+            f"[Content truncated: Showing first {max_lines} of {total_lines} lines. "
+            "Use the 'Lines' parameter to read specific line ranges (e.g., '2-25').]"
+        )
+
+    return f"[Content truncated: Showing {max_lines} of {total_lines} lines.]"
+
+
+def extract_lines_range(content: str, lines_spec: str) -> str:
+    """
+    Extracts a range of lines from multi-line content based on a lines specification.
+
+    Supported formats:
+        "10-20"  → inclusive range from line 10 to line 20 (1‑indexed)
+        "-20"    → first 20 lines (equivalent to "1-20")
+        "50-"    → from line 50 to the end
+        "5"      → single line (line 5)
+        anything else → returns full content unchanged (fallback)
+
+    Args:
+        content: The full file content as a single string.
+        lines_spec: The user‑supplied lines parameter (e.g., "10-20").
+
+    Returns:
+        The selected lines as a single string, or the full content if the spec
+        is invalid.
+    """
+    if not content:
+        return ""
+    if not lines_spec or not isinstance(lines_spec, str):
+        return content
+
+    lines = content.splitlines()
+    total = len(lines)
+
+    # Try to parse the specification
+    spec = lines_spec.strip()
+    try:
+        if "-" in spec:
+            # Range format: "start-end", "-end", or "start-"
+            parts = spec.split("-", 1)
+            if parts[0] == "" and parts[1] != "":
+                # "-end" → first `end` lines
+                end = int(parts[1])
+                start = 1
+            elif parts[1] == "" and parts[0] != "":
+                # "start-" → from `start` to end
+                start = int(parts[0])
+                end = total
+            else:
+                # "start-end"
+                start = int(parts[0]) if parts[0] else 1
+                end = int(parts[1]) if parts[1] else total
+        else:
+            # Single line number: "5"
+            line_num = int(spec)
+            start = line_num
+            end = line_num
+    except (ValueError, TypeError):
+        # Malformed spec → fall back to full content
+        return content
+
+    # If start line is beyond the file, return empty
+    if start > total:
+        return ""
+
+    # Clamp to valid range (1‑indexed)
+    start = max(1, min(start, total))
+    end = max(start, min(end, total))
+
+    extracted = lines[start - 1 : end]
+    return "\n".join(extracted)
+
+
+# double_newlines has been removed. It was a band-aid that became harmful:
+# blind \n → \n\n replacement broke tables, lists, and code blocks.
+# The correct fix is raw text extraction in parse_message_action, which preserves
+# the LLM's original formatting exactly. See action_parser_complex.py.

teddy_executor/prompts.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from typing import Optional
+
+
+def _search_prompt_in_dir(directory: Path, prompt_name: str) -> Optional[str]:
+    """Searches a directory for a prompt file and returns its content."""
+    if not directory.is_dir():
+        return None
+    found_files = list(directory.glob(f"{prompt_name}.*"))
+    if found_files:
+        return found_files[0].read_text(encoding="utf-8")
+    return None
+
+
+def find_prompt_content(prompt_name: str) -> Optional[str]:
+    """
+    Finds prompt content by searching in `.teddy/prompts/` (user-editable)
+    by traversing upwards from the current working directory.
+    Returns the content as a string, or None if not found.
+    Bundled resources are no longer used as a fallback — only `.teddy/prompts/`.
+    """
+    current_path = Path.cwd().resolve()
+    for path in [current_path] + list(current_path.parents):
+        local_prompt_dir = path / ".teddy" / "prompts"
+        if content := _search_prompt_in_dir(local_prompt_dir, prompt_name):
+            return content
+
+    return None
+
+
+def list_prompt_names() -> list[str]:
+    """
+    Lists available prompt names by scanning `.teddy/prompts/` directories
+    upward from the current working directory.
+    Returns a sorted list of prompt names (stems, without any file extension),
+    or an empty list if no prompts directory is found.
+    """
+    current_path = Path.cwd().resolve()
+    for path in [current_path] + list(current_path.parents):
+        prompts_dir = path / ".teddy" / "prompts"
+        if prompts_dir.is_dir():
+            # List all files in the prompts directory and extract stems
+            prompt_files = sorted(prompts_dir.glob("*"))
+            return [f.stem for f in prompt_files if f.is_file()]
+    return []

teddy_executor/registries/__init__.py

@@ -0,0 +1 @@
+"""Registry modules for container configuration."""