teddy-cli 0.1.0__py3-none-any.whl

teddy_executor/container.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import punq
+
+
+from teddy_executor.registries.infrastructure import register_infrastructure
+from teddy_executor.registries.reviewer import register_reviewer
+from teddy_executor.registries.validators import register_validators
+
+_container = None
+
+
+def get_container():
+    global _container
+    if _container is None:
+        _container = create_container()
+    return _container
+
+
+def create_container() -> punq.Container:
+    """
+    Creates and configures the dependency injection container.
+    """
+    container = punq.Container()
+    register_infrastructure(container)
+    register_validators(container)
+    _register_services(container)
+    _register_orchestration(container)
+    return container
+
+
+def _register_services(container: punq.Container) -> None:
+    """Registers core application services."""
+    from teddy_executor.core.ports.inbound.edit_simulator import IEditSimulator
+    from teddy_executor.core.ports.inbound.plan_parser import IPlanParser
+    from teddy_executor.core.ports.outbound import (
+        IConfigService,
+        IFileSystemManager,
+        IMarkdownReportFormatter,
+        IUserInteractor,
+    )
+    from teddy_executor.core.services.action_dispatcher import (
+        ActionDispatcher,
+        IActionFactory,
+    )
+    from teddy_executor.core.services.action_executor import ActionExecutor
+    from teddy_executor.core.services.action_factory import ActionFactory
+    from teddy_executor.core.services.edit_simulator import EditSimulator
+    from teddy_executor.core.ports.outbound.session_repository import (
+        ISessionRepository,
+    )
+    from teddy_executor.core.services.session_repository import SessionRepository
+    from teddy_executor.core.services.markdown_plan_parser import MarkdownPlanParser
+    from teddy_executor.core.services.markdown_report_formatter import (
+        MarkdownReportFormatter,
+    )
+    from teddy_executor.core.services.session_loop_guard import (
+        ProductionSessionLoopGuard,
+    )
+    from teddy_executor.core.domain.models.action_ports import ActionPorts
+
+    container.register(
+        ISessionRepository,
+        factory=lambda: SessionRepository(container.resolve(IFileSystemManager)),
+        scope=punq.Scope.transient,
+    )
+    container.register(IEditSimulator, EditSimulator, scope=punq.Scope.transient)
+    container.register(IPlanParser, MarkdownPlanParser, scope=punq.Scope.transient)
+
+    register_reviewer(container)
+
+    from teddy_executor.core.ports.outbound import (
+        IShellExecutor,
+        IWebScraper,
+        IWebSearcher,
+    )
+    from teddy_executor.core.ports.outbound.session_loop_guard import ISessionLoopGuard
+
+    container.register(
+        IActionFactory,
+        factory=lambda: ActionFactory(
+            ports=ActionPorts(
+                shell_executor=container.resolve(IShellExecutor),
+                file_system_manager=container.resolve(IFileSystemManager),
+                user_interactor=container.resolve(IUserInteractor),
+                web_scraper=container.resolve(IWebScraper),
+                web_searcher=container.resolve(IWebSearcher),
+                config_service=container.resolve(IConfigService),
+            )
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(ActionDispatcher, scope=punq.Scope.transient)
+    container.register(
+        ActionExecutor,
+        factory=lambda: ActionExecutor(
+            action_dispatcher=container.resolve(ActionDispatcher),
+            user_interactor=container.resolve(IUserInteractor),
+            file_system_manager=container.resolve(IFileSystemManager),
+            edit_simulator=container.resolve(IEditSimulator),
+            config_service=container.resolve(IConfigService),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(
+        IMarkdownReportFormatter, MarkdownReportFormatter, scope=punq.Scope.transient
+    )
+
+    container.register(
+        ISessionLoopGuard, ProductionSessionLoopGuard, scope=punq.Scope.transient
+    )
+    _register_orchestration_services(container)
+
+
+def _register_orchestration_services(container: punq.Container) -> None:
+    """Registers orchestration and use case implementation services."""
+    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.plan_parser import IPlanParser
+    from teddy_executor.core.ports.inbound.plan_validator import IPlanValidator
+    from teddy_executor.core.ports.inbound.plan_reviewer import IPlanReviewer
+    from teddy_executor.core.ports.outbound import (
+        IConfigService,
+        IFileSystemManager,
+        ILlmClient,
+        ISessionManager,
+        IUserInteractor,
+    )
+    from teddy_executor.core.ports.outbound.execution_report_assembler import (
+        IExecutionReportAssembler,
+    )
+    from teddy_executor.core.services.action_executor import ActionExecutor
+    from teddy_executor.core.services.context_service import ContextService
+    from teddy_executor.core.services.execution_orchestrator import (
+        ExecutionOrchestrator,
+    )
+    from teddy_executor.core.services.execution_report_assembler import (
+        ExecutionReportAssembler,
+    )
+    from teddy_executor.core.services.init_service import InitService
+    from teddy_executor.core.ports.outbound.prompt_manager import IPromptManager
+    from teddy_executor.core.services.prompt_manager import PromptManager
+    from teddy_executor.core.services.planning_service import PlanningService
+    from teddy_executor.core.services.session_service import SessionService
+
+    container.register(
+        IExecutionReportAssembler, ExecutionReportAssembler, scope=punq.Scope.transient
+    )
+    from teddy_executor.core.domain.models.orchestrator_ports import OrchestratorPorts
+
+    container.register(
+        OrchestratorPorts,
+        factory=lambda: OrchestratorPorts(
+            plan_parser=container.resolve(IPlanParser),
+            plan_validator=container.resolve(IPlanValidator),
+            action_executor=container.resolve(ActionExecutor),
+            file_system_manager=container.resolve(IFileSystemManager),
+            report_assembler=container.resolve(IExecutionReportAssembler),
+            user_interactor=container.resolve(IUserInteractor),
+            plan_reviewer=container.resolve(IPlanReviewer),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(ExecutionOrchestrator, scope=punq.Scope.transient)
+    from teddy_executor.core.ports.outbound import (
+        IEnvironmentInspector,
+        IRepoTreeGenerator,
+        IWebScraper,
+    )
+
+    container.register(
+        ContextService,
+        factory=lambda: ContextService(
+            file_system_manager=container.resolve(IFileSystemManager),
+            repo_tree_generator=container.resolve(IRepoTreeGenerator),
+            environment_inspector=container.resolve(IEnvironmentInspector),
+            llm_client=container.resolve(ILlmClient),
+            web_scraper=container.resolve(IWebScraper),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(IGetContextUseCase, ContextService, scope=punq.Scope.transient)
+    from teddy_executor.core.domain.models.planning_ports import PlanningPorts
+
+    container.register(
+        IPromptManager,
+        factory=lambda: PromptManager(
+            file_system_manager=container.resolve(IFileSystemManager),
+            user_interactor=container.resolve(IUserInteractor),
+        ),
+        scope=punq.Scope.transient,
+    )
+
+    container.register(
+        PlanningPorts,
+        factory=lambda: PlanningPorts(
+            context=container.resolve(IGetContextUseCase),
+            llm=container.resolve(ILlmClient),
+            fs=container.resolve(IFileSystemManager),
+            config=container.resolve(IConfigService),
+            prompts=container.resolve(IPromptManager),
+            ui=container.resolve(IUserInteractor),
+            session_manager=container.resolve(ISessionManager),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(PlanningService, scope=punq.Scope.transient)
+    container.register(IPlanningUseCase, PlanningService, scope=punq.Scope.transient)
+    from teddy_executor.core.ports.outbound.session_repository import ISessionRepository
+    from teddy_executor.core.ports.outbound.time_service import ITimeService
+
+    container.register(
+        IInitUseCase,
+        factory=lambda: InitService(container.resolve(IFileSystemManager)),
+        scope=punq.Scope.transient,
+    )
+
+    container.register(
+        ISessionManager,
+        factory=lambda: SessionService(
+            file_system_manager=container.resolve(IFileSystemManager),
+            repository=container.resolve(ISessionRepository),
+            time_service=container.resolve(ITimeService),
+            prompt_manager=container.resolve(IPromptManager),
+            init_service=container.resolve(IInitUseCase),
+            config_service=container.resolve(IConfigService),
+        ),
+        scope=punq.Scope.transient,
+    )
+
+
+def _register_orchestration(container: punq.Container) -> None:
+    """Registers session orchestration components."""
+    from teddy_executor.core.ports.inbound.get_context_use_case import (
+        IGetContextUseCase,
+    )
+    from teddy_executor.core.ports.inbound.run_plan_use_case import IRunPlanUseCase
+    from teddy_executor.core.ports.inbound.planning_use_case import IPlanningUseCase
+    from teddy_executor.core.ports.inbound.plan_parser import IPlanParser
+    from teddy_executor.core.ports.inbound.plan_validator import IPlanValidator
+    from teddy_executor.core.ports.outbound import (
+        IConfigService,
+        IFileSystemManager,
+        ILlmClient,
+        IMarkdownReportFormatter,
+        ISessionManager,
+        IUserInteractor,
+    )
+    from teddy_executor.core.ports.outbound.prompt_manager import IPromptManager
+    from teddy_executor.core.services.execution_orchestrator import (
+        ExecutionOrchestrator,
+    )
+    from teddy_executor.core.services.session_lifecycle_manager import (
+        SessionLifecycleManager,
+    )
+    from teddy_executor.core.services.session_orchestrator import SessionOrchestrator
+    from teddy_executor.core.services.session_planner import SessionPlanner
+    from teddy_executor.core.services.session_replanner import SessionReplanner
+    from teddy_executor.core.services.session_pruning_service import (
+        SessionPruningService,
+    )
+
+    container.register(
+        SessionPruningService,
+        factory=lambda: SessionPruningService(
+            config_service=container.resolve(IConfigService),
+            file_system_manager=container.resolve(IFileSystemManager),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(
+        SessionReplanner,
+        factory=lambda: SessionReplanner(
+            file_system_manager=container.resolve(IFileSystemManager),
+            planning_service=container.resolve(IPlanningUseCase),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(
+        SessionPlanner,
+        factory=lambda: SessionPlanner(
+            file_system_manager=container.resolve(IFileSystemManager),
+            planning_service=container.resolve(IPlanningUseCase),
+            user_interactor=container.resolve(IUserInteractor),
+            session_service=container.resolve(ISessionManager),
+        ),
+        scope=punq.Scope.transient,
+    )
+
+    from teddy_executor.core.domain.models.planning_ports import SessionPorts
+
+    container.register(
+        SessionPorts,
+        factory=lambda: SessionPorts(
+            session_service=container.resolve(ISessionManager),
+            file_system_manager=container.resolve(IFileSystemManager),
+            report_formatter=container.resolve(IMarkdownReportFormatter),
+            user_interactor=container.resolve(IUserInteractor),
+            session_planner=container.resolve(SessionPlanner),
+            replanner=container.resolve(SessionReplanner),
+        ),
+        scope=punq.Scope.transient,
+    )
+    container.register(
+        SessionLifecycleManager,
+        factory=lambda: SessionLifecycleManager(
+            ports=container.resolve(SessionPorts),
+        ),
+        scope=punq.Scope.transient,
+    )
+
+    container.register(
+        IRunPlanUseCase,
+        factory=lambda: SessionOrchestrator(
+            execution_orchestrator=container.resolve(ExecutionOrchestrator),
+            session_service=container.resolve(ISessionManager),
+            file_system_manager=container.resolve(IFileSystemManager),
+            plan_validator=container.resolve(IPlanValidator),
+            plan_parser=container.resolve(IPlanParser),
+            user_interactor=container.resolve(IUserInteractor),
+            lifecycle_manager=container.resolve(SessionLifecycleManager),
+            replanner=container.resolve(SessionReplanner),
+            context_service=container.resolve(IGetContextUseCase),
+            config_service=container.resolve(IConfigService),
+            llm_client=container.resolve(ILlmClient),
+            prompt_manager=container.resolve(IPromptManager),
+            pruning_service=container.resolve(SessionPruningService),
+        ),
+        scope=punq.Scope.transient,
+    )

teddy_executor/core/domain/models/__init__.py

@@ -0,0 +1,44 @@
+from .execution_report import (
+    ActionLog,
+    ActionStatus,
+    ExecutionReport,
+    RunStatus,
+    RunSummary,
+)
+from .plan import ActionData, ActionType, Plan
+from .exceptions import (
+    FileAlreadyExistsError,
+    MultipleMatchesFoundError,
+    SearchTextNotFoundError,
+    WebSearchError,
+)
+from .web_search_results import QueryResult
+from .web_search_results import SearchResult
+from .web_search_results import WebSearchResults
+from .change_set import ChangeSet
+from .project_context import ContextItem, ProjectContext
+from .report_assembly_data import ReportAssemblyData
+from .action_ports import ActionPorts
+
+__all__ = [
+    "ActionPorts",
+    "ChangeSet",
+    "ContextItem",
+    "ProjectContext",
+    "ReportAssemblyData",
+    "Plan",
+    "ActionData",
+    "ActionType",
+    "ExecutionReport",
+    "ActionLog",
+    "RunSummary",
+    "RunStatus",
+    "ActionStatus",
+    "FileAlreadyExistsError",
+    "MultipleMatchesFoundError",
+    "SearchTextNotFoundError",
+    "WebSearchError",
+    "WebSearchResults",
+    "QueryResult",
+    "SearchResult",
+]

teddy_executor/core/domain/models/action_ports.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from teddy_executor.core.ports.outbound import (
+        IShellExecutor,
+        IFileSystemManager,
+        IUserInteractor,
+        IWebScraper,
+        IWebSearcher,
+        IConfigService,
+    )
+
+
+@dataclass(frozen=True)
+class ActionPorts:
+    """
+    A data transfer object used to group the collection of outbound ports
+    required by the ActionFactory.
+    """
+
+    shell_executor: IShellExecutor
+    file_system_manager: IFileSystemManager
+    user_interactor: IUserInteractor
+    web_scraper: IWebScraper
+    web_searcher: IWebSearcher
+    config_service: Optional[IConfigService] = None

teddy_executor/core/domain/models/change_set.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ChangeSet:
+    path: Path
+    before_content: str
+    after_content: str
+    action_type: str  # 'CREATE' or 'EDIT'

teddy_executor/core/domain/models/exceptions.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+
+class SearchTextNotFoundError(ValueError):
+    """Exception for when search text is not found during an edit operation."""
+
+    def __init__(self, message: str, content: str):
+        super().__init__(message)
+        self.content = content
+
+
+class FileAlreadyExistsError(FileExistsError):
+    """Custom exception raised when trying to create a file that already exists."""
+
+    def __init__(self, message: str, file_path: str):
+        super().__init__(message)
+        self.file_path = file_path
+
+
+class MultipleMatchesFoundError(Exception):
+    """Custom exception for when an edit operation finds multiple matches."""
+
+    def __init__(self, message: str, content: str):
+        super().__init__(message)
+        self.content = content
+
+
+class WebSearchError(Exception):
+    """Custom exception raised when a web search operation fails."""
+
+    def __init__(self, message: str, original_exception: Optional[Exception] = None):
+        super().__init__(message)
+        self.original_exception = original_exception
+
+
+class ConfigurationError(Exception):
+    """Custom exception raised when system configuration is invalid or missing."""
+
+    def __init__(self, message: str):
+        super().__init__(message)

teddy_executor/core/domain/models/execution_report.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Sequence
+
+from teddy_executor.core.domain.models.plan import ActionData
+
+
+class RunStatus(str, Enum):
+    """Overall status for an entire plan execution."""
+
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+    VALIDATION_FAILED = "VALIDATION_FAILED"
+    SKIPPED = "SKIPPED"
+    ABORTED = "ABORTED"
+
+
+class ActionStatus(str, Enum):
+    """Status for a single action within a plan."""
+
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+    SKIPPED = "SKIPPED"
+    PENDING = "PENDING"
+
+
+@dataclass(frozen=True)
+class ActionLog:
+    """Logs the result of a single action execution."""
+
+    status: ActionStatus
+    action_type: str
+    params: dict[str, Any]
+    details: Any | None = None
+    modified: bool = False
+    modified_fields: list[str] = field(default_factory=list)
+    failed_command: str | None = None
+
+
+@dataclass(frozen=True)
+class RunSummary:
+    """Summarizes the overall result of a plan execution."""
+
+    status: RunStatus
+    start_time: datetime
+    end_time: datetime
+    error: str | None = None
+
+
+@dataclass(frozen=True)
+class ExecutionReport:
+    """The comprehensive report of a plan execution."""
+
+    run_summary: RunSummary
+    plan_title: str | None = None
+    rationale: str | None = None
+    user_request: str | None = None
+    is_session: bool = False
+    metadata: dict[str, str] = field(default_factory=dict)
+    original_actions: Sequence[ActionData] = field(default_factory=list)
+    action_logs: Sequence[ActionLog] = field(default_factory=list)
+    validation_result: Sequence[str] | None = None
+    validation_ast: str | None = None
+    failed_resources: dict[str, str] | None = None

teddy_executor/core/domain/models/orchestrator_ports.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from teddy_executor.core.ports.inbound.plan_parser import IPlanParser
+    from teddy_executor.core.ports.inbound.plan_validator import IPlanValidator
+    from teddy_executor.core.ports.inbound.plan_reviewer import IPlanReviewer
+    from teddy_executor.core.ports.outbound import IFileSystemManager, IUserInteractor
+    from teddy_executor.core.ports.outbound.execution_report_assembler import (
+        IExecutionReportAssembler,
+    )
+    from teddy_executor.core.services.action_executor import ActionExecutor
+
+
+@dataclass(frozen=True)
+class OrchestratorPorts:
+    """Groups dependencies for the ExecutionOrchestrator."""
+
+    plan_parser: IPlanParser
+    plan_validator: IPlanValidator
+    action_executor: ActionExecutor
+    file_system_manager: IFileSystemManager
+    report_assembler: IExecutionReportAssembler
+    user_interactor: IUserInteractor
+    plan_reviewer: Optional[IPlanReviewer] = None

teddy_executor/core/domain/models/plan.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional, Sequence
+
+if TYPE_CHECKING:
+    from teddy_executor.core.domain.models.execution_report import ActionLog
+
+
+class ActionType(str, Enum):
+    CREATE = "CREATE"
+    READ = "READ"
+    EDIT = "EDIT"
+    EXECUTE = "EXECUTE"
+    RESEARCH = "RESEARCH"
+    MESSAGE = "MESSAGE"
+
+
+class ExecutionStatus(str, Enum):
+    """Represents the possible execution states of an action."""
+
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    SUCCESS = "SUCCESS"
+    FAILURE = "FAILURE"
+    SKIPPED = "SKIPPED"
+
+
+@dataclass
+class ActionData:
+    """Represents a single action from the plan."""
+
+    type: str
+    params: dict[str, Any]
+    description: str | None = None
+    selected: bool = True
+    modified: bool = False
+    modified_fields: list[str] = field(default_factory=list)
+    executed: bool = False
+    state: ExecutionStatus = ExecutionStatus.PENDING
+    action_log: Optional[ActionLog] = None
+    user_response: Optional[str] = None
+    pending_temp_file: Optional[str] = None
+    node: Any = None
+    similarity_score: float | None = None
+    similarity_scores: list[float] | None = None
+
+    @property
+    def is_terminal(self) -> bool:
+        """Returns True if the action is a communication action."""
+        return self.type == ActionType.MESSAGE
+
+
+@dataclass(frozen=True)
+class ValidationError:
+    """Represents a structured validation error."""
+
+    message: str
+    action_index: int = 0
+    file_path: str | None = None
+    offending_node: Any = None
+
+
+DEFAULT_SIMILARITY_THRESHOLD = 0.95
+
+
+@dataclass
+class Plan:
+    """Represents a parsed and validated execution plan."""
+
+    title: str
+    rationale: str
+    actions: Sequence[ActionData]
+    metadata: dict[str, str] = field(default_factory=dict)
+    source_doc: Any = None
+    is_session: bool = False
+    plan_path: str | None = None
+    raw_content: str | None = None
+
+    def __post_init__(self):
+        assert self.actions, "Plan must contain at least one action."
+
+    def is_communication_turn(self) -> bool:
+        """Returns True if the plan consists only of a MESSAGE action."""
+        return len(self.actions) == 1 and self.actions[0].type == ActionType.MESSAGE

teddy_executor/core/domain/models/planning_ports.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from teddy_executor.core.ports.outbound.session_manager import ISessionManager
+    from teddy_executor.core.ports.outbound.markdown_report_formatter import (
+        IMarkdownReportFormatter,
+    )
+    from teddy_executor.core.services.session_planner import SessionPlanner
+    from teddy_executor.core.services.session_replanner import SessionReplanner
+
+from teddy_executor.core.ports.inbound.get_context_use_case import IGetContextUseCase
+from teddy_executor.core.ports.outbound.config_service import IConfigService
+from teddy_executor.core.ports.outbound.file_system_manager import IFileSystemManager
+from teddy_executor.core.ports.outbound.llm_client import ILlmClient
+from teddy_executor.core.ports.outbound.prompt_manager import IPromptManager
+from teddy_executor.core.ports.outbound.user_interactor import IUserInteractor
+
+
+@dataclass(frozen=True)
+class PlanningPorts:
+    """Outbound ports required by the PlanningService."""
+
+    context: IGetContextUseCase
+    llm: ILlmClient
+    fs: IFileSystemManager
+    config: IConfigService
+    prompts: IPromptManager
+    ui: IUserInteractor
+    session_manager: ISessionManager
+
+
+@dataclass(frozen=True)
+class SessionPorts:
+    """Ports required by the SessionLifecycleManager."""
+
+    session_service: ISessionManager
+    file_system_manager: IFileSystemManager
+    report_formatter: IMarkdownReportFormatter
+    user_interactor: IUserInteractor
+    session_planner: SessionPlanner
+    replanner: SessionReplanner