teddy-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: teddy-cli
-Version: 0.1.4
+Version: 0.1.5
 Summary: A local-first, file-based AI coding workflow that applies the UNIX philosophy to AI collaboration.
 License: AGPL-3.0-only
 License-File: LICENSE
@@ -30,6 +30,7 @@ Requires-Dist: python-dotenv (>=1.0.1)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: requests (>=2.33.0,<3.0.0)
 Requires-Dist: textual (>=8.1.0,<9.0.0)
+Requires-Dist: tld (>=0.10,<1.0)
 Requires-Dist: trafilatura (>=2.0.0,<3.0.0)
 Requires-Dist: typer[all]
 Requires-Dist: urllib3 (>=2.7.0,<3.0.0)

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "teddy-cli"
-version = "0.1.4"
+version = "0.1.5"
 description = "A local-first, file-based AI coding workflow that applies the UNIX philosophy to AI collaboration."
 authors = ["Raphael Atteritano"]
 license = "AGPL-3.0-only"
@@ -29,6 +29,7 @@ bandit = ">=1.7.9,<1.8.0"
 pip-audit = ">=2.7.3,<2.8.0"
 textual = "^8.1.0"
 urllib3 = "^2.7.0"
+tld = ">=0.10,<1.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^9.0.3"

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/__main__.py

@@ -57,8 +57,12 @@ logging.basicConfig(
 )
 
 
-def _ensure_project_initialized(container) -> None:
-    """Lazily performs project anchoring and initialization."""
+def _ensure_project_initialized(container, root_dir: str | None = None) -> None:
+    """Lazily performs project anchoring and initialization.
+
+    If root_dir is provided, uses that path as the root. Otherwise, finds
+    the nearest parent containing .teddy/ via find_project_root().
+    """
     from teddy_executor.adapters.inbound.cli_helpers import find_project_root
     from teddy_executor.core.ports.outbound.file_system_manager import (
         IFileSystemManager,
@@ -77,7 +81,10 @@ def _ensure_project_initialized(container) -> None:
     from teddy_executor.adapters.outbound.yaml_config_adapter import YamlConfigAdapter
     from punq import Scope
 
-    root = str(find_project_root())
+    if root_dir is None:
+        root = str(find_project_root())
+    else:
+        root = root_dir
     c = container
 
     regs = getattr(c.registrations, "_Registry__registrations", {})
@@ -170,17 +177,11 @@ def init():
     """
     Initializes the .teddy directory and pre-warms heavy imports for faster startup.
     """
+    from teddy_executor.adapters.inbound.cli_helpers import prewarm_imports
+
     container = get_container()
-    _ensure_project_initialized(container)
-    # Pre-warm heavy imports to reduce first-run latency
-    try:
-        import litellm  # noqa: F401
-        import trafilatura  # noqa: F401
-        import pyperclip  # noqa: F401
-        from bs4 import BeautifulSoup  # noqa: F401
-        from ddgs import DDGS  # noqa: F401
-    except ImportError:
-        pass  # Some optional dependencies may not be installed
+    _ensure_project_initialized(container, root_dir=str(Path.cwd()))
+    prewarm_imports()
     # Auto-login would trigger here once `teddy login` is implemented (no-op for now)
     typer.echo("TeDDy initialized in .teddy folder.")
 
@@ -194,6 +195,71 @@ def version() -> None:
     typer.echo(f"TeDDy v{installed}")
 
 
+@app.command()
+def update(
+    experimental: bool = typer.Option(
+        False,
+        "--experimental",
+        help="Check and upgrade from TestPyPI instead of PyPI.",
+    ),
+):
+    """Checks PyPI for the latest version of TeDDy and displays upgrade
+    instructions. Does not upgrade automatically."""
+    from teddy_executor.core.services.update_checker import (
+        get_current_version,
+        fetch_latest_version,
+        compare_versions,
+        is_prerelease,
+        PYPI_URL,
+        TEST_PYPI_URL,
+    )
+
+    index_url = TEST_PYPI_URL if experimental else PYPI_URL
+    # When experimental, include prerelease versions (TestPyPI only has dev releases)
+    latest = fetch_latest_version(index_url, stable_only=not experimental)
+
+    if latest is None:
+        typer.echo("Could not check for updates: network error.")
+        return
+
+    current = get_current_version()
+
+    needs_update = compare_versions(current, latest)
+    is_channel_switch = False
+    if not needs_update:
+        # If current is a pre-release and the latest is stable, allow downgrade
+        # to the stable channel
+        if is_prerelease(current) and not is_prerelease(latest):
+            is_channel_switch = True
+
+    if not needs_update and not is_channel_switch:
+        typer.echo(f"You are already running the latest version ({current}).")
+        return
+
+    if is_channel_switch:
+        typer.echo(f"You are running the latest experimental version ({current}).")
+        typer.echo(
+            "To switch to the stable release, run: pip install --upgrade teddy-cli"
+        )
+        typer.echo(
+            "To apply prompt updates: delete .teddy/prompts/ and run 'teddy init'"
+        )
+    elif experimental:
+        typer.echo(f"A new experimental version {latest} is available.")
+        typer.echo(
+            "To upgrade, run: pip install --upgrade teddy-cli --index-url https://test.pypi.org/simple/"
+        )
+        typer.echo(
+            "To apply prompt updates: delete .teddy/prompts/ and run 'teddy init'"
+        )
+    else:
+        typer.echo(f"A new version {latest} is available.")
+        typer.echo("To upgrade, run: pip install --upgrade teddy-cli")
+        typer.echo(
+            "To apply prompt updates: delete .teddy/prompts/ and run 'teddy init'"
+        )
+
+
 @app.command()
 def context(
     no_copy: bool = typer.Option(

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/adapters/inbound/cli_helpers.py

@@ -247,3 +247,18 @@ def apply_ui_mode_override(container: Container, ui_mode_bool: bool) -> None:
 
     mode = "tui" if ui_mode_bool else "console"
     register_reviewer(container, ui_mode=mode)
+
+
+def prewarm_imports() -> None:
+    """
+    Pre-warm heavy imports to reduce first-run latency.
+    Extracted from __main__.py init command for reuse by update command.
+    """
+    try:
+        import litellm  # noqa: F401
+        import trafilatura  # noqa: F401
+        import pyperclip  # noqa: F401
+        from bs4 import BeautifulSoup  # noqa: F401
+        from ddgs import DDGS  # noqa: F401
+    except ImportError:
+        pass

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -17,6 +17,13 @@ from teddy_executor.core.utils.string import slugify
 from teddy_executor.adapters.inbound.cli_formatter import format_project_context
 from teddy_executor.adapters.inbound.cli_helpers import (
     echo_and_copy,
+    find_project_root,
+)
+from teddy_executor.core.services.update_checker import (
+    background_check,
+    compare_versions,
+    get_current_version,
+    read_update_cache,
 )
 
 
@@ -78,6 +85,34 @@ def _orchestrate_session_loop(
             break
 
 
+def _display_update_notification(cache_path: Path) -> None:
+    """Check the update cache and display a non-blocking notification
+    if a newer version is available. Called on session startup, after
+    the background check thread has been started."""
+    try:
+        cache = read_update_cache(cache_path)
+        if cache is None:
+            return
+        latest = cache.get("latest_version", "")
+        if not latest:
+            return
+        current = get_current_version()
+        if compare_versions(current, latest):
+            typer.echo(
+                typer.style(
+                    f"ℹ A new version {latest} is available. "
+                    "To upgrade, run: pip install --upgrade teddy-cli\n"
+                    "   To apply prompt updates: delete .teddy/prompts/ and run 'teddy init'",
+                    fg=typer.colors.YELLOW,
+                )
+            )
+    except Exception:
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.debug("Failed to display update notification", exc_info=True)
+
+
 def handle_new_session(  # noqa: PLR0913
     container: Container,
     name: Optional[str],
@@ -91,6 +126,18 @@ def handle_new_session(  # noqa: PLR0913
     api_key: Optional[str] = None,
 ):
     """Logic for the 'start' command."""
+    import threading
+
+    # Start non-blocking background version check
+    cache_path = find_project_root() / ".teddy" / ".update_cache.json"
+    thread = threading.Thread(
+        target=background_check,
+        args=(cache_path,),
+        daemon=True,
+    )
+    thread.start()
+    _display_update_notification(cache_path)
+
     try:
         # 0. Ensure project is initialized
         container.resolve(IInitUseCase).ensure_initialized()
@@ -326,6 +373,18 @@ def handle_resume_session(  # noqa: PLR0913
     api_key: Optional[str] = None,
 ):
     """Logic for the 'resume' command."""
+    import threading
+
+    # Start non-blocking background version check
+    cache_path = find_project_root() / ".teddy" / ".update_cache.json"
+    thread = threading.Thread(
+        target=background_check,
+        args=(cache_path,),
+        daemon=True,
+    )
+    thread.start()
+    _display_update_notification(cache_path)
+
     try:
         # 1. Pre-flight checks
         typer.echo("Checking configurations...", err=True)

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/core/services/parser_metadata.py

@@ -17,6 +17,76 @@ from teddy_executor.core.services.parser_infrastructure import (
 )
 
 
+def _extract_text_with_emphasis(node: Any) -> str:
+    """
+    Extract text from an AST node, emitting delimiter markers for Strong/Emphasis tokens.
+
+    Used only for extracting the value portion of metadata key-value pairs.
+    Unlike `get_child_text`, it emits `__text__` for Strong tokens and `_text_`
+    for Emphasis tokens, preserving literal double underscores like those in
+    `__main__.py` that mistletoe would otherwise parse as formatting.
+    """
+    from mistletoe.span_token import Strong, Emphasis, RawText
+
+    if isinstance(node, RawText):
+        return getattr(node, "content", "")
+
+    if isinstance(node, Strong):
+        inner = ""
+        if hasattr(node, "children") and node.children:
+            inner = "".join(_extract_text_with_emphasis(c) for c in node.children)
+        return f"__{inner}__"
+
+    if isinstance(node, Emphasis):
+        inner = ""
+        if hasattr(node, "children") and node.children:
+            inner = "".join(_extract_text_with_emphasis(c) for c in node.children)
+        return f"_{inner}_"
+
+    if hasattr(node, "children") and node.children is not None:
+        return "".join(_extract_text_with_emphasis(c) for c in node.children)
+    return getattr(node, "content", "")
+
+
+def _extract_value_after_key(item: "MdListItem", key_text: str) -> Optional[str]:
+    """
+    Extract the value portion of a key-value pair from an AST ListItem node,
+    preserving emphasis delimiters in the value (e.g., for paths like __main__.py).
+
+    Navigates the item's children to find the node containing the key (a Strong
+    token like **Resource:**), then extracts emphasis-aware text from all subsequent
+    sibling nodes. When a Strong/Emphasis token's text matches the key, we STOP
+    recursion and return the remaining siblings at that level.
+    """
+    from mistletoe.span_token import Strong, Emphasis
+
+    key_with_colon = f"{key_text}:"
+
+    def find_remaining(parent) -> Optional[list[Any]]:
+        if not hasattr(parent, "children") or not parent.children:
+            return None
+        children = list(parent.children)
+        for i, child in enumerate(children):
+            child_text = get_child_text(child)
+            if child_text and key_with_colon in child_text:
+                if isinstance(child, (Strong, Emphasis)):
+                    return children[i + 1 :]
+                remaining = find_remaining(child)
+                if remaining is not None:
+                    return remaining
+        return None
+
+    remaining_children = find_remaining(item)
+    if not remaining_children:
+        return None
+
+    value_parts = []
+    for child in remaining_children:
+        value_parts.append(_extract_text_with_emphasis(child))
+    result = "".join(value_parts).strip()
+    return result if result else None
+
+
 def _process_link_key(
     item: "MdListItem", text: str, key_map: dict[str, str]
 ) -> Optional[tuple[str, str]]:
@@ -29,6 +99,12 @@ def _process_link_key(
             if link_node:
                 target = normalize_link_target(link_node.target)
                 return param_key, normalize_path(target)
+            # No link found: extract value from plain text using AST-based
+            # emphasis-aware extraction to preserve double underscores.
+            value = _extract_value_after_key(item, key_text)
+            if value is not None:
+                return param_key, normalize_path(value)
+            # Last resort fallback: use original (possibly corrupted) text
             parts = text.split(f"{key_text}:", 1)
             if len(parts) == EXPECTED_KV_PARTS and parts[1].strip():
                 return param_key, normalize_path(parts[1].strip())

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/core/services/planning_service.py

@@ -75,6 +75,7 @@ class PlanningService(IPlanningUseCase):
             agent_name=agent_name,
             current_turn=Path(turn_dir).name,
             system_prompt_tokens=system_token_count,
+            cache_dir=str(Path(turn_dir).parent),
         )
 
         # Context is purely project state (including initial_request.md via session.context).

teddy_cli-0.1.5/src/teddy_executor/core/services/update_checker.py

@@ -0,0 +1,212 @@
+"""Update Checker: Lightweight version check and upgrade mechanism.
+
+Provides functions for detecting the current installed version, fetching the
+latest version from PyPI/TestPyPI, comparing versions, caching results, and
+performing upgrades. All public functions use stdlib only (plus the
+`packaging` library which is a transitive dependency via pip-audit).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from packaging.version import Version
+
+if TYPE_CHECKING:
+    import ssl
+
+# --- Constants ---
+
+PYPI_URL = "https://pypi.org/pypi/teddy-cli/json"
+TEST_PYPI_URL = "https://test.pypi.org/pypi/teddy-cli/json"
+CACHE_FILENAME = ".update_cache.json"
+CACHE_TTL_HOURS = 24
+
+
+# --- SSL Context Setup ---
+
+
+def _create_ssl_context() -> ssl.SSLContext:
+    """
+    Create an SSL context with proper CA bundle.
+
+    Priority order:
+    1. certifi if available (provides latest Mozilla CA bundle)
+    2. Default SSL context (system CA bundle)
+
+    Returns an ssl.SSLContext object suitable for urllib.
+    """
+    import ssl  # noqa: F811  (imported at module level under TYPE_CHECKING)
+
+    try:
+        import certifi
+
+        cafile = certifi.where()
+        if Path(cafile).is_file():
+            return ssl.create_default_context(cafile=cafile)
+    except ImportError:
+        pass
+
+    # Fallback: use system default (may fail on some Python 3.14 macOS builds)
+    return ssl.create_default_context()
+
+
+# --- Public API ---
+
+
+def get_current_version() -> str:
+    """
+    Read installed version from importlib.metadata.
+    Falls back to '0.0.0' for dev installations or missing package.
+    """
+    try:
+        from importlib.metadata import version as _get_version
+
+        return _get_version("teddy-cli")
+    except Exception:
+        return "0.0.0"
+
+
+def fetch_latest_version(
+    index_url: str = PYPI_URL,
+    stable_only: bool = True,
+) -> Optional[str]:
+    """
+    Fetch the highest version from PyPI/TestPyPI JSON API.
+
+    Scans all releases in data['releases'] (instead of only data['info']['version']),
+    and optionally filters to stable versions only.
+
+    Args:
+        index_url: The PyPI JSON API URL.
+        stable_only: If True (default), only consider stable (non-prerelease) versions.
+                     If False, consider all versions including dev/pre-releases.
+
+    Returns:
+        The highest matching version string, or None on failure.
+    """
+    import json
+    import urllib.error
+    import urllib.request
+
+    try:
+        req = urllib.request.Request(
+            index_url,
+            headers={
+                "User-Agent": "TeDDy-Update-Checker/1.0",
+                "Accept": "application/json",
+            },
+        )
+        context = _create_ssl_context()
+        with urllib.request.urlopen(req, timeout=10, context=context) as resp:  # nosec
+            data = json.loads(resp.read().decode("utf-8"))
+            releases = data.get("releases", {})
+            if not releases:
+                # Fallback to info.version if releases dict is empty
+                return data.get("info", {}).get("version")
+            valid_versions = []
+            for v_str in releases.keys():
+                try:
+                    ver = Version(v_str)
+                    if stable_only and ver.is_prerelease:
+                        continue
+                    valid_versions.append(ver)
+                except Exception:
+                    pass
+            if not valid_versions:
+                return None
+            highest = max(valid_versions)
+            return str(highest)
+    except (urllib.error.URLError, OSError, json.JSONDecodeError, KeyError) as e:
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.debug("fetch_latest_version failed: %s", e)
+        return None
+
+
+def is_prerelease(version_str: str) -> bool:
+    """
+    Returns True if the given version string is a pre-release (dev, alpha, beta, rc, etc.)
+    according to PEP 440. Returns False on any parse failure.
+    """
+    try:
+        return Version(version_str).is_prerelease
+    except Exception:
+        return False
+
+
+def compare_versions(current: str, latest: str) -> bool:
+    """
+    Returns True if latest > current using PEP 440 version comparison.
+    Returns False on any parse failure.
+    """
+    try:
+        return Version(latest) > Version(current)
+    except Exception:
+        return False
+
+
+def read_update_cache(cache_path: Path) -> Optional[dict]:
+    """
+    Read the cache file. Returns None if:
+    - File is missing
+    - File is corrupt (invalid JSON)
+    - File has invalid structure (missing keys)
+    - TTL exceeded (24h from checked_at)
+    """
+    import json
+    from datetime import datetime, timezone, timedelta
+
+    try:
+        if not cache_path.is_file():
+            return None
+        data = json.loads(cache_path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return None
+        if "latest_version" not in data or "checked_at" not in data:
+            return None
+        checked_at = datetime.fromisoformat(data["checked_at"])
+        if datetime.now(timezone.utc) - checked_at > timedelta(hours=CACHE_TTL_HOURS):
+            return None
+        return data
+    except (OSError, json.JSONDecodeError, ValueError, TypeError):
+        return None
+
+
+def write_update_cache(cache_path: Path, latest_version: str) -> None:
+    """
+    Atomically write the cache file (write to temp file, rename).
+    Ensures the main thread never reads a partially written file.
+    """
+    import json
+    from datetime import datetime, timezone
+
+    cache_data = {
+        "latest_version": latest_version,
+        "checked_at": datetime.now(timezone.utc).isoformat(),
+    }
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = cache_path.with_suffix(".tmp")
+    try:
+        tmp_path.write_text(json.dumps(cache_data, indent=2), encoding="utf-8")
+        tmp_path.rename(cache_path)
+    except OSError as e:
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.debug("Failed to write update cache: %s", e)
+        if tmp_path.exists():
+            tmp_path.unlink()
+
+
+def background_check(cache_path: Path, index_url: str = PYPI_URL) -> None:
+    """
+    Non-blocking background version check.
+    Intended to run in a daemon thread. Fetches latest version from PyPI
+    and writes it to cache. All errors are silently caught.
+    """
+    latest = fetch_latest_version(index_url)
+    if latest is not None:
+        write_update_cache(cache_path, latest)

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/resources/config/config.yaml

@@ -9,6 +9,7 @@ ui_mode: "tui"
 # Fallback chain: Config -> VISUAL/EDITOR env vars -> code -> nano.
 editor: "code"
 
+
 # Execution Settings
 execution:
   default_timeout_seconds: 60

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/resources/config/prompts/architect.xml

@@ -29,7 +29,7 @@
         <step n="2" name="CI Quality Gate">Verify CI pipeline status for the targeted components. Ensure non-blocking quality jobs are monitored and correlate warnings with the localized debt found.</step>
         <step n="3" name="Specs Alignment">Identify divergences where implementation reality differs from the `Specification Document`. Resolve these via As-Built Alignment by `EDIT`-ing the Spec and Design Docs to match reality.</step>
         <step n="4" name="Milestone Management">If no active milestone exists, `READ` the Roadmap in `docs/project/PROJECT.md` to `CREATE` the next `Milestone`. You MUST translate ALL its Roadmap requirements into the Milestone document. Change status to `In Progress` and transition to `Completed` once fully implemented.</step>
-        <step n="5" name="Draft Component Designs">`CREATE` or `EDIT` draft design docs for affected components. Focus strictly on strategic intent, purpose, and key contracts; defer detailed logic. Transition any updated existing docs to `Refactoring` status.</step>
+        <step n="5" name="Draft Component Designs">`CREATE` or `EDIT` draft design docs for affected components. Focus strictly on strategic intent, purpose, and key contracts; defer detailed logic. Transition any updated existing docs to `Refactoring` status. If any existing component design docs do not adhere to the Component Design blueprint, update them to align.</step>
         <step n="6" name="Architecture Maintenance">Update `docs/architecture/ARCHITECTURE.md`'s `Component & Boundary Map` and `Key Architectural Decisions` if needed to align.</step>
         <step n="7" name="Delta Analysis">Use `EXECUTE git grep` and `READ` on all targeted components, contracts, interfaces, and DTOs referenced in the design. Verify implementation status of every piece the design calls for. Catalog the delta: what already exists (skip — do NOT include as a deliverable), what is partially implemented (note remaining work), and what is entirely missing (add as pending). Only truly unimplemented or incomplete work SHALL appear in the slice deliverables. Do NOT create entries for work that demonstrably exists.</step>
         <step n="8" name="Create Slice">`CREATE` exactly ONE Vertical Slice following these rules:
@@ -91,17 +91,32 @@
         </section>
         <section n="3" name="Failure Modes">
           <item name="Heading">## Failure Modes</item>
-          <item name="Content">Explicitly list known failure modes for this component. Ports (Interfaces) MUST NOT return generic "error-swallowing" values (like `None` or `False`) to hide internal crashes; instead, they should allow exceptions to propagate to the boundary where they can be handled transparently.</item>
+          <item name="Content">Explicitly list known failure modes for this component. Each entry MUST reference the specific precondition or postcondition it violates. Ports (Interfaces) MUST NOT return generic "error-swallowing" values (like `None` or `False`) to hide internal crashes; instead, they should allow exceptions to propagate to the boundary where they can be handled transparently.</item>
+          <item name="Content">Format: "- **Failure Title**: Violates the precondition/postcondition 'XYZ'. The component MUST raise a specific exception rather than returning a partial/invalid result."</item>
         </section>
-        <section n="4" name="Ports">
+        <section n="4" name="Class Invariants">
+          <item name="Heading">## Class Invariants</item>
+          <item name="Content">Document conditions that must always hold true for instances of this component (e.g., "turn_counter >= 0", "plan is never None after initialization"). Invariants are checked at public method entry and exit. If no invariants apply, state: "None — stateless component."</item>
+        </section>
+        <section n="5" name="Ports">
           <item name="Heading">## Ports</item>
           <item name="Content">Explicit inbound/outbound relationships.</item>
+          <item name="Content">If this component depends on other Ports' contracts, list them under **Contract Dependencies:** with links to the relevant doc sections. Example: "- Relies on `IFileSystemManager.read()` postcondition 'Returns file content as string'."</item>
         </section>
-        <section n="4" name="Logic">
+        <section n="6" name="Logic">
           <item name="Heading">## Implementation Details / Logic</item>
         </section>
-        <section n="5" name="Contracts">
+        <section n="7" name="Contracts">
           <item name="Heading">## Data Contracts / Methods</item>
+          <item name="Content">Document every public method with the following standard subsections:</item>
+          <item name="Content">```text
+### `method_name`
+- **Preconditions:** (required) What must be true before calling. Use "must" language: "key must be a non-empty string."
+- **Postconditions:** (required) What is guaranteed after successful return. Use "returns" or "ensures" language: "Returns a valid ConfigValue. Ensures the cache is updated."
+- **Exceptions:** (required) What errors can be raised and under what conditions.
+- **Invariants:** (optional) Class-level invariants that must hold before and after this method executes.
+```</item>
+          <item name="Content">**Contract Enforcement:** Implementations MUST validate preconditions with explicit guard clauses (assertions or early raises). Postcondition failures MUST be surfaced as specific exceptions, never swallowed. Invariants should be checked at public method entry and exit where practical. Core domain code should enforce contracts at boundary crossings (ports), not deep inside implementation details.</item>
         </section>
         <directory_conventions>
           <rule>Doc path: docs/architecture/BOUNDARY/LAYER/TYPE/name.md -> Source path: src/{pkg}/BOUNDARY/LAYER/TYPE/name.py -> Test path: tests/suites/TEST_TYPE/BOUNDARY/LAYER/TYPE/test_name.py</rule>
@@ -140,7 +155,7 @@
         </section>
         <section n="6" name="Deliverables">
           <item name="Heading">## Deliverables</item>
-          <item name="Content">Checklist of atomic units of work ordered following the Deliverable Dependency Sequence: 1. Contract (Interfaces; DTOs; Signatures; Expansion), 2. Harness (Infrastructure; Env), 3. Seam (Abstraction; Toggles; DI), 4. Logic (Rules; Algorithms), 5. Wiring (Connecting components to the entrypoints/Composition Root), 6. Migration (Updating consumers), 7. Refactor (Internal restructuring; non-breaking), 8. Cleanup (Pruning; Contraction). Every deliverable MUST be an atomic "Green-to-Green" transition; behavioral tests MUST be bundled with the Logic or Wiring deliverable that satisfies them, never committed as standalone failing states. Format: `- [ ] **Type** - Description`.</item>
+          <item name="Content">Checklist of atomic units of work ordered following the Tracer Bullet Dependency Sequence: 1. Contract (Interfaces; DTOs; Signatures; Expansion), 2. Harness (Infrastructure; Env), 3. Seam (Abstraction; Toggles; DI), 4. Wiring (The Tracer Bullet: Connecting components to the Composition Root/entrypoints returning trivial/hardcoded data to prove the end-to-end path), 5. Logic (Replacing the Tracer Bullet with complex Rules/Algorithms via TDD), 6. Migration (Updating consumers), 7. Refactor (Internal restructuring; non-breaking), 8. Cleanup (Pruning; Contraction). Every deliverable MUST be an atomic "Green-to-Green" transition; behavioral tests MUST be bundled with Wiring; Unit tests with Logic. Format: `- [ ] **Type** - Description`.</item>
         </section>
         <section n="7" name="Implementation Notes">
           <item name="Heading">## Implementation Notes</item>
@@ -243,6 +258,9 @@ WIP & REMINDERS:
         2. Commit Message: Use Conventional Commits '<type>(<scope>): <description>' wrapped in single quotes. Use imperative mood. Append ! for breaking changes.
         3. Execution: You MUST test, stage, commit locally, pull safely with rebase, and push by executing exactly this codeblock:
            ```shell
+           # 0. Ensure commit hooks are installed
+           pre-commit install -t pre-commit -t post-commit
+
            # 1. Stage changes and run pre-commit
            git add .
            pre-commit run || true

{teddy_cli-0.1.4 → teddy_cli-0.1.5}/src/teddy_executor/resources/config/prompts/assistant.xml

@@ -90,6 +90,9 @@ WIP & REMINDERS:
         2. Commit Message: Use Conventional Commits '<type>(<scope>): <description>' wrapped in single quotes. Use imperative mood. Append ! for breaking changes.
         3. Execution: You MUST test, stage, commit locally, pull safely with rebase, and push by executing exactly this codeblock:
            ```shell
+           # 0. Ensure commit hooks are installed
+           pre-commit install -t pre-commit -t post-commit
+
            # 1. Stage changes and run pre-commit
            git add .
            pre-commit run || true