tapps-agents 3.5.40__py3-none-any.whl → 3.6.0__py3-none-any.whl

tapps_agents/hooks/manager.py

@@ -1,143 +1,143 @@
-"""
-Hook manager: lifecycle, registration by event, and triggering.
-
-Loads hooks from config, runs them via the executor with payload-derived env,
-and supports PostToolUse filtering by matcher and file_patterns.
-"""
-
-from __future__ import annotations
-
-import fnmatch
-import re
-from pathlib import Path
-from typing import Any, Protocol
-
-from .config import HookDefinition, HooksConfig, load_hooks_config
-from .executor import HookResult, run_hook
-
-
-class _PayloadProtocol(Protocol):
-    """Payload must provide to_env() for hook execution."""
-
-    def to_env(self) -> dict[str, str]: ...
-    def to_dict(self) -> dict[str, Any]: ...
-
-
-def _tool_matches(hook: HookDefinition, tool_name: str) -> bool:
-    """True if hook has no matcher or tool_name matches the matcher regex."""
-    if not hook.matcher:
-        return True
-    try:
-        return re.search(hook.matcher, tool_name) is not None
-    except re.error:
-        return False
-
-
-def _file_matches(hook: HookDefinition, file_path: str | None) -> bool:
-    """True if hook has no file_patterns or file_path matches any pattern."""
-    if not hook.file_patterns or not file_path:
-        return True
-    name = Path(file_path).name
-    for pattern in hook.file_patterns:
-        if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(file_path, pattern):
-            return True
-    return False
-
-
-def _filter_post_tool_use(
-    hooks: list[HookDefinition],
-    tool_name: str,
-    file_path: str | None,
-) -> list[HookDefinition]:
-    """Filter PostToolUse hooks by matcher and file_patterns."""
-    return [
-        h
-        for h in hooks
-        if _tool_matches(h, tool_name) and _file_matches(h, file_path)
-    ]
-
-
-class HookManager:
-    """
-    Loads and triggers hooks by event type.
-
-    Hooks are loaded from .tapps-agents/hooks.yaml (or explicit path).
-    Trigger invokes all enabled hooks for the event with payload-derived env.
-    """
-
-    def __init__(
-        self,
-        config: HooksConfig | None = None,
-        *,
-        config_path: Path | str | None = None,
-        project_root: Path | None = None,
-        timeout_seconds: int | None = None,
-    ) -> None:
-        """
-        Initialize manager from config or load from path.
-
-        Args:
-            config: Pre-loaded config. If None, loads from config_path/project_root.
-            config_path: Path to hooks.yaml (used when config is None).
-            project_root: Project root for loading config and running hooks.
-            timeout_seconds: Override default hook timeout.
-        """
-        self._project_root = Path(project_root) if project_root else Path.cwd()
-        self._timeout_seconds = timeout_seconds
-        if config is not None:
-            self._config = config
-        else:
-            self._config = load_hooks_config(
-                config_path=config_path,
-                project_root=self._project_root,
-            )
-
-    def _get_hooks_for_event(self, event_name: str) -> list[HookDefinition]:
-        """Return enabled hooks for the event."""
-        hooks = self._config.hooks.get(event_name, [])
-        return [h for h in hooks if h.enabled]
-
-    def trigger(
-        self,
-        event_name: str,
-        payload: _PayloadProtocol,
-        *,
-        tool_name: str | None = None,
-        file_path: str | None = None,
-    ) -> list[HookResult]:
-        """
-        Run all hooks registered for the event with payload env.
-
-        For PostToolUse, only hooks matching tool_name and file_path (matcher
-        and file_patterns) are run.
-
-        Args:
-            event_name: One of UserPromptSubmit, PostToolUse, SessionStart,
-                SessionEnd, WorkflowComplete.
-            payload: Event payload with to_env() returning TAPPS_* dict.
-            tool_name: For PostToolUse, the tool that was used (e.g. Write, Edit).
-            file_path: For PostToolUse, the affected file path.
-
-        Returns:
-            List of HookResult in execution order. Caller can check fail_on_error
-            and result.success to decide whether to fail the workflow.
-        """
-        hooks = self._get_hooks_for_event(event_name)
-        if event_name == "PostToolUse" and (tool_name is not None or file_path is not None):
-            hooks = _filter_post_tool_use(hooks, tool_name or "", file_path)
-        env = payload.to_env()
-        results: list[HookResult] = []
-        for hook in hooks:
-            result = run_hook(
-                hook,
-                env,
-                timeout_seconds=self._timeout_seconds,
-                project_root=self._project_root,
-            )
-            results.append(result)
-            if hook.fail_on_error and not result.success:
-                raise RuntimeError(
-                    f"Hook {hook.name} failed (fail_on_error=True): "
-                    f"returncode={result.returncode}, stderr={result.stderr[:200]!r}"
-                )
-        return results
+"""
+Hook manager: lifecycle, registration by event, and triggering.
+
+Loads hooks from config, runs them via the executor with payload-derived env,
+and supports PostToolUse filtering by matcher and file_patterns.
+"""
+
+from __future__ import annotations
+
+import fnmatch
+import re
+from pathlib import Path
+from typing import Any, Protocol
+
+from .config import HookDefinition, HooksConfig, load_hooks_config
+from .executor import HookResult, run_hook
+
+
+class _PayloadProtocol(Protocol):
+    """Payload must provide to_env() for hook execution."""
+
+    def to_env(self) -> dict[str, str]: ...
+    def to_dict(self) -> dict[str, Any]: ...
+
+
+def _tool_matches(hook: HookDefinition, tool_name: str) -> bool:
+    """True if hook has no matcher or tool_name matches the matcher regex."""
+    if not hook.matcher:
+        return True
+    try:
+        return re.search(hook.matcher, tool_name) is not None
+    except re.error:
+        return False
+
+
+def _file_matches(hook: HookDefinition, file_path: str | None) -> bool:
+    """True if hook has no file_patterns or file_path matches any pattern."""
+    if not hook.file_patterns or not file_path:
+        return True
+    name = Path(file_path).name
+    for pattern in hook.file_patterns:
+        if fnmatch.fnmatch(name, pattern) or fnmatch.fnmatch(file_path, pattern):
+            return True
+    return False
+
+
+def _filter_post_tool_use(
+    hooks: list[HookDefinition],
+    tool_name: str,
+    file_path: str | None,
+) -> list[HookDefinition]:
+    """Filter PostToolUse hooks by matcher and file_patterns."""
+    return [
+        h
+        for h in hooks
+        if _tool_matches(h, tool_name) and _file_matches(h, file_path)
+    ]
+
+
+class HookManager:
+    """
+    Loads and triggers hooks by event type.
+
+    Hooks are loaded from .tapps-agents/hooks.yaml (or explicit path).
+    Trigger invokes all enabled hooks for the event with payload-derived env.
+    """
+
+    def __init__(
+        self,
+        config: HooksConfig | None = None,
+        *,
+        config_path: Path | str | None = None,
+        project_root: Path | None = None,
+        timeout_seconds: int | None = None,
+    ) -> None:
+        """
+        Initialize manager from config or load from path.
+
+        Args:
+            config: Pre-loaded config. If None, loads from config_path/project_root.
+            config_path: Path to hooks.yaml (used when config is None).
+            project_root: Project root for loading config and running hooks.
+            timeout_seconds: Override default hook timeout.
+        """
+        self._project_root = Path(project_root) if project_root else Path.cwd()
+        self._timeout_seconds = timeout_seconds
+        if config is not None:
+            self._config = config
+        else:
+            self._config = load_hooks_config(
+                config_path=config_path,
+                project_root=self._project_root,
+            )
+
+    def _get_hooks_for_event(self, event_name: str) -> list[HookDefinition]:
+        """Return enabled hooks for the event."""
+        hooks = self._config.hooks.get(event_name, [])
+        return [h for h in hooks if h.enabled]
+
+    def trigger(
+        self,
+        event_name: str,
+        payload: _PayloadProtocol,
+        *,
+        tool_name: str | None = None,
+        file_path: str | None = None,
+    ) -> list[HookResult]:
+        """
+        Run all hooks registered for the event with payload env.
+
+        For PostToolUse, only hooks matching tool_name and file_path (matcher
+        and file_patterns) are run.
+
+        Args:
+            event_name: One of UserPromptSubmit, PostToolUse, SessionStart,
+                SessionEnd, WorkflowComplete.
+            payload: Event payload with to_env() returning TAPPS_* dict.
+            tool_name: For PostToolUse, the tool that was used (e.g. Write, Edit).
+            file_path: For PostToolUse, the affected file path.
+
+        Returns:
+            List of HookResult in execution order. Caller can check fail_on_error
+            and result.success to decide whether to fail the workflow.
+        """
+        hooks = self._get_hooks_for_event(event_name)
+        if event_name == "PostToolUse" and (tool_name is not None or file_path is not None):
+            hooks = _filter_post_tool_use(hooks, tool_name or "", file_path)
+        env = payload.to_env()
+        results: list[HookResult] = []
+        for hook in hooks:
+            result = run_hook(
+                hook,
+                env,
+                timeout_seconds=self._timeout_seconds,
+                project_root=self._project_root,
+            )
+            results.append(result)
+            if hook.fail_on_error and not result.success:
+                raise RuntimeError(
+                    f"Hook {hook.name} failed (fail_on_error=True): "
+                    f"returncode={result.returncode}, stderr={result.stderr[:200]!r}"
+                )
+        return results

tapps_agents/integration/__init__.py

@@ -1,8 +1,8 @@
-"""
-Service Integration Automation
-"""
-
-from .service_integrator import ServiceIntegrator
-
-__all__ = ["ServiceIntegrator"]
-
+"""
+Service Integration Automation
+"""
+
+from .service_integrator import ServiceIntegrator
+
+__all__ = ["ServiceIntegrator"]
+

tapps_agents/integration/service_integrator.py

@@ -1,121 +1,121 @@
-"""
-Service Integration Generator
-
-Automates service-to-service integration (client classes, config, DI).
-"""
-
-import logging
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class ServiceIntegrator:
-    """
-    Automates service-to-service integration.
-
-    Generates:
-    - HTTP client classes for target service
-    - Config file updates with service URLs
-    - Dependency injection setup
-    - Docker Compose updates
-    - Integration tests
-    """
-
-    def __init__(self, project_root: Path | None = None):
-        """Initialize service integrator."""
-        self.project_root = project_root or Path.cwd()
-
-    def integrate(
-        self, source_service: str, target_service: str
-    ) -> dict[str, Any]:
-        """
-        Integrate two services.
-
-        Args:
-            source_service: Service that will call target
-            target_service: Service to integrate with
-
-        Returns:
-            Integration results
-        """
-        results: dict[str, Any] = {"files_created": [], "files_updated": []}
-
-        # Generate client class
-        client_result = self._generate_client_class(source_service, target_service)
-        results["files_created"].append(client_result)
-
-        # Update config
-        config_result = self._update_config(source_service, target_service)
-        results["files_updated"].append(config_result)
-
-        # Update docker-compose
-        compose_result = self._update_docker_compose(target_service)
-        if compose_result:
-            results["files_updated"].append(compose_result)
-
-        return results
-
-    def _generate_client_class(
-        self, source_service: str, target_service: str
-    ) -> dict[str, Any]:
-        """Generate HTTP client class."""
-        source_path = self.project_root / "services" / source_service
-        client_file = source_path / "src" / f"{target_service.replace('-', '_')}_client.py"
-
-        client_content = f'''"""
-{target_service} HTTP Client
-"""
-
-import httpx
-from typing import Any
-
-class {target_service.replace('-', '_').title().replace('_', '')}Client:
-    """HTTP client for {target_service} service."""
-
-    def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip("/")
-        self.client = httpx.AsyncClient()
-
-    async def health_check(self) -> dict[str, Any]:
-        """Check service health."""
-        response = await self.client.get(f"{{self.base_url}}/health")
-        response.raise_for_status()
-        return response.json()
-
-    async def close(self):
-        """Close the client."""
-        await self.client.aclose()
-'''
-        client_file.parent.mkdir(parents=True, exist_ok=True)
-        client_file.write_text(client_content, encoding="utf-8")
-
-        return {"file": str(client_file), "type": "client_class"}
-
-    def _update_config(
-        self, source_service: str, target_service: str
-    ) -> dict[str, Any]:
-        """Update service config."""
-        source_path = self.project_root / "services" / source_service
-        config_file = source_path / "src" / "config.py"
-
-        if config_file.exists():
-            content = config_file.read_text(encoding="utf-8")
-            # Add target service URL
-            if f"{target_service}_url" not in content:
-                content += f'\n    {target_service.replace("-", "_")}_url: str = "http://{target_service}:8000"'
-                config_file.write_text(content, encoding="utf-8")
-
-        return {"file": str(config_file), "type": "config"}
-
-    def _update_docker_compose(self, target_service: str) -> dict[str, Any] | None:
-        """Update docker-compose.yml."""
-        compose_file = self.project_root / "docker-compose.yml"
-        if not compose_file.exists():
-            return None
-
-        # Would need to parse and update YAML
-        # For now, just return
-        return {"file": str(compose_file), "type": "docker_compose"}
-
+"""
+Service Integration Generator
+
+Automates service-to-service integration (client classes, config, DI).
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class ServiceIntegrator:
+    """
+    Automates service-to-service integration.
+
+    Generates:
+    - HTTP client classes for target service
+    - Config file updates with service URLs
+    - Dependency injection setup
+    - Docker Compose updates
+    - Integration tests
+    """
+
+    def __init__(self, project_root: Path | None = None):
+        """Initialize service integrator."""
+        self.project_root = project_root or Path.cwd()
+
+    def integrate(
+        self, source_service: str, target_service: str
+    ) -> dict[str, Any]:
+        """
+        Integrate two services.
+
+        Args:
+            source_service: Service that will call target
+            target_service: Service to integrate with
+
+        Returns:
+            Integration results
+        """
+        results: dict[str, Any] = {"files_created": [], "files_updated": []}
+
+        # Generate client class
+        client_result = self._generate_client_class(source_service, target_service)
+        results["files_created"].append(client_result)
+
+        # Update config
+        config_result = self._update_config(source_service, target_service)
+        results["files_updated"].append(config_result)
+
+        # Update docker-compose
+        compose_result = self._update_docker_compose(target_service)
+        if compose_result:
+            results["files_updated"].append(compose_result)
+
+        return results
+
+    def _generate_client_class(
+        self, source_service: str, target_service: str
+    ) -> dict[str, Any]:
+        """Generate HTTP client class."""
+        source_path = self.project_root / "services" / source_service
+        client_file = source_path / "src" / f"{target_service.replace('-', '_')}_client.py"
+
+        client_content = f'''"""
+{target_service} HTTP Client
+"""
+
+import httpx
+from typing import Any
+
+class {target_service.replace('-', '_').title().replace('_', '')}Client:
+    """HTTP client for {target_service} service."""
+
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip("/")
+        self.client = httpx.AsyncClient()
+
+    async def health_check(self) -> dict[str, Any]:
+        """Check service health."""
+        response = await self.client.get(f"{{self.base_url}}/health")
+        response.raise_for_status()
+        return response.json()
+
+    async def close(self):
+        """Close the client."""
+        await self.client.aclose()
+'''
+        client_file.parent.mkdir(parents=True, exist_ok=True)
+        client_file.write_text(client_content, encoding="utf-8")
+
+        return {"file": str(client_file), "type": "client_class"}
+
+    def _update_config(
+        self, source_service: str, target_service: str
+    ) -> dict[str, Any]:
+        """Update service config."""
+        source_path = self.project_root / "services" / source_service
+        config_file = source_path / "src" / "config.py"
+
+        if config_file.exists():
+            content = config_file.read_text(encoding="utf-8")
+            # Add target service URL
+            if f"{target_service}_url" not in content:
+                content += f'\n    {target_service.replace("-", "_")}_url: str = "http://{target_service}:8000"'
+                config_file.write_text(content, encoding="utf-8")
+
+        return {"file": str(config_file), "type": "config"}
+
+    def _update_docker_compose(self, target_service: str) -> dict[str, Any] | None:
+        """Update docker-compose.yml."""
+        compose_file = self.project_root / "docker-compose.yml"
+        if not compose_file.exists():
+            return None
+
+        # Would need to parse and update YAML
+        # For now, just return
+        return {"file": str(compose_file), "type": "docker_compose"}
+

tapps_agents/integrations/__init__.py

@@ -1,10 +1,10 @@
-"""
-TappsCodingAgents Integrations
-
-Modules for integrating with external tools and environments.
-"""
-
-from .clawdbot import ClawdbotIntegration
-from .memory_bridge import MemoryBridge
-
-__all__ = ["ClawdbotIntegration", "MemoryBridge"]
+"""
+TappsCodingAgents Integrations
+
+Modules for integrating with external tools and environments.
+"""
+
+from .clawdbot import ClawdbotIntegration
+from .memory_bridge import MemoryBridge
+
+__all__ = ["ClawdbotIntegration", "MemoryBridge"]