tapps-agents 3.5.39__py3-none-any.whl → 3.5.41__py3-none-any.whl

tapps_agents/simple_mode/code_snippet_handler.py

@@ -0,0 +1,382 @@
+"""
+Code Snippet Handler - Detect and handle pasted code in user input.
+
+Detects markdown code blocks, creates temporary files in scratchpad directory,
+and integrates with workflow suggester for automatic *fix workflow invocation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import re
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+# Language to file extension mapping
+LANGUAGE_EXTENSIONS: dict[str, str] = {
+    "python": ".py",
+    "py": ".py",
+    "javascript": ".js",
+    "js": ".js",
+    "typescript": ".ts",
+    "ts": ".ts",
+    "java": ".java",
+    "go": ".go",
+    "rust": ".rs",
+    "rs": ".rs",
+    "c": ".c",
+    "cpp": ".cpp",
+    "c++": ".cpp",
+    "csharp": ".cs",
+    "cs": ".cs",
+    "ruby": ".rb",
+    "rb": ".rb",
+    "php": ".php",
+    "swift": ".swift",
+    "kotlin": ".kt",
+    "scala": ".scala",
+    "shell": ".sh",
+    "bash": ".sh",
+    "sh": ".sh",
+    "sql": ".sql",
+    "html": ".html",
+    "css": ".css",
+    "json": ".json",
+    "yaml": ".yaml",
+    "yml": ".yml",
+    "xml": ".xml",
+    "markdown": ".md",
+    "md": ".md",
+    "text": ".txt",
+    "txt": ".txt",
+}
+
+
+# Markdown code fence pattern
+MARKDOWN_CODE_FENCE_PATTERN = r"```(?P<lang>\w+)?\s*\n(?P<code>.*?)```"
+
+
+@dataclass(frozen=True, slots=True)
+class CodeSnippet:
+    """
+    Detected code snippet with metadata.
+
+    Attributes:
+        code: The extracted code content
+        language: Detected language (or 'txt' if unknown)
+        extension: File extension for the language
+        confidence: Detection confidence (0.0-1.0)
+    """
+
+    code: str
+    language: str
+    extension: str
+    confidence: float
+
+
+@dataclass(frozen=True, slots=True)
+class TempFile:
+    """
+    Temporary file information.
+
+    Attributes:
+        path: Full path to the temporary file
+        filename: Just the filename
+        language: Detected language
+        created_at: Timestamp when file was created
+    """
+
+    path: Path
+    filename: str
+    language: str
+    created_at: float
+
+
+class CodeSnippetHandler:
+    """
+    Handler for detecting and processing pasted code snippets.
+
+    Detects markdown code blocks in user input, creates temporary files
+    in the scratchpad directory, and prepares for workflow integration.
+    """
+
+    def __init__(self, scratchpad_dir: Optional[Path] = None):
+        """
+        Initialize code snippet handler.
+
+        Args:
+            scratchpad_dir: Path to scratchpad directory for temp files.
+                If None, uses default Claude Code scratchpad location.
+        """
+        self._logger = logging.getLogger(__name__)
+
+        # Use provided scratchpad or default location
+        if scratchpad_dir is None:
+            # Default Claude Code scratchpad location
+            import tempfile
+            import os
+
+            base_temp = Path(tempfile.gettempdir())
+            claude_dir = base_temp / "claude"
+
+            # Try to find existing Claude directory with session ID
+            if claude_dir.exists():
+                # Look for subdirectories (session IDs)
+                session_dirs = [d for d in claude_dir.iterdir() if d.is_dir()]
+                if session_dirs:
+                    # Use first session directory found
+                    scratchpad_dir = session_dirs[0] / "scratchpad"
+                else:
+                    # Create default session directory
+                    scratchpad_dir = claude_dir / "default" / "scratchpad"
+            else:
+                # Create default Claude directory structure
+                scratchpad_dir = claude_dir / "default" / "scratchpad"
+
+        self.scratchpad_dir = Path(scratchpad_dir)
+        self._logger.debug(f"Scratchpad directory: {self.scratchpad_dir}")
+
+        # Ensure scratchpad directory exists
+        try:
+            self.scratchpad_dir.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            self._logger.warning(
+                f"Could not create scratchpad directory {self.scratchpad_dir}: {e}"
+            )
+
+    def detect_code_snippet(self, user_input: str) -> Optional[CodeSnippet]:
+        """
+        Detect code snippet in user input.
+
+        Searches for markdown code fences (```lang...```) and extracts
+        the code content and language.
+
+        Args:
+            user_input: User's natural language input
+
+        Returns:
+            CodeSnippet if code block detected, None otherwise
+
+        Example:
+            >>> handler = CodeSnippetHandler()
+            >>> result = handler.detect_code_snippet('''
+            ... Fix this code:
+            ... ```python
+            ... def add(a, b):
+            ...     return a / b
+            ... ```
+            ... ''')
+            >>> result.language
+            'python'
+            >>> result.code
+            'def add(a, b):\\n    return a / b\\n'
+        """
+        if not user_input or not isinstance(user_input, str):
+            return None
+
+        try:
+            # Search for markdown code fence
+            match = re.search(
+                MARKDOWN_CODE_FENCE_PATTERN,
+                user_input,
+                re.DOTALL | re.IGNORECASE
+            )
+
+            if not match:
+                return None
+
+            # Extract language and code
+            language = match.group("lang")
+            code = match.group("code")
+
+            # Normalize language
+            if language:
+                language = language.lower().strip()
+            else:
+                language = "txt"  # Default if no language specified
+
+            # Get file extension
+            extension = LANGUAGE_EXTENSIONS.get(language, ".txt")
+
+            # Validate code is not empty
+            if not code or not code.strip():
+                self._logger.debug("Code block detected but empty")
+                return None
+
+            # High confidence if language specified and code non-empty
+            confidence = 0.95 if match.group("lang") else 0.80
+
+            return CodeSnippet(
+                code=code.strip(),
+                language=language,
+                extension=extension,
+                confidence=confidence
+            )
+
+        except Exception as e:
+            self._logger.error(f"Error detecting code snippet: {e}", exc_info=True)
+            return None
+
+    def generate_temp_filename(
+        self,
+        language: str,
+        extension: str,
+        code_content: str
+    ) -> str:
+        """
+        Generate unique temporary filename.
+
+        Uses timestamp and hash of code content to ensure uniqueness.
+
+        Args:
+            language: Detected language
+            extension: File extension
+            code_content: The code content (used for hash)
+
+        Returns:
+            Unique filename like "pasted_code_1234567890_abc123.py"
+
+        Example:
+            >>> handler = CodeSnippetHandler()
+            >>> filename = handler.generate_temp_filename("python", ".py", "code")
+            >>> filename.startswith("pasted_code_")
+            True
+            >>> filename.endswith(".py")
+            True
+        """
+        # Generate timestamp
+        timestamp = int(time.time())
+
+        # Generate hash of code content
+        code_hash = hashlib.md5(code_content.encode('utf-8')).hexdigest()[:8]
+
+        # Construct filename
+        filename = f"pasted_code_{timestamp}_{code_hash}{extension}"
+
+        return filename
+
+    def create_temp_file(self, snippet: CodeSnippet) -> Optional[TempFile]:
+        """
+        Create temporary file with code snippet content.
+
+        Writes the code snippet to a uniquely named file in the
+        scratchpad directory.
+
+        Args:
+            snippet: CodeSnippet to write to file
+
+        Returns:
+            TempFile with file information, or None if creation failed
+
+        Example:
+            >>> handler = CodeSnippetHandler()
+            >>> snippet = CodeSnippet(
+            ...     code="print('hello')",
+            ...     language="python",
+            ...     extension=".py",
+            ...     confidence=0.95
+            ... )
+            >>> temp_file = handler.create_temp_file(snippet)
+            >>> temp_file.path.exists()
+            True
+        """
+        try:
+            # Generate unique filename
+            filename = self.generate_temp_filename(
+                snippet.language,
+                snippet.extension,
+                snippet.code
+            )
+
+            # Construct full path
+            file_path = self.scratchpad_dir / filename
+
+            # Write code to file
+            file_path.write_text(snippet.code, encoding='utf-8')
+
+            self._logger.info(f"Created temp file: {file_path}")
+
+            return TempFile(
+                path=file_path,
+                filename=filename,
+                language=snippet.language,
+                created_at=time.time()
+            )
+
+        except Exception as e:
+            self._logger.error(
+                f"Failed to create temp file: {e}",
+                exc_info=True
+            )
+            return None
+
+    def detect_and_create_temp_file(
+        self,
+        user_input: str
+    ) -> Optional[TempFile]:
+        """
+        Detect code snippet and create temporary file in one step.
+
+        Convenience method that combines detection and file creation.
+
+        Args:
+            user_input: User's natural language input
+
+        Returns:
+            TempFile if code detected and file created, None otherwise
+
+        Example:
+            >>> handler = CodeSnippetHandler()
+            >>> temp_file = handler.detect_and_create_temp_file('''
+            ... ```python
+            ... def hello():
+            ...     print("world")
+            ... ```
+            ... ''')
+            >>> temp_file is not None
+            True
+        """
+        # Detect code snippet
+        snippet = self.detect_code_snippet(user_input)
+        if snippet is None:
+            return None
+
+        # Create temp file
+        temp_file = self.create_temp_file(snippet)
+        return temp_file
+
+
+# Convenience function for workflow integration
+def detect_pasted_code(user_input: str) -> Optional[TempFile]:
+    """
+    Detect pasted code and create temporary file.
+
+    Convenience function for use in workflow suggester and other modules.
+
+    Args:
+        user_input: User's natural language input
+
+    Returns:
+        TempFile if code detected and file created, None otherwise
+
+    Example:
+        >>> temp_file = detect_pasted_code('''
+        ... Fix this code:
+        ... ```python
+        ... def bad_code():
+        ...     return 1 / 0
+        ... ```
+        ... ''')
+        >>> temp_file is not None
+        True
+        >>> temp_file.language
+        'python'
+    """
+    handler = CodeSnippetHandler()
+    return handler.detect_and_create_temp_file(user_input)

tapps_agents/simple_mode/intent_parser.py

@@ -379,17 +379,42 @@ class IntentParser:
             intent_type = IntentType.UNKNOWN
             confidence = 0.0
 
-        # Detect "compare to codebase" intent
+        # Detect "compare to codebase" intent with enhanced semantics
         compare_to_codebase = False
         compare_phrases = [
+            # Direct compare phrases
             "compare to",
             "compare with",
+            "compare against",
+            "compare this to",
+            "compare this with",
+            "compare to codebase",
+            "compare to our",
+            "compare to project",
+            # Match/align phrases
             "match our",
+            "match the",
+            "match patterns",
+            "match codebase",
             "align with",
+            "align to",
             "follow patterns",
-            "match patterns",
-            "compare to codebase",
-            "compare to our",
+            "follow our patterns",
+            "follow project patterns",
+            # Make match phrases (implicit compare)
+            "make match",
+            "make this match",
+            "make it match",
+            # Consistency phrases
+            "consistent with",
+            "consistency with",
+            "conform to",
+            "conform with",
+            # Standard phrases
+            "match standards",
+            "follow standards",
+            "meet standards",
+            "adhere to",
         ]
         if any(phrase in input_lower for phrase in compare_phrases):
             compare_to_codebase = True

tapps_agents/simple_mode/orchestrators/base.py

@@ -1,59 +1,185 @@
-"""
-Base orchestrator interface for Simple Mode.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from tapps_agents.core.config import ProjectConfig
-
-if TYPE_CHECKING:
-    from ..intent_parser import Intent
-
-
-class SimpleModeOrchestrator(ABC):
-    """Base class for Simple Mode orchestrators."""
-
-    def __init__(
-        self,
-        project_root: Path | None = None,
-        config: ProjectConfig | None = None,
-    ):
-        """
-        Initialize orchestrator.
-
-        Args:
-            project_root: Project root directory
-            config: Optional project configuration
-        """
-        self.project_root = project_root or Path.cwd()
-        self.config = config
-
-    @abstractmethod
-    async def execute(
-        self, intent: Intent, parameters: dict[str, Any] | None = None
-    ) -> dict[str, Any]:
-        """
-        Execute the orchestrator's workflow.
-
-        Args:
-            intent: Parsed user intent
-            parameters: Additional parameters from user input
-
-        Returns:
-            Dictionary with execution results
-        """
-        pass
-
-    def get_agent_sequence(self) -> list[str]:
-        """
-        Get the sequence of agents this orchestrator coordinates.
-
-        Returns:
-            List of agent names in execution order
-        """
-        return []
-
+"""
+Base orchestrator interface for Simple Mode.
+
+Integrates optional hook system: UserPromptSubmit before workflow,
+PostToolUse after implementer tool use, WorkflowComplete after workflow ends.
+Hooks are opt-in (no behavior change when hooks disabled).
+"""
+
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from tapps_agents.core.config import ProjectConfig
+
+if TYPE_CHECKING:
+    from ..intent_parser import Intent
+
+logger = logging.getLogger(__name__)
+
+
+def _get_hook_manager(project_root: Path) -> Any:
+    """
+    Load HookManager for project if hooks are configured.
+
+    Returns None when hooks.yaml is missing or has no enabled hooks (opt-in).
+    """
+    try:
+        from tapps_agents.hooks.config import load_hooks_config
+        from tapps_agents.hooks.manager import HookManager
+
+        config = load_hooks_config(project_root=project_root)
+        has_any = any(
+            any(h.enabled for h in hooks)
+            for hooks in config.hooks.values()
+        )
+        if not has_any:
+            return None
+        return HookManager(project_root=project_root)
+    except Exception as e:  # pylint: disable=broad-except
+        logger.debug("Hooks not loaded (opt-in): %s", e)
+        return None
+
+
+class SimpleModeOrchestrator(ABC):
+    """Base class for Simple Mode orchestrators."""
+
+    def __init__(
+        self,
+        project_root: Path | None = None,
+        config: ProjectConfig | None = None,
+    ):
+        """
+        Initialize orchestrator.
+
+        Args:
+            project_root: Project root directory
+            config: Optional project configuration
+        """
+        self.project_root = project_root or Path.cwd()
+        self.config = config
+        self._hook_manager = None  # Lazy-loaded when needed
+
+    def _get_hook_manager(self) -> Any:
+        """Return HookManager if hooks are enabled for this project; else None."""
+        if self._hook_manager is None:
+            self._hook_manager = _get_hook_manager(self.project_root)
+        return self._hook_manager
+
+    def _trigger_user_prompt_submit(
+        self,
+        prompt: str,
+        workflow_type: str | None = None,
+    ) -> None:
+        """
+        Fire UserPromptSubmit hook before workflow execution.
+
+        No-op when hooks disabled or no hooks configured for this event.
+        """
+        mgr = self._get_hook_manager()
+        if not mgr:
+            return
+        try:
+            from tapps_agents.hooks.events import UserPromptSubmitEvent
+
+            payload = UserPromptSubmitEvent(
+                prompt=prompt,
+                project_root=str(self.project_root),
+                workflow_type=workflow_type,
+            )
+            mgr.trigger("UserPromptSubmit", payload)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.debug("UserPromptSubmit hook error (non-fatal): %s", e)
+
+    def _trigger_post_tool_use(
+        self,
+        tool_name: str,
+        file_path: str | None,
+        file_paths: list[str] | None = None,
+        workflow_id: str | None = None,
+    ) -> None:
+        """
+        Fire PostToolUse hook after implementer Write/Edit.
+
+        No-op when hooks disabled or no matching hooks.
+        """
+        mgr = self._get_hook_manager()
+        if not mgr:
+            return
+        try:
+            from tapps_agents.hooks.events import PostToolUseEvent
+
+            payload = PostToolUseEvent(
+                file_path=file_path,
+                file_paths=file_paths or ([file_path] if file_path else []),
+                tool_name=tool_name,
+                project_root=str(self.project_root),
+                workflow_id=workflow_id,
+            )
+            mgr.trigger(
+                "PostToolUse",
+                payload,
+                tool_name=tool_name,
+                file_path=file_path,
+            )
+        except Exception as e:  # pylint: disable=broad-except
+            logger.debug("PostToolUse hook error (non-fatal): %s", e)
+
+    def _trigger_workflow_complete(
+        self,
+        workflow_type: str,
+        workflow_id: str,
+        status: str,
+        beads_issue_id: str | None = None,
+    ) -> None:
+        """
+        Fire WorkflowComplete hook after workflow ends.
+
+        status: 'completed', 'failed', or 'cancelled'.
+        No-op when hooks disabled.
+        """
+        mgr = self._get_hook_manager()
+        if not mgr:
+            return
+        try:
+            from tapps_agents.hooks.events import WorkflowCompleteEvent
+
+            payload = WorkflowCompleteEvent(
+                workflow_type=workflow_type,
+                workflow_id=workflow_id,
+                status=status,
+                project_root=str(self.project_root),
+                beads_issue_id=beads_issue_id,
+            )
+            mgr.trigger("WorkflowComplete", payload)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.debug("WorkflowComplete hook error (non-fatal): %s", e)
+
+    @abstractmethod
+    async def execute(
+        self, intent: Intent, parameters: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
+        """
+        Execute the orchestrator's workflow.
+
+        Args:
+            intent: Parsed user intent
+            parameters: Additional parameters from user input
+
+        Returns:
+            Dictionary with execution results
+        """
+        pass
+
+    def get_agent_sequence(self) -> list[str]:
+        """
+        Get the sequence of agents this orchestrator coordinates.
+
+        Returns:
+            List of agent names in execution order
+        """
+        return []
+