soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/shared/tool_formatters/goal_formatter.py

@@ -0,0 +1,331 @@
+"""Formatter for goal management tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from soothe_cli.shared.tool_formatters.base import BaseFormatter
+from soothe_cli.shared.tool_output_formatter import ToolBrief
+
+
+class GoalFormatter(BaseFormatter):
+    """Formatter for goal management tools.
+
+    Handles: create_goal, list_goals, complete_goal, fail_goal
+
+    Provides semantic summaries with goal IDs, counts, and status.
+    """
+
+    def format(self, tool_name: str, result: Any) -> ToolBrief:
+        """Format goal management tool result.
+
+        Args:
+            tool_name: Name of the goal tool.
+            result: Tool result (dict with goal data).
+
+        Returns:
+            ToolBrief with goal summary.
+
+        Raises:
+            ValueError: If tool_name is not a recognized goal tool.
+
+        Example:
+            >>> formatter = GoalFormatter()
+            >>> brief = formatter.format("create_goal", {"created": {"id": "g1"}})
+            >>> brief.to_display()
+            '✓ Created goal g1'
+        """
+        # Normalize tool name
+        normalized = tool_name.lower().replace("-", "_").replace(" ", "_")
+
+        # Route to specific formatter
+        if normalized == "create_goal":
+            return self._format_create_goal(result)
+        if normalized == "list_goals":
+            return self._format_list_goals(result)
+        if normalized == "complete_goal":
+            return self._format_complete_goal(result)
+        if normalized == "fail_goal":
+            return self._format_fail_goal(result)
+        msg = f"Unknown goal tool: {tool_name}"
+        raise ValueError(msg)
+
+    def _format_create_goal(self, result: dict[str, Any]) -> ToolBrief:
+        """Format create_goal result.
+
+        Shows created goal ID.
+
+        Args:
+            result: Dict with 'created' field containing goal object.
+
+        Returns:
+            ToolBrief with goal ID.
+
+        Example:
+            >>> brief = formatter._format_create_goal({"created": {"id": "g1", "priority": 80}})
+            >>> brief.summary
+            'Created goal g1'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Create failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract goal data
+            created = result.get("created", {})
+            goal_id = created.get("id", "unknown")
+            priority = created.get("priority")
+
+            # Build summary
+            summary = f"Created goal {goal_id}"
+
+            # Build detail
+            detail = None
+            if priority is not None:
+                detail = f"priority: {priority}"
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=detail,
+                metrics={"goal_id": goal_id, "priority": priority},
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Create failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Created goal",
+                detail=None,
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Created goal",
+            detail=None,
+            metrics={},
+        )
+
+    def _format_list_goals(self, result: dict[str, Any]) -> ToolBrief:
+        """Format list_goals result.
+
+        Shows count of goals.
+
+        Args:
+            result: Dict with 'goals' field containing list of goal objects.
+
+        Returns:
+            ToolBrief with goal count.
+
+        Example:
+            >>> brief = formatter._format_list_goals({"goals": [{"id": "g1"}, {"id": "g2"}]})
+            >>> brief.summary
+            'Found 2 goals'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="List failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract goals
+            goals = result.get("goals", [])
+            count = len(goals)
+
+            # Build summary
+            summary = f"Found {count} goal{'s' if count != 1 else ''}"
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=None,
+                metrics={"count": count},
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="List failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Listed goals",
+                detail=None,
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Listed goals",
+            detail=None,
+            metrics={},
+        )
+
+    def _format_complete_goal(self, result: dict[str, Any]) -> ToolBrief:
+        """Format complete_goal result.
+
+        Shows completed goal ID.
+
+        Args:
+            result: Dict with 'completed' field containing goal object.
+
+        Returns:
+            ToolBrief with goal ID.
+
+        Example:
+            >>> brief = formatter._format_complete_goal({"completed": {"id": "g1"}})
+            >>> brief.summary
+            'Completed goal g1'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Complete failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract goal data
+            completed = result.get("completed", {})
+            goal_id = completed.get("id", "unknown")
+
+            # Build summary
+            summary = f"Completed goal {goal_id}"
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=None,
+                metrics={"goal_id": goal_id},
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Complete failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Completed goal",
+                detail=None,
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Completed goal",
+            detail=None,
+            metrics={},
+        )
+
+    def _format_fail_goal(self, result: dict[str, Any]) -> ToolBrief:
+        """Format fail_goal result.
+
+        Shows failed goal ID and reason.
+
+        Args:
+            result: Dict with 'failed' field containing goal object.
+
+        Returns:
+            ToolBrief with goal ID and failure reason.
+
+        Example:
+            >>> brief = formatter._format_fail_goal({"failed": {"id": "g1", "reason": "blocked"}})
+            >>> brief.summary
+            'Failed goal g1'
+            >>> brief.detail
+            'reason: blocked'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Fail operation failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract goal data
+            failed = result.get("failed", {})
+            goal_id = failed.get("id", "unknown")
+            reason = failed.get("reason", "unknown reason")
+
+            # Build summary
+            summary = f"Failed goal {goal_id}"
+
+            # Build detail
+            detail = f"reason: {reason}"
+
+            return ToolBrief(
+                icon="✗",
+                summary=summary,
+                detail=detail,
+                metrics={"goal_id": goal_id, "reason": reason},
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Fail operation failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✗",
+                summary="Failed goal",
+                detail=None,
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✗",
+            summary="Failed goal",
+            detail=None,
+            metrics={},
+        )

soothe_cli/shared/tool_formatters/media.py

@@ -0,0 +1,291 @@
+"""Formatter for media tools."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from soothe_cli.shared.tool_formatters.base import BaseFormatter
+from soothe_cli.shared.tool_output_formatter import ToolBrief
+
+
+class MediaFormatter(BaseFormatter):
+    """Formatter for media tools.
+
+    Handles: transcribe_audio, get_video_info, analyze_image
+
+    Provides semantic summaries with duration, resolution, and format metrics.
+    """
+
+    def format(self, tool_name: str, result: Any) -> ToolBrief:
+        """Format media tool result.
+
+        Args:
+            tool_name: Name of the media tool.
+            result: Tool result (dict with media metadata).
+
+        Returns:
+            ToolBrief with media summary.
+
+        Raises:
+            ValueError: If tool_name is not a recognized media tool.
+
+        Example:
+            >>> formatter = MediaFormatter()
+            >>> brief = formatter.format("transcribe_audio", {"duration": 45.2, "language": "en"})
+            >>> brief.to_display()
+            '✓ Transcribed 45.2s (en)'
+        """
+        # Normalize tool name
+        normalized = tool_name.lower().replace("-", "_").replace(" ", "_")
+
+        # Route to specific formatter
+        if normalized == "transcribe_audio":
+            return self._format_transcribe_audio(result)
+        if normalized == "get_video_info":
+            return self._format_get_video_info(result)
+        if normalized == "analyze_image":
+            return self._format_analyze_image(result)
+        msg = f"Unknown media tool: {tool_name}"
+        raise ValueError(msg)
+
+    def _format_transcribe_audio(self, result: dict[str, Any]) -> ToolBrief:
+        """Format transcribe_audio result.
+
+        Shows duration and language.
+
+        Args:
+            result: Dict with 'text', 'duration', 'language', and optional 'error'.
+
+        Returns:
+            ToolBrief with transcription summary.
+
+        Example:
+            >>> brief = formatter._format_transcribe_audio(
+            ...     {"duration": 45.2, "language": "en", "text": "hello"}
+            ... )
+            >>> brief.summary
+            'Transcribed 45.2s'
+            >>> brief.detail
+            'language: en'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Transcription failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract metadata
+            duration = result.get("duration", 0.0)
+            language = result.get("language", "unknown")
+            text_length = len(result.get("text", ""))
+
+            # Build summary
+            summary = f"Transcribed {duration:.1f}s"
+
+            # Build detail
+            detail = f"language: {language}"
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=detail,
+                metrics={
+                    "duration": duration,
+                    "language": language,
+                    "text_length": text_length,
+                },
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Transcription failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Transcribed",
+                detail=f"{len(result)} chars",
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Transcribed",
+            detail=None,
+            metrics={},
+        )
+
+    def _format_get_video_info(self, result: dict[str, Any]) -> ToolBrief:
+        """Format get_video_info result.
+
+        Shows duration, resolution, and format.
+
+        Args:
+            result: Dict with 'duration_seconds', 'format', 'codec', and optional 'error'.
+
+        Returns:
+            ToolBrief with video info summary.
+
+        Example:
+            >>> brief = formatter._format_get_video_info({"duration_seconds": 120, "format": "mp4"})
+            >>> brief.summary
+            'Video: 120s'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Video info failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract metadata
+            duration = result.get("duration_seconds", 0.0)
+            video_format = result.get("format", "unknown")
+            codec = result.get("codec", "unknown")
+            size_bytes = result.get("size_bytes", 0)
+
+            # Build summary
+            summary = f"Video: {duration:.0f}s"
+
+            # Build detail with resolution if available (not in basic schema)
+            # Just show format for now
+            detail = f"{video_format}, {codec}"
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=detail,
+                metrics={
+                    "duration": duration,
+                    "format": video_format,
+                    "codec": codec,
+                    "size_bytes": size_bytes,
+                },
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Video info failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Video info retrieved",
+                detail=self._truncate_text(result, 80),
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Video info retrieved",
+            detail=None,
+            metrics={},
+        )
+
+    def _format_analyze_image(self, result: dict[str, Any]) -> ToolBrief:
+        """Format analyze_image result.
+
+        Shows size and format.
+
+        Args:
+            result: Dict with image metadata and optional 'error'.
+
+        Returns:
+            ToolBrief with image analysis summary.
+
+        Example:
+            >>> brief = formatter._format_analyze_image({"size_bytes": 2400000, "format": "PNG"})
+            >>> brief.summary
+            'Analyzed image'
+            >>> brief.detail
+            '2.3 MB, PNG'
+        """
+        # Handle dict result
+        if isinstance(result, dict):
+            # Check for error
+            if "error" in result:
+                error_msg = str(result["error"])
+                return ToolBrief(
+                    icon="✗",
+                    summary="Image analysis failed",
+                    detail=self._truncate_text(error_msg, 80),
+                    metrics={"error": True},
+                )
+
+            # Extract metadata
+            size_bytes = result.get("size_bytes", 0)
+            image_format = result.get("format", "unknown")
+            width = result.get("width")
+            height = result.get("height")
+
+            # Build summary
+            summary = "Analyzed image"
+
+            # Build detail
+            size_str = self._format_size(size_bytes)
+            detail_parts = [size_str, image_format]
+
+            if width and height:
+                detail_parts.append(f"{width}x{height}")
+
+            detail = ", ".join(detail_parts)
+
+            return ToolBrief(
+                icon="✓",
+                summary=summary,
+                detail=detail,
+                metrics={
+                    "size_bytes": size_bytes,
+                    "format": image_format,
+                    "width": width,
+                    "height": height,
+                },
+            )
+
+        # Handle string result (fallback)
+        if isinstance(result, str):
+            if "error" in result.lower() or "failed" in result.lower():
+                return ToolBrief(
+                    icon="✗",
+                    summary="Image analysis failed",
+                    detail=self._truncate_text(result, 80),
+                    metrics={"error": True},
+                )
+
+            return ToolBrief(
+                icon="✓",
+                summary="Analyzed image",
+                detail=self._truncate_text(result, 80),
+                metrics={},
+            )
+
+        # Unknown type
+        return ToolBrief(
+            icon="✓",
+            summary="Analyzed image",
+            detail=None,
+            metrics={},
+        )