teddy-cli 0.1.17.dev1320__tar.gz → 0.1.17.dev1322__tar.gz

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1320
+Version: 0.1.17.dev1322
 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.dev1320 → teddy_cli-0.1.17.dev1322}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1320"
+version = "0.1.17.dev1322"
 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.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/__main__.py

@@ -214,6 +214,16 @@ OPT_PIPELINE = typer.Option(
     "-p",
     help="Pipeline mode: auto-approve all actions, requires -m, exits after first ## Message.",
 )
+OPT_MAX_TURNS = typer.Option(
+    None,
+    "--max-turns",
+    help="Maximum turns for a non-interactive run (overrides config).",
+)
+OPT_MAX_COST = typer.Option(
+    None,
+    "--max-cost",
+    help="Maximum session cost in dollars for a non-interactive run.",
+)
 
 
 @app.command()
@@ -255,6 +265,8 @@ def start(  # noqa: PLR0913
     api_key: Optional[str] = typer.Option(
         None, "--api-key", help="LLM API key override."
     ),
+    max_turns: Optional[int] = OPT_MAX_TURNS,
+    max_cost: Optional[float] = OPT_MAX_COST,
 ):
     """
     Initializes a new session directory and bootstraps it for Turn 1.
@@ -293,6 +305,8 @@ def start(  # noqa: PLR0913
         additional_context=additional_context,
         model=model,
         api_key=api_key,
+        max_turns=max_turns,
+        max_cost=max_cost,
     )
 
 
@@ -537,6 +551,8 @@ def resume(  # noqa: PLR0913
         ),
     ),
     pipeline: bool = OPT_PIPELINE,
+    max_turns: Optional[int] = OPT_MAX_TURNS,
+    max_cost: Optional[float] = OPT_MAX_COST,
 ):
     """
     Intelligently resumes the last turn of a session or starts a new one.
@@ -565,6 +581,8 @@ def resume(  # noqa: PLR0913
         agent=agent,
         message=message,
         pipeline=pipeline,
+        max_turns=max_turns,
+        max_cost=max_cost,
     )
 
 

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -334,7 +334,7 @@ def _resolve_initial_turn(session_manager: ISessionManager, session_name: str) -
 
 def _emit_guard_termination(guard_reason: Optional[str]) -> None:
     """Prints a guardrail termination reason: first line red, remainder plain."""
-    reason = guard_reason or "YOLO guardrail limit reached."
+    reason = guard_reason or "Guardrail limit reached."
     lines = reason.lstrip("\n").split("\n", 1)
     typer.secho("")
     typer.secho(lines[0], fg=typer.colors.RED)
@@ -356,6 +356,23 @@ def _should_exit_pipeline(pipeline: bool, report: Any) -> bool:
     )
 
 
+def _is_communication_turn(report: Any) -> bool:
+    """True when the report carries a non-empty MESSAGE action.
+
+    A communication turn means the human is present and approves the
+    continuation, so the loop re-anchors the guard baseline before the limit
+    check. Mirrors the orchestrator's canonical predicate: a MESSAGE action
+    with non-empty details.
+    """
+    if not report.action_logs:
+        return False
+    return any(
+        (getattr(log_entry, "action_type", None) or "").upper() == "MESSAGE"
+        and (getattr(log_entry, "details", "") or "").strip()
+        for log_entry in report.action_logs
+    )
+
+
 def _orchestrate_session_loop(  # noqa: PLR0913
     container: Container,
     session_name: str,
@@ -363,6 +380,8 @@ def _orchestrate_session_loop(  # noqa: PLR0913
     no_copy: bool,
     pipeline: bool = False,
     message: Optional[str] = None,
+    max_turns: Optional[int] = None,
+    max_cost: Optional[float] = None,
 ) -> None:
     """Shared turn loop for start and resume commands."""
     from teddy_executor.adapters.inbound.cli_helpers import handle_report_output
@@ -378,7 +397,11 @@ def _orchestrate_session_loop(  # noqa: PLR0913
     initial_cost = session_manager.get_cumulative_cost(session_name)
 
     loop_guard = container.resolve(
-        ISessionLoopGuard, initial_turn=initial_turn, initial_cost=initial_cost
+        ISessionLoopGuard,
+        initial_turn=initial_turn,
+        initial_cost=initial_cost,
+        max_turns=max_turns,
+        max_cost=max_cost,
     )
 
     # Two-phase Ctrl+C interrupt (tracer bullet): the container shares ONE
@@ -431,6 +454,15 @@ def _orchestrate_session_loop(  # noqa: PLR0913
                 break
 
             cumulative_cost = float(report.metadata.get("cumulative_cost", 0.0))
+
+            # A communication turn means the human is present and approves the
+            # continuation, so re-anchor the budget BEFORE the limit check. The
+            # message turn therefore never trips the limit, and the next segment
+            # starts fresh. The guard itself gates the reset on
+            # guardrails.message_reset.
+            if _is_communication_turn(report):
+                loop_guard.reset_baseline(turn_count, cumulative_cost)
+
             should_continue, guard_reason = loop_guard.should_continue(
                 turn_count, cumulative_cost, interactive
             )
@@ -628,6 +660,8 @@ def handle_new_session(  # noqa: PLR0913
     api_key: Optional[str] = None,
     setup_editor: Optional[bool] = None,
     setup_api_key: Optional[bool] = None,
+    max_turns: Optional[int] = None,
+    max_cost: Optional[float] = None,
 ):
     """Logic for the 'start' command."""
     fired = _start_background_update_check(container)
@@ -681,6 +715,8 @@ def handle_new_session(  # noqa: PLR0913
             interactive=interactive,
             no_copy=no_copy,
             pipeline=pipeline,
+            max_turns=max_turns,
+            max_cost=max_cost,
         )
 
     except Exception as e:
@@ -1145,6 +1181,8 @@ def handle_resume_session(  # noqa: PLR0913
     pipeline: bool = False,
     setup_editor: Optional[bool] = None,
     setup_api_key: Optional[bool] = None,
+    max_turns: Optional[int] = None,
+    max_cost: Optional[float] = None,
 ):
     """Logic for the 'resume' command."""
     fired = _start_background_update_check(container)
@@ -1185,6 +1223,8 @@ def handle_resume_session(  # noqa: PLR0913
             no_copy=no_copy,
             message=message,
             pipeline=pipeline,
+            max_turns=max_turns,
+            max_cost=max_cost,
         )
 
     except Exception as e:

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/core/ports/outbound/session_loop_guard.py

@@ -17,3 +17,13 @@ class ISessionLoopGuard(Protocol):
         how to adjust the configuration.
         """
         ...
+
+    def reset_baseline(self, turn_count: int, cumulative_cost: float) -> None:
+        """
+        Re-anchors the turn-count and cost baselines to the given values.
+
+        A human-approved message turn re-anchors the baselines so the next
+        segment gets a fresh budget. Implementations measure every later
+        ``should_continue`` call as a delta from the new baselines.
+        """
+        ...

teddy_cli-0.1.17.dev1322/src/teddy_executor/core/services/session_loop_guard.py

@@ -0,0 +1,133 @@
+from typing import Any, Optional
+
+from teddy_executor.core.ports.outbound import IConfigService
+from teddy_executor.core.ports.outbound.session_loop_guard import ISessionLoopGuard
+from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
+
+
+# Sentinel distinguishing "key absent" from a present falsy value, so the
+# legacy `yolo_guardrails` namespace is consulted only when the renamed
+# `guardrails` key is missing.
+_UNSET = object()
+
+
+class ProductionSessionLoopGuard(ISessionLoopGuard):
+    """
+    Production implementation: bounds a non-interactive run by turns and cost.
+    """
+
+    def __init__(  # noqa: PLR0913  # Explicit DI: config, environment, baselines, and CLI overrides.
+        self,
+        config_service: IConfigService,
+        system_environment: ISystemEnvironment,
+        initial_turn: int,
+        initial_cost: float,
+        max_turns: Optional[int] = None,
+        max_cost: Optional[float] = None,
+    ) -> None:
+        self._config_service = config_service
+        self._system_environment = system_environment
+        self._initial_turn = initial_turn
+        self._initial_cost = initial_cost
+        # A CLI-supplied limit is the most specific source and wins outright.
+        self._max_turns_override = max_turns
+        self._max_cost_override = max_cost
+
+    def _read_config(self, key: str, default: Any) -> Any:
+        """Reads ``guardrails.<key>`` with a legacy ``yolo_guardrails`` fallback.
+
+        Existing user configs still use the ``yolo_guardrails`` namespace, so
+        when the renamed ``guardrails`` key is absent the legacy key is read
+        before the default applies.
+        """
+        value = self._config_service.get_setting(f"guardrails.{key}", _UNSET)
+        if value is _UNSET:
+            value = self._config_service.get_setting(f"yolo_guardrails.{key}", _UNSET)
+        return default if value is _UNSET else value
+
+    def _resolve_limit(
+        self,
+        override: Optional[float],
+        env_key: str,
+        config_key: str,
+        default: float,
+    ) -> Any:
+        """Resolves one limit through the precedence chain.
+
+        Order: an explicit CLI override, then the environment variable, then the
+        config value, then the default. The config value falls back to the
+        default when it is absent or falsy; an explicit override of 0 still wins.
+        """
+        if override is not None:
+            return override
+        env_value = self._system_environment.get_env(env_key)
+        if env_value:
+            return env_value
+        return self._read_config(config_key, default) or default
+
+    def _resolve_max_turns(self) -> int:
+        """Resolves the turn limit: CLI flag, then env var, then config, then 150."""
+        return int(
+            self._resolve_limit(
+                self._max_turns_override, "TEDDY_MAX_TURNS", "max_turns", 150
+            )
+        )
+
+    def _resolve_max_cost(self) -> float:
+        """Resolves the cost limit: CLI flag, then env var, then config, then 5.0."""
+        return float(
+            self._resolve_limit(
+                self._max_cost_override,
+                "TEDDY_MAX_SESSION_COST",
+                "max_session_cost",
+                5.0,
+            )
+        )
+
+    def should_continue(
+        self, turn_count: int, cumulative_cost: float, interactive: bool
+    ) -> tuple[bool, Optional[str]]:
+        if interactive:
+            return True, None
+
+        if not bool(self._read_config("enabled", True)):
+            return True, None
+
+        max_turns = self._resolve_max_turns()
+        max_cost = self._resolve_max_cost()
+
+        turn_delta = turn_count - self._initial_turn
+        cost_delta = cumulative_cost - self._initial_cost
+
+        if turn_delta >= max_turns:
+            config_path = self._config_service.get_config_path()
+            import os as _os
+
+            rel_path = _os.path.relpath(config_path)
+            return False, (
+                f"Turn limit reached: {turn_delta}/{max_turns} turns in this run.\n"
+                f"To change this limit, set 'guardrails.max_turns' in {rel_path}."
+            )
+
+        if cost_delta >= max_cost:
+            config_path = self._config_service.get_config_path()
+            import os as _os
+
+            rel_path = _os.path.relpath(config_path)
+            return False, (
+                f"Cost limit reached: ${cost_delta:.2f}/${max_cost:.2f} in this run.\n"
+                f"To change this limit, set 'guardrails.max_session_cost' in {rel_path}."
+            )
+
+        return True, None
+
+    def reset_baseline(self, turn_count: int, cumulative_cost: float) -> None:
+        """Re-anchors both baselines after a message turn, when enabled.
+
+        The reset is gated by ``guardrails.message_reset`` (default true), so an
+        operator can keep the baselines fixed for the whole run.
+        """
+        if not bool(self._read_config("message_reset", True)):
+            return
+        self._initial_turn = turn_count
+        self._initial_cost = cumulative_cost

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/resources/config/config.yaml

@@ -39,9 +39,9 @@ yolo_default: false
 
 # Safety limits enforced in non-interactive runs (--yolo and --pipeline).
 # Limits are per-run: `teddy resume` starts counting from 0 again.
-yolo_guardrails:
+guardrails:
   enabled: true
-  max_turns: 99
+  max_turns: 150
   max_session_cost: 5.00
   message_reset: true
 

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/resources/templates/ci.md

@@ -12,6 +12,7 @@ The CI pipeline consists of two parallel jobs:
 - Runs on each push and pull request.
 - Executes across multiple OS targets (e.g., ubuntu-latest, windows-latest, macos-latest).
 - Runs the full test suite: `{runner} pytest`.
+- Discovers tests via `testpaths` in `pyproject.toml`; the CI step passes no path so the config stays the single source of truth.
 - **Blocking:** If this job fails, the CI pipeline is marked as failed.
 
 ### Job 2: Non-Blocking Quality Checks

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/resources/templates/makefile.md

@@ -99,6 +99,8 @@ test:
 
 **Usage:** `make test`
 
+**Test scope:** declare the tests directory once via `testpaths` in `pyproject.toml`. The `test` target passes no path to `pytest`, so the config stays the single source of truth.
+
 ## Commit Workflow
 
 `make commit` is **local-only**: it stages all local changes, runs the pre-commit hooks once (an advisory auto-fix pass that re-stages any auto-formatted files), and commits. It does **not** pull or push — the push is deferred to the session Conclusion via `make push` (see [Push (Deferred to Conclusion)](#push-deferred-to-conclusion)).

{teddy_cli-0.1.17.dev1320 → teddy_cli-0.1.17.dev1322}/src/teddy_executor/resources/templates/pre-commit.md

@@ -77,6 +77,8 @@ repos:
 
 **Tip:** Pin exact `rev` tags so every teammate runs identical checks.
 
+**Line endings:** The whitespace hooks (`trailing-whitespace`, `end-of-file-fixer`) fix trailing spaces and the missing final newline. They do NOT normalize LF versus CRLF. Add a committed `.gitattributes` with the rule `* text=auto eol=lf`. Git then stores and checks out text as LF on every platform. This rule applies to every clone and to unstaged files, so it is more robust than a hook. TeDDy does NOT create this file. Create it yourself in the project root.
+
 ## 3. Install the hooks
 
 ```shell

teddy_cli-0.1.17.dev1320/src/teddy_executor/core/services/session_loop_guard.py

@@ -1,62 +0,0 @@
-from typing import Optional
-
-from teddy_executor.core.ports.outbound import IConfigService
-from teddy_executor.core.ports.outbound.session_loop_guard import ISessionLoopGuard
-
-
-class ProductionSessionLoopGuard(ISessionLoopGuard):
-    """
-    Production implementation: enforces YOLO guardrails in non-interactive mode.
-    """
-
-    def __init__(
-        self,
-        config_service: IConfigService,
-        initial_turn: int,
-        initial_cost: float,
-    ) -> None:
-        self._config_service = config_service
-        self._initial_turn = initial_turn
-        self._initial_cost = initial_cost
-
-    def should_continue(
-        self, turn_count: int, cumulative_cost: float, interactive: bool
-    ) -> tuple[bool, Optional[str]]:
-        if interactive:
-            return True, None
-
-        if not self._config_service.get_setting("yolo_guardrails.enabled", True):
-            return True, None
-
-        max_turns = int(
-            self._config_service.get_setting("yolo_guardrails.max_turns", 99) or 99
-        )
-        max_cost = float(
-            self._config_service.get_setting("yolo_guardrails.max_session_cost", 5.0)
-            or 5.0
-        )
-
-        turn_delta = turn_count - self._initial_turn
-        cost_delta = cumulative_cost - self._initial_cost
-
-        if turn_delta >= max_turns:
-            config_path = self._config_service.get_config_path()
-            import os as _os
-
-            rel_path = _os.path.relpath(config_path)
-            return False, (
-                f"YOLO turn limit reached: {turn_delta}/{max_turns} turns in this run.\n"
-                f"To change this limit, set 'yolo_guardrails.max_turns' in {rel_path}."
-            )
-
-        if cost_delta >= max_cost:
-            config_path = self._config_service.get_config_path()
-            import os as _os
-
-            rel_path = _os.path.relpath(config_path)
-            return False, (
-                f"YOLO cost limit reached: ${cost_delta:.2f}/${max_cost:.2f} in this run.\n"
-                f"To change this limit, set 'yolo_guardrails.max_session_cost' in {rel_path}."
-            )
-
-        return True, None