tunacode-cli 0.0.48__py3-none-any.whl → 0.0.49__py3-none-any.whl

tunacode/core/agents/utils.py

@@ -1,13 +1,20 @@
 import asyncio
 import importlib
 import json
+import logging
 import os
 import re
 from collections.abc import Iterator
 from datetime import datetime, timezone
 from typing import Any
 
-from tunacode.constants import READ_ONLY_TOOLS
+from tunacode.constants import (
+    JSON_PARSE_BASE_DELAY,
+    JSON_PARSE_MAX_DELAY,
+    JSON_PARSE_MAX_RETRIES,
+    READ_ONLY_TOOLS,
+)
+from tunacode.exceptions import ToolBatchingJSONError
 from tunacode.types import (
     ErrorMessage,
     StateManager,
@@ -16,6 +23,9 @@ from tunacode.types import (
     ToolName,
 )
 from tunacode.ui import console as ui
+from tunacode.utils.retry import retry_json_parse_async
+
+logger = logging.getLogger(__name__)
 
 
 # Lazy import for Agent and Tool
@@ -167,11 +177,28 @@ async def parse_json_tool_calls(
             if brace_count == 0 and start_pos != -1:
                 potential_json = text[start_pos : i + 1]
                 try:
-                    parsed = json.loads(potential_json)
+                    # Use retry logic for JSON parsing
+                    parsed = await retry_json_parse_async(
+                        potential_json,
+                        max_retries=JSON_PARSE_MAX_RETRIES,
+                        base_delay=JSON_PARSE_BASE_DELAY,
+                        max_delay=JSON_PARSE_MAX_DELAY,
+                    )
                     if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
                         potential_jsons.append((parsed["tool"], parsed["args"]))
-                except json.JSONDecodeError:
-                    pass
+                except json.JSONDecodeError as e:
+                    # After all retries failed
+                    logger.error(f"JSON parsing failed after {JSON_PARSE_MAX_RETRIES} retries: {e}")
+                    if state_manager.session.show_thoughts:
+                        await ui.error(
+                            f"Failed to parse tool JSON after {JSON_PARSE_MAX_RETRIES} retries"
+                        )
+                    # Raise custom exception for better error handling
+                    raise ToolBatchingJSONError(
+                        json_content=potential_json,
+                        retry_count=JSON_PARSE_MAX_RETRIES,
+                        original_error=e,
+                    ) from e
                 start_pos = -1
 
     matches = potential_jsons
@@ -220,7 +247,13 @@ async def extract_and_execute_tool_calls(
 
     for match in code_matches:
         try:
-            tool_data = json.loads(match)
+            # Use retry logic for JSON parsing in code blocks
+            tool_data = await retry_json_parse_async(
+                match,
+                max_retries=JSON_PARSE_MAX_RETRIES,
+                base_delay=JSON_PARSE_BASE_DELAY,
+                max_delay=JSON_PARSE_MAX_DELAY,
+            )
             if "tool" in tool_data and "args" in tool_data:
 
                 class MockToolCall:
@@ -240,7 +273,22 @@ async def extract_and_execute_tool_calls(
                 if state_manager.session.show_thoughts:
                     await ui.muted(f"FALLBACK: Executed {tool_data['tool']} from code block")
 
-        except (json.JSONDecodeError, KeyError, Exception) as e:
+        except json.JSONDecodeError as e:
+            # After all retries failed
+            logger.error(
+                f"Code block JSON parsing failed after {JSON_PARSE_MAX_RETRIES} retries: {e}"
+            )
+            if state_manager.session.show_thoughts:
+                await ui.error(
+                    f"Failed to parse code block tool JSON after {JSON_PARSE_MAX_RETRIES} retries"
+                )
+            # Raise custom exception for better error handling
+            raise ToolBatchingJSONError(
+                json_content=match,
+                retry_count=JSON_PARSE_MAX_RETRIES,
+                original_error=e,
+            ) from e
+        except (KeyError, Exception) as e:
             if state_manager.session.show_thoughts:
                 await ui.error(f"Error parsing code block tool call: {e!s}")
 

tunacode/core/logging/__init__.py

@@ -0,0 +1,29 @@
+import logging
+
+# Custom log level: THOUGHT
+THOUGHT = 25
+logging.addLevelName(THOUGHT, "THOUGHT")
+
+
+def thought(self, message, *args, **kwargs):
+    if self.isEnabledFor(THOUGHT):
+        self._log(THOUGHT, message, args, **kwargs)
+
+
+logging.Logger.thought = thought
+
+
+# RichHandler for UI output (stub, real implementation in handlers.py)
+class RichHandler(logging.Handler):
+    def emit(self, record):
+        # Actual implementation in handlers.py
+        pass
+
+
+def setup_logging(config_path=None):
+    """
+    Set up logging configuration from YAML file.
+    """
+    from .config import LogConfig
+
+    LogConfig.load(config_path)

tunacode/core/logging/config.py

@@ -0,0 +1,28 @@
+import logging
+import logging.config
+import os
+
+import yaml
+
+DEFAULT_CONFIG_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
+)
+
+
+class LogConfig:
+    @staticmethod
+    def load(config_path=None):
+        """
+        Load logging configuration from YAML file and apply it.
+        """
+        path = config_path or DEFAULT_CONFIG_PATH
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Logging config file not found: {path}")
+        with open(path, "r") as f:
+            config = yaml.safe_load(f)
+        logging_config = config.get("logging", config)
+        try:
+            logging.config.dictConfig(logging_config)
+        except Exception as e:
+            print(f"Failed to configure logging: {e}")
+            logging.basicConfig(level=logging.INFO)

tunacode/core/logging/formatters.py

@@ -0,0 +1,48 @@
+import logging
+
+
+class SimpleFormatter(logging.Formatter):
+    """
+    Simple formatter for UI output.
+    """
+
+    def __init__(self):
+        super().__init__("[%(levelname)s] %(message)s")
+
+
+class DetailedFormatter(logging.Formatter):
+    """
+    Detailed formatter for backend text logs.
+    """
+
+    def __init__(self):
+        super().__init__("[%(asctime)s] [%(levelname)s] [%(name)s:%(lineno)d] - %(message)s")
+
+
+try:
+    from pythonjsonlogger import jsonlogger
+
+    class JSONFormatter(jsonlogger.JsonFormatter):
+        """
+        JSON formatter for structured logs.
+        """
+
+        def __init__(self):
+            super().__init__("%(asctime)s %(name)s %(levelname)s %(message)s")
+except ImportError:
+    import json
+
+    class JSONFormatter(logging.Formatter):
+        """
+        Fallback JSON formatter if pythonjsonlogger is not installed.
+        """
+
+        def format(self, record):
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+            }
+            return json.dumps(log_entry)

tunacode/core/logging/handlers.py

@@ -0,0 +1,83 @@
+import json
+import logging
+
+from rich.console import Console
+from rich.text import Text
+
+# Global context for streaming state
+_streaming_context = {"just_finished": False}
+
+
+class RichHandler(logging.Handler):
+    """
+    Handler that outputs logs to the console using rich formatting.
+    """
+
+    level_icons = {
+        "INFO": "",
+        "WARNING": "⚠️",
+        "ERROR": "❌",
+        "CRITICAL": "🚨",
+        "THOUGHT": "🤔",
+        "DEBUG": "",
+    }
+
+    def __init__(self, level=logging.NOTSET):
+        super().__init__(level)
+        self.console = Console()
+
+    def emit(self, record):
+        try:
+            icon = self.level_icons.get(record.levelname, "")
+            timestamp = self.formatTime(record)
+            msg = self.format(record)
+            if icon:
+                output = f"[{timestamp}] {icon} {msg}"
+            else:
+                output = f"[{timestamp}] {msg}"
+
+            # Check if we just finished streaming to avoid extra newlines
+            just_finished_streaming = _streaming_context.get("just_finished", False)
+            if just_finished_streaming:
+                _streaming_context["just_finished"] = False  # Reset after use
+                # Don't add extra newline when transitioning from streaming
+                self.console.print(Text(output), end="\n")
+            else:
+                self.console.print(Text(output))
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime
+
+        ct = datetime.fromtimestamp(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)
+        return ct.strftime("%Y-%m-%d %H:%M:%S")
+
+
+class StructuredFileHandler(logging.FileHandler):
+    """
+    Handler that outputs logs as structured JSON lines.
+    """
+
+    def emit(self, record):
+        try:
+            log_entry = {
+                "timestamp": self.formatTime(record),
+                "level": record.levelname,
+                "name": record.name,
+                "line": record.lineno,
+                "message": record.getMessage(),
+                "extra_data": getattr(record, "extra", {}),
+            }
+            self.stream.write(json.dumps(log_entry) + "\n")
+            self.flush()
+        except Exception:
+            self.handleError(record)
+
+    def formatTime(self, record, datefmt=None):
+        from datetime import datetime, timezone
+
+        ct = datetime.fromtimestamp(record.created, tz=timezone.utc)
+        return ct.isoformat()

tunacode/core/logging/logger.py

@@ -0,0 +1,8 @@
+import logging
+
+
+def get_logger(name=None):
+    """
+    Get a logger instance with the given name.
+    """
+    return logging.getLogger(name)

tunacode/core/recursive/__init__.py

@@ -0,0 +1,18 @@
+"""Module: tunacode.core.recursive
+
+Recursive task execution system for complex task decomposition and execution.
+"""
+
+from .aggregator import ResultAggregator
+from .budget import BudgetManager
+from .decomposer import TaskDecomposer
+from .executor import RecursiveTaskExecutor
+from .hierarchy import TaskHierarchy
+
+__all__ = [
+    "RecursiveTaskExecutor",
+    "TaskDecomposer",
+    "TaskHierarchy",
+    "BudgetManager",
+    "ResultAggregator",
+]