teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/core/services/planning_service.py

@@ -0,0 +1,242 @@
+from pathlib import Path
+from typing import Any, Dict, Optional, Sequence
+from teddy_executor.core.ports.inbound.planning_use_case import IPlanningUseCase
+
+
+class PlanningService(IPlanningUseCase):
+    """
+    Orchestrates context gathering and LLM interaction to generate plans.
+    """
+
+    from teddy_executor.core.domain.models.planning_ports import PlanningPorts
+
+    def __init__(self, ports: PlanningPorts):
+        self._context_service = ports.context
+        self._llm_client = ports.llm
+        self._file_system_manager = ports.fs
+        self._config_service = ports.config
+        self._prompt_manager = ports.prompts
+        self._user_interactor = ports.ui
+        self._session_manager = ports.session_manager
+
+    def generate_plan(
+        self,
+        user_message: Optional[str],
+        turn_dir: str,
+        context_files: Optional[Dict[str, Sequence[str]]] = None,
+    ) -> tuple[str, float]:
+        """Generates a new plan.md file."""
+        import re
+
+        turn_path = Path(turn_dir)
+        agent_name, meta, meta_file_path = self._prompt_manager.resolve_agent_metadata(
+            turn_path
+        )
+
+        if self._user_interactor:
+            session_folder = turn_path.parent.name
+            natural_name = re.sub(r"^\d{8}_\d{6}-", "", session_folder)
+            msg = f"\n[cyan][{turn_path.name}] {natural_name} | Waiting for {agent_name} to respond...[/cyan]"
+            self._user_interactor.display_message(msg)
+
+        self._run_preflight_check()
+
+        # Defensive resolution of context manifests from turn_dir
+        resolved_context_files = context_files
+        if resolved_context_files is None and self._session_manager:
+            plan_path = (turn_path / "plan.md").as_posix()
+            # Mypy: dict is invariant, so dict[str, list] != dict[str, Sequence]
+            resolved_context_files = self._session_manager.resolve_context_paths(  # type: ignore[assignment]
+                plan_path
+            )
+        # Resolve message to capture user intent in meta.yaml
+        resolved_message = self._prompt_manager.resolve_message(user_message, turn_path)
+
+        if resolved_message is not None:
+            if not meta.get("is_replan"):
+                meta["user_request"] = resolved_message
+
+        system_prompt = self._prompt_manager.fetch_system_prompt(agent_name, turn_path)
+
+        # Compute system prompt token count BEFORE context construction so the
+        # ProjectContext DTO is born with correct data (no post-hoc patching needed).
+        model = str(
+            meta.get("model") or self._config_service.get_setting("llm.model") or ""
+        )
+        try:
+            system_token_count = self._llm_client.get_text_token_count(
+                system_prompt, model=model
+            )
+        except Exception:
+            system_token_count = 0
+
+        context = self._context_service.get_context(
+            context_files=resolved_context_files,
+            agent_name=agent_name,
+            current_turn=Path(turn_dir).name,
+            system_prompt_tokens=system_token_count,
+        )
+
+        # Context is purely project state (including initial_request.md via session.context).
+        full_context = f"{context.header}\n{context.content}"
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {
+                "role": "user",
+                "content": full_context,
+            },
+        ]
+
+        self._file_system_manager.write_file(
+            (turn_path / "input.md").as_posix(), full_context
+        )
+
+        model = str(
+            meta.get("model") or self._config_service.get_setting("llm.model") or ""
+        )
+
+        # Pre-emptive Hydration: Trigger hydration via get_context_window BEFORE counting tokens.
+        # This ensures the model is known to the registry so token counting and telemetry work.
+        if self._user_interactor:
+            # We call this for the side-effect of triggering hydration in Turn 1
+            self._llm_client.get_context_window(model=model)
+
+        token_count = int(
+            self._safe_float(self._llm_client.get_token_count(messages=messages))
+        )
+
+        if self._user_interactor:
+            self._display_telemetry(meta, token_count)
+
+        response, plan_content, turn_cost = self._perform_generation_with_retry(
+            messages,
+            model=model,
+            provider=meta.get("provider"),
+            api_key=meta.get("api_key"),
+        )
+
+        cost_val = self._prompt_manager.log_telemetry(token_count, turn_cost)
+        plan_path = (turn_path / "plan.md").as_posix()
+        self._file_system_manager.write_file(plan_path, plan_content)
+        # Pre-populate meta["model"] before update_meta to ensure the user-configured
+        # model (with routing prefix like openrouter/) is preserved.
+        # This prevents the bug where meta["model"] was missing on first turn (no --model flag)
+        # and update_meta overwrote it with the bare actual model.
+        meta.setdefault("model", model)
+        self._prompt_manager.update_meta(
+            meta, response, token_count, turn_cost, meta_file_path
+        )
+
+        return plan_path, cost_val
+
+    def _perform_generation_with_retry(
+        self,
+        messages: list[Dict[str, str]],
+        model: str,
+        provider: Optional[str] = None,
+        api_key: Optional[str] = None,
+    ) -> tuple[Any, str, float]:
+        """Implements retry loop for empty LLM content."""
+        max_retries_val = self._config_service.get_setting("llm.max_retries")
+        max_retries = int(max_retries_val) if max_retries_val is not None else 3
+        response = None
+        plan_content = ""
+        turn_cost = 0.0
+
+        # Construct overrides dict for kwargs
+        overrides = {}
+        if provider:
+            overrides["provider"] = provider
+        if api_key:
+            overrides["api_key"] = api_key
+
+        for attempt in range(max_retries):
+            response = self._llm_client.get_completion(
+                messages=messages, model=model, **overrides
+            )
+            plan_content = self._extract_plan_content(response)
+            turn_cost = self._llm_client.get_completion_cost(
+                response, model_override=model
+            )
+
+            if plan_content and plan_content.strip():
+                break
+
+            if attempt < max_retries - 1 and self._user_interactor:
+                self._user_interactor.display_message(
+                    f"[yellow]Empty response received (Attempt {attempt + 1}/{max_retries}). Retrying...[/yellow]"
+                )
+
+        return response, plan_content, turn_cost
+
+    # Class-level cache to ensure remote preflight is performed exactly once per process.
+    # This eliminates the 10s timeout lag on subsequent turns in a session.
+    _PREFLIGHT_DONE = False
+
+    @classmethod
+    def reset_preflight(cls) -> None:
+        """Resets the preflight cache (used primarily for testing)."""
+        cls._PREFLIGHT_DONE = False
+
+    def _run_preflight_check(self) -> None:
+        """Ensures system is configured before attempting generation."""
+        from teddy_executor.core.domain.models.exceptions import ConfigurationError
+
+        # Perform local validation only. Remote connectivity is checked lazily
+        # by the LLM client during actual generation. This ensures fast CLI startup
+        # and eliminates redundant remote lag for sessions.
+        errors = self._llm_client.validate_config(include_remote=False)
+
+        if not errors:
+            PlanningService._PREFLIGHT_DONE = True
+            return
+
+        error_msg = f"Configuration Error: {', '.join(errors)}"
+        raise ConfigurationError(error_msg)
+
+    def _extract_plan_content(self, response: Any) -> str:
+        """Robustly extracts content from the LLM response object."""
+        if hasattr(response, "choices") and len(response.choices) > 0:
+            return getattr(response.choices[0].message, "content", "") or ""
+        return ""
+
+    def _display_telemetry(self, meta: Dict[str, Any], token_count: int) -> None:
+        """Displays real-time telemetry about the upcoming LLM call."""
+        model = str(
+            meta.get("actual_model")
+            or meta.get("model")
+            or self._config_service.get_setting("llm.model")
+            or "unknown"
+        )
+        context_window = self._safe_float(
+            self._llm_client.get_context_window(model=model)
+        )
+        cumulative_cost = self._safe_float(meta.get("cumulative_cost"))
+
+        self._user_interactor.display_message(
+            f"[blue]• Model:[/blue] [magenta]{model}[/magenta]"
+        )
+
+        window_str = f"{context_window / 1000:.1f}k" if context_window > 0 else "???"
+        self._user_interactor.display_message(
+            f"[blue]• Context:[/blue] [magenta]{token_count / 1000:.1f}k / {window_str} tokens[/magenta]"
+        )
+
+        pricing_supported = self._llm_client.supports_pricing(model=model)
+        cost_str = (
+            f"${cumulative_cost:.4f}"
+            if context_window > 0 and pricing_supported
+            else "$???"
+        )
+        self._user_interactor.display_message(
+            f"[blue]• Session Cost:[/blue] [magenta]{cost_str}[/magenta]\n"
+        )
+
+    def _safe_float(self, v: Any, default: float = 0.0) -> float:
+        """Robust conversion to float, handling mocks and strings."""
+        try:
+            if hasattr(v, "__float__"):
+                return float(v)
+            return float(str(v))
+        except (TypeError, ValueError):
+            return default

teddy_executor/core/services/prompt_manager.py

@@ -0,0 +1,146 @@
+from pathlib import Path
+from typing import Any, Dict, Optional
+import yaml
+from teddy_executor.core.ports.outbound.file_system_manager import IFileSystemManager
+from teddy_executor.core.ports.outbound.user_interactor import IUserInteractor
+from teddy_executor.core.ports.outbound.prompt_manager import IPromptManager
+from teddy_executor.core.utils.serialization import scrub_dict_for_serialization
+
+
+class PromptManager(IPromptManager):
+    """
+    Service for resolving agent configuration, system prompts, and user messages.
+    """
+
+    def __init__(
+        self,
+        file_system_manager: IFileSystemManager,
+        user_interactor: IUserInteractor = None,  # type: ignore
+    ):
+        self._file_system_manager = file_system_manager
+        self._user_interactor = user_interactor
+
+    def get_prompt_content(self, agent_name: str) -> Optional[str]:
+        """Synchronously retrieves the raw content of an agent prompt."""
+        from teddy_executor.prompts import find_prompt_content
+
+        return find_prompt_content(agent_name)
+
+    def get_available_agents(self) -> list[str]:
+        """Returns the list of available agent names from .teddy/prompts/."""
+        prompts_dir = ".teddy/prompts/"
+        if not self._file_system_manager.path_exists(prompts_dir):
+            return []
+        files = self._file_system_manager.list_directory(prompts_dir)
+        return sorted((Path(f).stem for f in files), key=str.casefold)
+
+    def resolve_agent_metadata(
+        self, turn_path: Path
+    ) -> tuple[str, Dict[str, Any], str]:
+        meta_file_path = (turn_path / "meta.yaml").as_posix()
+        meta_content = ""
+        if self._file_system_manager.path_exists(meta_file_path):
+            meta_content = self._file_system_manager.read_file(meta_file_path)
+
+        meta = yaml.safe_load(str(meta_content))
+        if not isinstance(meta, dict):
+            meta = {}
+        return meta.get("agent_name", "pathfinder"), meta, meta_file_path
+
+    def resolve_message(
+        self, user_message: Optional[str], turn_path: Path
+    ) -> Optional[str]:
+        # If message is an empty string, it's a continuation signal.
+        if user_message == "":
+            return ""
+
+        resolved = user_message
+        if resolved is None and turn_path.name == "01":
+            # Check for initial_request.md at session root (turn_path.parent)
+            # This only acts as a fallback for the very first turn.
+            request_path = (turn_path.parent / "initial_request.md").as_posix()
+            if self._file_system_manager.path_exists(request_path):
+                resolved = self._file_system_manager.read_file(request_path)
+
+        if resolved is not None and not resolved.strip():
+            # User provided empty input at the prompt (just hit enter) -> Exit
+            return None
+
+        return resolved
+
+    def _find_prompt_file(self, directory: str, agent_name: str) -> Optional[str]:
+        """Searches a directory for a file with the given agent name (any extension)."""
+        if not self._file_system_manager.path_exists(directory):
+            return None
+        for f in self._file_system_manager.list_directory(directory):
+            if Path(f).stem.casefold() == agent_name.casefold():
+                return f"{directory}/{f}"
+        return None
+
+    def fetch_system_prompt(self, agent_name: str, turn_path: Path) -> str:
+        # 1. Try Session-Root override (Current standard)
+        session_root_prompt = self._find_prompt_file(
+            turn_path.parent.as_posix(), agent_name
+        )
+        if session_root_prompt:
+            return self._file_system_manager.read_file(session_root_prompt)
+
+        # 2. Try .teddy/prompts/ (canonical source, user-editable)
+        teddy_prompt_dir = (
+            turn_path.parent.parent.parent.parent / ".teddy" / "prompts"
+        ).as_posix()
+        teddy_prompt_path = self._find_prompt_file(teddy_prompt_dir, agent_name)
+        if teddy_prompt_path:
+            return self._file_system_manager.read_file(teddy_prompt_path)
+
+        import logging
+
+        logging.getLogger(__name__).warning(
+            "PromptManager: Failed to resolve system prompt for agent '%s' (searched %s and %s)",
+            agent_name,
+            session_root_prompt,
+            teddy_prompt_path,
+        )
+        return ""
+
+    def log_telemetry(self, token_count: Any, turn_cost: Any) -> float:
+        def safe_float(v: Any, default: float = 0.0) -> float:
+            try:
+                return float(v)
+            except (TypeError, ValueError):
+                return default
+
+        return safe_float(turn_cost)
+
+    def update_meta(
+        self,
+        meta: Dict[str, Any],
+        response: Any,
+        token_count: int,
+        turn_cost: float,
+        meta_file_path: str,
+    ) -> None:
+        try:
+            meta["turn_cost"] = float(turn_cost)
+            meta["token_count"] = int(token_count)
+        except (TypeError, ValueError):
+            meta["turn_cost"] = meta.get("turn_cost", 0.0)
+            meta["token_count"] = meta.get("token_count", 0)
+
+        # Preserve the user-configured model (with routing prefix) for routing.
+        # Store the actual serving model separately for telemetry.
+        actual_model = str(getattr(response, "model", "unknown"))
+        if "model" not in meta or meta.get("model") == actual_model:
+            meta["model"] = actual_model
+        meta["actual_model"] = actual_model
+
+        # Capture finish_reason; scrub_dict_for_serialization will neutralize mocks
+        if hasattr(response, "choices") and len(response.choices) > 0:
+            meta["finish_reason"] = getattr(
+                response.choices[0], "finish_reason", "unknown"
+            )
+
+        serializable_meta = scrub_dict_for_serialization(meta)
+        self._file_system_manager.write_file(
+            meta_file_path, yaml.dump(serializable_meta)
+        )

teddy_executor/core/services/session_lifecycle_manager.py

@@ -0,0 +1,228 @@
+import logging
+from pathlib import Path
+from typing import Any, Optional, TYPE_CHECKING
+
+import yaml
+from teddy_executor.core.domain.models.execution_report import ExecutionReport
+
+from typing import Sequence
+
+from teddy_executor.core.ports.inbound.run_plan_use_case import IRunPlanUseCase
+from teddy_executor.core.ports.outbound.session_manager import SessionState
+from teddy_executor.core.utils.io import Tee as _Tee
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from teddy_executor.core.domain.models.planning_ports import (
+        SessionPorts,
+    )
+    from teddy_executor.core.domain.models.plan import Plan
+
+    _ = SessionPorts
+
+
+class SessionLifecycleManager:
+    """
+    Manages the lifecycle of session turns, including finalization,
+    resume state machine, and automated re-plan coordination.
+    """
+
+    tee_active = False  # Class-level default for mock spec compatibility
+
+    def __init__(self, ports: "SessionPorts"):
+        self._session_service = ports.session_service
+        self._file_system_manager = ports.file_system_manager
+        self._report_formatter = ports.report_formatter
+        self._user_interactor = ports.user_interactor
+        self._session_planner = ports.session_planner
+        self._replanner = ports.replanner
+        self.tee_active = False
+
+    def resume(
+        self,
+        session_name: str,
+        orchestrator: IRunPlanUseCase,
+        interactive: bool = True,
+        project_context: Optional[Any] = None,
+    ) -> tuple[str, Optional[ExecutionReport]]:
+        """Implements the 'resume' state machine.
+
+        Returns:
+            A tuple (actual_session_name, report). The actual_session_name
+            may differ from the input session_name after a centennial
+            migration (when the session transitions to a continuation name
+            like 'my-session-2').
+        """
+        state, turn_path = self._session_service.get_session_state(session_name)
+
+        if state == SessionState.PENDING_PLAN:
+            plan_path = f"{turn_path}/plan.md"
+            report = orchestrator.execute(
+                plan_path=plan_path,
+                interactive=interactive,
+                project_context=project_context,
+            )
+            return (session_name, report)
+
+        if state == SessionState.EMPTY:
+            return self._handle_planning_and_execution(
+                turn_path,
+                orchestrator,
+                interactive,
+                project_context=project_context,
+            )
+
+        if state == SessionState.COMPLETE_TURN:
+            next_turn_dir = self._session_service.transition_to_next_turn(
+                plan_path=f"{turn_path}/plan.md"
+            )
+            return self._handle_planning_and_execution(
+                next_turn_dir,
+                orchestrator,
+                interactive,
+                project_context=project_context,
+            )
+
+        return (session_name, None)
+
+    def _handle_planning_and_execution(
+        self,
+        turn_dir: str,
+        orchestrator: IRunPlanUseCase,
+        interactive: bool,
+        project_context: Optional[Any] = None,
+    ) -> tuple[str, Optional[ExecutionReport]]:
+        """Triggers planning for a turn and then executes the resulting plan.
+
+        Tee is installed before planning to capture all output (turn headers,
+        metadata, planning logs) into history.log. The installation is guarded
+        by tee_active to prevent double installation.
+
+        Returns:
+            A tuple (actual_session_name, report). The actual_session_name
+            is the session name returned by trigger_new_plan, which may
+            differ from the original session name after a centennial
+            migration.
+        """
+        # Install Tee to capture planning output before trigger_new_plan
+        tee = None
+        if not self.tee_active:
+            try:
+                log_path = str(Path(turn_dir).parent / "history.log")
+                # Defensive guard: never write history.log to project root
+                resolved = str(Path(log_path).resolve())
+                project_root = str(Path.cwd().resolve())
+                if resolved.rstrip("/") == project_root.rstrip("/"):
+                    safe_dir = str(Path(turn_dir).parent.parent / ".tmp")
+                    self._file_system_manager.create_directory(safe_dir)
+                    log_path = str(Path(safe_dir) / "history.log")
+                log_file = self._file_system_manager.open_file_for_append(log_path)
+                tee = _Tee(log_file)
+                tee.__enter__()
+                self.tee_active = True
+            except Exception:
+                logger.warning("Failed to install Tee in lifecycle manager")
+                tee = None
+
+        try:
+            # Print initial request before turn header (before planning)
+            from teddy_executor.core.services.session_orchestrator import (
+                _print_initial_request,
+            )
+
+            if Path(turn_dir).name == "01":
+                _print_initial_request(None, True, plan_path=Path(turn_dir).as_posix())
+            new_name = self._session_planner.trigger_new_plan(turn_dir)
+            if not new_name or new_name == "CANCELLED":
+                return (turn_dir, None)
+            _, actual_turn_path = self._session_service.get_session_state(new_name)
+            report = orchestrator.execute(
+                plan_path=f"{actual_turn_path}/plan.md",
+                interactive=interactive,
+                project_context=project_context,
+            )
+            return (new_name, report)
+        finally:
+            self.tee_active = False
+            if tee is not None:
+                try:
+                    tee.__exit__(None, None, None)
+                except Exception:
+                    logger.exception("Failed to clean up Tee in lifecycle manager")
+
+    def trigger_replan(  # noqa: PLR0913
+        self,
+        plan_path: str,
+        errors: list[str],
+        original_plan_content: str,
+        title: str = "Unknown Plan",
+        rationale: str = "Structural Error",
+        failed_resources: Optional[dict[str, str]] = None,
+        is_session: bool = False,
+        validation_ast: Optional[str] = None,
+        original_actions: Optional[Sequence[Any]] = None,
+        plan: Optional["Plan"] = None,
+    ) -> ExecutionReport:
+        """Triggers the Automated Re-plan Loop."""
+        self._user_interactor.display_message(
+            "[yellow]Validation failed... replanning[/yellow]"
+        )
+        report = self._replanner.build_failure_report(
+            errors,
+            title,
+            rationale,
+            failed_resources or {},
+            validation_ast=validation_ast,
+            original_actions=original_actions,
+            is_session=is_session,
+        )
+        next_turn_dir = self.finalize_turn(
+            plan_path, report, is_validation_failure=True, plan=plan
+        )
+
+        self._replanner.trigger_replan_turn(
+            next_turn_dir, errors, original_plan_content, validation_ast=validation_ast
+        )
+        return report
+
+    def finalize_turn(
+        self,
+        plan_path: str,
+        report: ExecutionReport,
+        is_validation_failure: bool = False,
+        plan: Optional[Any] = None,
+    ) -> str:
+        """Persists the report and transitions to the next turn."""
+        turn_dir = Path(plan_path).parent
+        meta_path = turn_dir / "meta.yaml"
+
+        # Read current cost from meta.yaml
+        turn_cost = 0.0
+        if self._file_system_manager.path_exists(str(meta_path)):
+            meta_content = self._file_system_manager.read_file(str(meta_path))
+            meta_loaded = yaml.safe_load(str(meta_content))
+            meta = meta_loaded if isinstance(meta_loaded, dict) else {}
+            turn_cost = meta.get("turn_cost", 0.0)
+
+        # 1. Persist the report to the current turn directory
+        formatted_report = self._report_formatter.format(report)
+        # Use root-relative path for report persistence to ensure context discovery
+        report_file_path = self._session_service.to_root_relative(turn_dir, "report.md")
+        self._file_system_manager.write_file(report_file_path, formatted_report)
+
+        # Extract manual pruning paths from plan metadata
+        pruned_paths = []
+        if plan:
+            raw_pruned = plan.metadata.get("pruned_context", "")
+            if raw_pruned:
+                pruned_paths = [p.strip() for p in raw_pruned.split(",") if p.strip()]
+
+        # 2. Transition to next turn
+        return self._session_service.transition_to_next_turn(
+            plan_path=plan_path,
+            execution_report=report,
+            turn_cost=turn_cost,
+            is_validation_failure=is_validation_failure,
+            pruned_paths=pruned_paths,
+        )

teddy_executor/core/services/session_loop_guard.py

@@ -0,0 +1,46 @@
+from teddy_executor.core.ports.outbound import IConfigService
+from teddy_executor.core.ports.outbound.session_loop_guard import ISessionLoopGuard
+
+
+class ProductionSessionLoopGuard(ISessionLoopGuard):
+    """
+    Production implementation: always continues unless manually interrupted.
+    """
+
+    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
+    ) -> bool:
+        if interactive:
+            return True
+
+        if not self._config_service.get_setting("yolo_guardrails.enabled", True):
+            return True
+
+        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:
+            return False
+
+        if cost_delta >= max_cost:
+            return False
+
+        return True