teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/adapters/inbound/cli_helpers.py

@@ -0,0 +1,249 @@
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from punq import Container
+
+from teddy_executor.core.domain.models import (
+    ExecutionReport,
+    RunStatus,
+    RunSummary,
+)
+from teddy_executor.core.domain.models.plan import Plan
+from teddy_executor.core.ports.inbound.plan_parser import IPlanParser, InvalidPlanError
+from teddy_executor.core.ports.inbound.run_plan_use_case import IRunPlanUseCase
+from teddy_executor.core.ports.outbound.markdown_report_formatter import (
+    IMarkdownReportFormatter,
+)
+from teddy_executor.core.services.plan_validator import ValidationError
+
+logger = logging.getLogger(__name__)
+
+
+def find_project_root() -> Path:
+    """
+    Locates the project root by climbing up from the CWD until a .teddy directory is found.
+    Falls back to CWD if not found.
+    """
+    current = Path.cwd().resolve()
+    for parent in [current] + list(current.parents):
+        if (parent / ".teddy").is_dir():
+            return parent
+    return current
+
+
+def echo_and_copy(
+    content: str,
+    no_copy: bool = False,
+    confirmation_message: str = "Output copied to clipboard.",
+    content_to_copy: Optional[str] = None,
+):
+    """Prints content to stdout and copies it to the clipboard unless disabled."""
+    import threading
+    import os
+
+    if content:
+        typer.echo(content)
+
+    if not no_copy:
+        to_copy = content_to_copy if content_to_copy is not None else content
+        if os.getenv("TEDDY_DEBUG"):
+            typer.echo("DEBUG: Attempting clipboard copy...", err=True)
+        try:
+            # Completely detached thread. We do NOT join it at all to ensure
+            # the main process can exit even if the clipboard provider hangs.
+            def _copy():
+                import pyperclip
+
+                try:
+                    pyperclip.copy(to_copy)
+                except Exception as e:
+                    logger.debug("Background clipboard copy failed: %s", e)
+
+            thread = threading.Thread(target=_copy, daemon=True)
+            thread.start()
+            # Give the thread a small window to complete. 0.1s is enough for
+            # most healthy clipboard providers (pbcopy/xclip) without being
+            # a noticeable delay for the user.
+            thread.join(timeout=0.1)
+            typer.secho(f"\n{confirmation_message}", fg=typer.colors.GREEN, err=True)
+        except Exception as e:
+            logger.debug("Main thread clipboard handler failed: %s", e)
+
+
+def get_plan_content(plan_content_str: Optional[str], plan_file: Optional[Path]) -> str:
+    """
+    Retrieves the plan content from one of three sources, in order of priority:
+    1. A direct string via --plan-content.
+    2. A file path.
+    3. The system clipboard.
+    Exits with an error if the final source is invalid or empty.
+    """
+    if plan_content_str:
+        return plan_content_str
+
+    if plan_file:
+        if not plan_file.is_file():
+            typer.echo(f"Error: Plan file not found at '{plan_file}'", err=True)
+            raise typer.Exit(code=1)
+        return plan_file.read_text(encoding="utf-8")
+
+    import pyperclip
+
+    try:
+        plan_from_clipboard = pyperclip.paste()
+        if not plan_from_clipboard.strip():
+            typer.echo(
+                "Error: No plan provided via file or --plan-content, and clipboard is empty.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        return plan_from_clipboard
+    except Exception as e:
+        typer.echo(f"Error accessing clipboard: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+def create_failure_report(
+    e: Exception,
+    start_time: datetime,
+    container: Container,
+    plan_content: Optional[str] = None,
+) -> ExecutionReport:
+    """
+    Creates a rich ExecutionReport for a failure that occurred before or during execution.
+    """
+    error_messages = [str(e)]
+
+    if isinstance(e, InvalidPlanError) and plan_content:
+        try:
+            plan_parser = container.resolve(IPlanParser)
+            temp_plan = plan_parser.parse(plan_content)
+
+            errors_to_report = getattr(e, "validation_errors", [])
+            if errors_to_report:
+                return handle_validation_failure(
+                    temp_plan, errors_to_report, start_time
+                )
+
+            return ExecutionReport(
+                plan_title=temp_plan.title,
+                run_summary=RunSummary(
+                    status=RunStatus.VALIDATION_FAILED,
+                    start_time=start_time,
+                    end_time=datetime.now(timezone.utc),
+                    error=str(e),
+                ),
+                validation_result=error_messages,
+            )
+        except Exception as report_err:
+            logger.debug("Failed to create rich failure report: %s", report_err)
+
+    return ExecutionReport(
+        plan_title="Execution Error",
+        run_summary=RunSummary(
+            status=RunStatus.FAILURE
+            if isinstance(e, NotImplementedError)
+            else RunStatus.VALIDATION_FAILED,
+            start_time=start_time,
+            end_time=datetime.now(timezone.utc),
+            error=str(e),
+        ),
+        validation_result=error_messages,
+    )
+
+
+def handle_validation_failure(
+    plan: Plan, validation_errors: List[ValidationError], start_time: datetime
+) -> ExecutionReport:
+    """Creates an ExecutionReport for a validation failure."""
+    failed_resources: dict[str, str] = {}
+    error_messages: list[str] = []
+    for error in validation_errors:
+        error_messages.append(error.message)
+        if error.file_path:
+            try:
+                path = Path(error.file_path)
+                if path.exists():
+                    failed_resources[error.file_path] = path.read_text(encoding="utf-8")
+            except OSError as os_err:
+                logger.debug(
+                    "Failed to read failed resource %s: %s", error.file_path, os_err
+                )
+
+    return ExecutionReport(
+        plan_title=plan.title,
+        rationale=plan.rationale,
+        original_actions=plan.actions,
+        run_summary=RunSummary(
+            status=RunStatus.VALIDATION_FAILED,
+            start_time=start_time,
+            end_time=datetime.now(timezone.utc),
+        ),
+        validation_result=error_messages,
+        failed_resources=failed_resources if failed_resources else None,
+    )
+
+
+def execute_valid_plan(
+    container: Container,
+    plan: Plan,
+    interactive_mode: bool,
+    plan_meta: Optional[dict] = None,
+) -> ExecutionReport:
+    """Executes a plan that has already been parsed and validated."""
+    import sys
+
+    orchestrator = container.resolve(IRunPlanUseCase)
+    print(f"DEBUG CLI: Resolved orchestrator: {type(orchestrator)}", file=sys.stderr)
+    meta = plan_meta or {}
+    execution_report = orchestrator.execute(
+        plan=plan,
+        interactive=interactive_mode,
+        plan_path=meta.get("plan_path"),
+        plan_content=meta.get("plan_content"),
+    )
+    return execution_report
+
+
+def handle_report_output(
+    container: Container,
+    report: Optional[ExecutionReport],
+    no_copy: bool,
+    silent: bool = False,
+    exit_on_failure: bool = True,
+) -> None:
+    """Formats the report, echoes/copies it, and exits with non-zero if failed."""
+    if report:
+        report_formatter = container.resolve(IMarkdownReportFormatter)
+        formatted_report = report_formatter.format(report)
+
+        if silent:
+            # In silent mode (sessions), we don't print to stdout or copy to clipboard
+            # (R-10-12: The report is already saved to file in the session dir)
+            echo_and_copy(
+                "",
+                content_to_copy=formatted_report,
+                no_copy=True,
+            )
+        else:
+            echo_and_copy(
+                formatted_report,
+                no_copy=no_copy,
+            )
+
+        if exit_on_failure and report.run_summary.status in (
+            RunStatus.FAILURE,
+            RunStatus.VALIDATION_FAILED,
+        ):
+            raise typer.Exit(code=1)
+
+
+def apply_ui_mode_override(container: Container, ui_mode_bool: bool) -> None:
+    """Applies a UI mode override to the container."""
+    from teddy_executor.container import register_reviewer
+
+    mode = "tui" if ui_mode_bool else "console"
+    register_reviewer(container, ui_mode=mode)

teddy_executor/adapters/inbound/console_plan_reviewer.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+from typing import Optional, TYPE_CHECKING
+from teddy_executor.core.ports.inbound.plan_reviewer import IPlanReviewer
+
+if TYPE_CHECKING:
+    from teddy_executor.core.domain.models.plan import (
+        Plan,
+        ActionData,
+    )
+    from teddy_executor.core.domain.models.project_context import ProjectContext
+    from teddy_executor.core.ports.outbound import (
+        IUserInteractor,
+        IFileSystemManager,
+        IConfigService,
+    )
+    from teddy_executor.core.ports.inbound.edit_simulator import (
+        IEditSimulator,
+    )
+
+
+from teddy_executor.core.services.action_changeset_builder import ActionChangeSetBuilder
+
+
+class ConsolePlanReviewer(IPlanReviewer):
+    """
+    Inbound adapter for reviewing plans via the standard console (sequential Y/N).
+    """
+
+    def __init__(
+        self,
+        user_interactor: IUserInteractor,
+        file_system_manager: IFileSystemManager,
+        config_service: IConfigService,
+        edit_simulator: IEditSimulator,
+    ):
+        self._user_interactor = user_interactor
+        self._changeset_builder = ActionChangeSetBuilder(
+            file_system_manager, config_service, edit_simulator
+        )
+
+    def review(
+        self, plan: "Plan", project_context: Optional["ProjectContext"] = None
+    ) -> Optional["Plan"]:
+        """
+        Prints the plan header and returns immediately to proceed to actions.
+        """
+        import typer
+
+        header = f'\n▶ Reviewing Plan: "{plan.title}"'
+        typer.secho(header, fg=typer.colors.CYAN, bold=True, err=True)
+        return plan
+
+    def review_action(
+        self,
+        action: "ActionData",
+        total_actions: int,
+        agent_name: Optional[str] = None,
+    ) -> tuple[bool, str]:
+        _ = total_actions
+        _ = agent_name
+        prompt = ActionChangeSetBuilder.format_action_prompt(action)
+
+        change_set = self._changeset_builder.create_change_set(action)
+
+        approved, message = self._user_interactor.confirm_action(
+            action=action, action_prompt=prompt, change_set=change_set
+        )
+        action.selected = approved
+        return approved, message

teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -0,0 +1,366 @@
+from pathlib import Path
+from typing import Dict, Optional, Sequence
+import typer
+from punq import Container
+
+from teddy_executor.core.ports.inbound.get_context_use_case import IGetContextUseCase
+from teddy_executor.core.ports.inbound.init import IInitUseCase
+from teddy_executor.core.ports.inbound.planning_use_case import IPlanningUseCase
+from teddy_executor.core.ports.inbound.run_plan_use_case import IRunPlanUseCase
+from teddy_executor.core.ports.outbound.session_manager import ISessionManager
+from teddy_executor.core.domain.models.session import SessionOptions
+from teddy_executor.core.ports.outbound.user_interactor import IUserInteractor
+from teddy_executor.core.ports.outbound.session_loop_guard import ISessionLoopGuard
+from teddy_executor.core.ports.outbound.config_service import IConfigService
+from teddy_executor.core.ports.outbound.session_repository import ISessionRepository
+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,
+)
+
+
+def _determine_session_name(name: Optional[str], message: Optional[str]) -> str:
+    """Determine session name (slugify message if name is missing)."""
+    if name:
+        return name
+    if message:
+        return slugify(message)
+    return "session-auto"
+
+
+def _orchestrate_session_loop(
+    container: Container,
+    session_name: str,
+    interactive: bool,
+    no_copy: bool,
+) -> None:
+    """Shared turn loop for start and resume commands."""
+    from teddy_executor.adapters.inbound.cli_helpers import handle_report_output
+
+    orchestrator = container.resolve(IRunPlanUseCase)
+    session_manager = container.resolve(ISessionManager)
+
+    # Resolve initial state for process-relative guardrails
+    latest_turn_path = session_manager.get_latest_turn(session_name)
+    try:
+        # get_latest_turn returns a path string; the turn ID is the folder name
+        initial_turn = int(Path(latest_turn_path).name) if latest_turn_path else 0
+    except (ValueError, TypeError):
+        # Handle non-numeric turn names or MagicMocks in tests
+        initial_turn = 0
+
+    # Resolve initial cost for process-relative guardrails
+    initial_cost = session_manager.get_cumulative_cost(session_name)
+
+    loop_guard = container.resolve(
+        ISessionLoopGuard, initial_turn=initial_turn, initial_cost=initial_cost
+    )
+
+    turn_count = 0
+    while True:
+        turn_count += 1
+        session_name, report = orchestrator.resume(
+            session_name=session_name,
+            interactive=interactive,
+        )
+        if report is None:
+            break
+
+        # In session mode, we do NOT exit on validation failure
+        # because the orchestrator triggers an automatic re-plan.
+        handle_report_output(
+            container, report, no_copy, silent=True, exit_on_failure=False
+        )
+
+        cumulative_cost = float(report.metadata.get("cumulative_cost", 0.0))
+        if not loop_guard.should_continue(turn_count, cumulative_cost, interactive):
+            break
+
+
+def handle_new_session(  # noqa: PLR0913
+    container: Container,
+    name: Optional[str],
+    agent: str,
+    interactive: bool = True,
+    no_copy: bool = False,
+    message: Optional[str] = None,
+    additional_context: Optional[list[str]] = None,
+    model: Optional[str] = None,
+    provider: Optional[str] = None,
+    api_key: Optional[str] = None,
+):
+    """Logic for the 'start' command."""
+    try:
+        # 0. Ensure project is initialized
+        container.resolve(IInitUseCase).ensure_initialized()
+
+        # 1. Pre-flight checks (Fail-fast before user interaction)
+        typer.echo("Checking configurations...", err=True)
+        _run_cli_preflight_check(container, agent=agent)
+        _echo_config_success(container, agent, model=model)
+
+        session_manager: ISessionManager = container.resolve(ISessionManager)
+        user_interactor: IUserInteractor = container.resolve(IUserInteractor)
+
+        # 2. Resolve message first if missing
+        if message is None:
+            message = user_interactor.ask_question("What are we working on?")
+            if not message:
+                raise EOFError("No terminal input provided for initial message.")
+
+        # 2. Determine session name (slugify message if name is missing)
+        actual_name = _determine_session_name(name, message)
+        options = SessionOptions(
+            name=actual_name,
+            agent_name=agent,
+            initial_request=message,
+            additional_context=additional_context or [],
+            model=model,
+            provider=provider,
+            api_key=api_key,
+        )
+        session_dir = session_manager.create_session(options)
+        typer.echo(f"Session created at: {session_dir}")
+
+        # Streamlined Initialization: Trigger resume (which triggers planning for EMPTY state)
+        _orchestrate_session_loop(
+            container=container,
+            session_name=Path(session_dir).name,
+            interactive=interactive,
+            no_copy=no_copy,
+        )
+
+    except Exception as e:
+        from teddy_executor.core.domain.models.exceptions import ConfigurationError
+
+        if isinstance(e, ConfigurationError):
+            from teddy_executor.core.ports.outbound.config_service import IConfigService
+
+            config_service = container.resolve(IConfigService)
+            config_path = config_service.get_config_path()
+            typer.echo(f"Error: {e}", err=True)
+            typer.echo(f"Please update your configuration at: {config_path}", err=True)
+        else:
+            typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+def _echo_config_success(
+    container: Container,
+    agent: Optional[str] = None,
+    model: Optional[str] = None,
+    actual_model: Optional[str] = None,
+) -> None:
+    """Retrieves and echoes the active model and agent configuration on success.
+
+    Args:
+        container: The DI container with resolved services.
+        agent: Optional agent name to display.
+        model: Optional model override from CLI. If provided, this takes
+               precedence over the config file value.
+        actual_model: Optional actual serving model from meta.yaml. If provided,
+                      this takes precedence over the model parameter.
+    """
+    config_service = container.resolve(IConfigService)
+    if actual_model:
+        resolved_model = actual_model
+    elif model:
+        resolved_model = model
+    else:
+        resolved_model = config_service.get_setting("llm.model", "unknown")
+    msg = f"API key valid! Model: {resolved_model}"
+    if agent:
+        msg += f" | Agent: {agent}"
+    typer.echo(msg, err=True)
+
+
+def _run_cli_preflight_check(container: Container, agent: Optional[str] = None) -> None:
+    """Ensures system is configured before starting/resuming a session."""
+    from teddy_executor.core.ports.outbound.llm_client import ILlmClient
+    from teddy_executor.core.domain.models.exceptions import ConfigurationError
+    from teddy_executor.core.ports.outbound.prompt_manager import IPromptManager
+
+    llm_client = container.resolve(ILlmClient)
+    # Perform local validation only to ensure fast CLI startup.
+    # Remote connectivity is checked lazily by the PlanningService.
+    errors = llm_client.validate_config(include_remote=False)
+
+    if agent:
+        prompt_manager = container.resolve(IPromptManager)
+        if not prompt_manager.get_prompt_content(agent):
+            available = prompt_manager.get_available_agents()
+            agent_error = f"Agent prompt '{agent}' not found. Available agents: " + (
+                ", ".join(available) if available else ""
+            )
+            if not errors:
+                # Only an agent error -> plain ValueError (no config hint)
+                raise ValueError(agent_error)
+            # Prepend agent error before other errors
+            errors.insert(0, agent_error)
+
+    if not errors:
+        return
+
+    error_msg = f"Configuration Error: {', '.join(errors)}"
+    raise ConfigurationError(error_msg)
+
+
+def detect_session_context() -> Optional[Dict[str, Sequence[str]]]:
+    """Helper to detect turn and session context files."""
+    cwd = Path.cwd()
+    turn_context = cwd / "turn.context"
+    session_context = cwd.parent / "session.context"
+    meta_yaml = cwd / "meta.yaml"
+
+    if turn_context.exists() and session_context.exists() and meta_yaml.exists():
+        return {
+            "Turn": [str(turn_context)],
+            "Session": [str(session_context)],
+        }
+    return None
+
+
+def handle_plan_generation(container: Container, message: Optional[str]):
+    """Logic for the 'plan' command."""
+    try:
+        # Note: 'plan' command uses the default 'pathfinder' agent if not in a session
+        _run_cli_preflight_check(container, agent="pathfinder")
+        _echo_config_success(container)
+
+        planning_service: IPlanningUseCase = container.resolve(IPlanningUseCase)
+        context_files = detect_session_context()
+        cwd = Path.cwd()
+
+        plan_path, _ = planning_service.generate_plan(
+            user_message=message, turn_dir=str(cwd), context_files=context_files
+        )
+        typer.echo(f"Plan generated at: {plan_path}")
+    except Exception as e:
+        from teddy_executor.core.domain.models.exceptions import ConfigurationError
+
+        if isinstance(e, ConfigurationError):
+            from teddy_executor.core.ports.outbound.config_service import IConfigService
+
+            config_service = container.resolve(IConfigService)
+            config_path = config_service.get_config_path()
+            typer.echo(f"Error: {e}", err=True)
+            typer.echo(f"Please update your configuration at: {config_path}", err=True)
+        else:
+            typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+def handle_context_gathering(container: Container, no_copy: bool):
+    """Logic for the 'context' command."""
+    context_service: IGetContextUseCase = container.resolve(IGetContextUseCase)
+    context_files = detect_session_context()
+    # Performance: Formatting context for Markdown doesn't use tokens, so we skip them.
+    context_result = context_service.get_context(
+        context_files=context_files, include_tokens=False
+    )
+    formatted_context = format_project_context(context_result)
+    echo_and_copy(formatted_context, no_copy=no_copy)
+
+
+def _resolve_session_name(
+    container: Container,
+    path: Optional[str] = None,
+) -> str:
+    """Resolves the session name from a path, CWD, or auto-detection."""
+    session_manager = container.resolve(ISessionManager)
+    if path:
+        return session_manager.resolve_session_from_path(path)
+    try:
+        return session_manager.resolve_session_from_path(str(Path.cwd().resolve()))
+    except ValueError:
+        return session_manager.get_latest_session_name()
+
+
+def _sync_and_display_session_meta(
+    container: Container,
+    session_name: str,
+    model: Optional[str] = None,
+    provider: Optional[str] = None,
+    api_key: Optional[str] = None,
+) -> None:
+    """Reads latest turn meta.yaml, syncs config overrides, and clears actual_model."""
+    from teddy_executor.core.ports.outbound.config_service import IConfigService
+
+    session_manager = container.resolve(ISessionManager)
+    repository: ISessionRepository = container.resolve(ISessionRepository)
+    config_service: IConfigService = container.resolve(IConfigService)
+
+    latest_turn_path = session_manager.get_latest_turn(session_name)
+    meta = repository.load_meta(latest_turn_path)
+    # Clear actual_model so display falls through to current model (override or config)
+    meta.pop("actual_model", None)
+    _echo_config_success(container, agent=meta.get("agent_name"), model=model)
+
+    # Sync latest turn's meta.yaml with current config model/overrides
+    config_model = config_service.get_setting("llm.model", "unknown")
+    changed = False
+    if model:
+        meta["model"] = model
+        changed = True
+    elif config_model != "unknown" and meta.get("model") != config_model:
+        meta["model"] = config_model
+        changed = True
+    if provider:
+        meta["provider"] = provider
+        changed = True
+    if api_key:
+        meta["api_key"] = api_key
+        changed = True
+    if changed:
+        repository.save_meta(f"{latest_turn_path}/meta.yaml", meta)
+
+
+def handle_resume_session(  # noqa: PLR0913
+    container: Container,
+    path: Optional[str] = None,
+    interactive: bool = True,
+    no_copy: bool = False,
+    model: Optional[str] = None,
+    provider: Optional[str] = None,
+    api_key: Optional[str] = None,
+):
+    """Logic for the 'resume' command."""
+    try:
+        # 1. Pre-flight checks
+        typer.echo("Checking configurations...", err=True)
+        _run_cli_preflight_check(container)
+
+        # 2. Resolve session name
+        session_name = _resolve_session_name(container, path)
+
+        # 3. Display session path
+        session_relative_path = str(Path(".teddy") / "sessions" / session_name)
+        typer.echo(f"Resuming session: {session_relative_path}")
+
+        # 4. Display actual_model and sync config overrides
+        _sync_and_display_session_meta(
+            container, session_name, model=model, provider=provider, api_key=api_key
+        )
+
+        # 5. Enter the session loop
+        _orchestrate_session_loop(
+            container=container,
+            session_name=session_name,
+            interactive=interactive,
+            no_copy=no_copy,
+        )
+
+    except Exception as e:
+        from teddy_executor.core.domain.models.exceptions import ConfigurationError
+
+        if isinstance(e, ConfigurationError):
+            from teddy_executor.core.ports.outbound.config_service import IConfigService
+
+            config_service = container.resolve(IConfigService)
+            config_path = config_service.get_config_path()
+            typer.echo(f"Error: {e}", err=True)
+            typer.echo(f"Please update your configuration at: {config_path}", err=True)
+        else:
+            typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)