tunacode-cli 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

tunacode/core/agents/main.py

@@ -6,6 +6,7 @@ Handles agent creation, configuration, and request processing.
 
 import asyncio
 import json
+import logging
 import os
 import re
 from datetime import datetime, timezone
@@ -29,7 +30,12 @@ except ImportError:
     STREAMING_AVAILABLE = False
 
 from tunacode.constants import READ_ONLY_TOOLS
+from tunacode.core.agents.dspy_integration import DSPyIntegration
+from tunacode.core.recursive import RecursiveTaskExecutor
 from tunacode.core.state import StateManager
+from tunacode.core.token_usage.api_response_parser import ApiResponseParser
+from tunacode.core.token_usage.cost_calculator import CostCalculator
+from tunacode.exceptions import ToolBatchingJSONError
 from tunacode.services.mcp import get_mcp_servers
 from tunacode.tools.bash import bash
 from tunacode.tools.glob import glob
@@ -37,6 +43,7 @@ from tunacode.tools.grep import grep
 from tunacode.tools.list_dir import list_dir
 from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
+from tunacode.tools.todo import TodoTool
 from tunacode.tools.update_file import update_file
 from tunacode.tools.write_file import write_file
 from tunacode.types import (
@@ -50,8 +57,12 @@ from tunacode.types import (
     ToolCallback,
     ToolCallId,
     ToolName,
+    UsageTrackerProtocol,
 )
 
+# Configure logging
+logger = logging.getLogger(__name__)
+
 
 class ToolBuffer:
     """Buffer for collecting read-only tool calls to execute in parallel."""
@@ -110,6 +121,7 @@ async def execute_tools_parallel(
         try:
             return await callback(part, node)
         except Exception as e:
+            logger.error(f"Error executing parallel tool: {e}", exc_info=True)
             return e
 
     # If we have more tools than max_parallel, execute in batches
@@ -214,6 +226,7 @@ async def _process_node(
     state_manager: StateManager,
     tool_buffer: Optional[ToolBuffer] = None,
     streaming_callback: Optional[callable] = None,
+    usage_tracker: Optional[UsageTrackerProtocol] = None,
 ):
     from tunacode.ui import console as ui
     from tunacode.utils.token_counter import estimate_tokens
@@ -233,6 +246,9 @@ async def _process_node(
     if hasattr(node, "model_response"):
         state_manager.session.messages.append(node.model_response)
 
+        if usage_tracker:
+            await usage_tracker.track_and_display(node.model_response)
+
         # Stream content to callback if provided
         # Use this as fallback when true token streaming is not available
         if streaming_callback and not STREAMING_AVAILABLE:
@@ -313,8 +329,8 @@ async def _process_node(
                             thought_obj = json.loads(content)
                             if "thought" in thought_obj:
                                 await ui.muted(f"REASONING: {thought_obj['thought']}")
-                    except (json.JSONDecodeError, KeyError):
-                        pass
+                    except (json.JSONDecodeError, KeyError) as e:
+                        logger.debug(f"Failed to parse thought JSON: {e}")
 
                     # Pattern 3: Multi-line thoughts with context
                     multiline_pattern = r'\{"thought":\s*"([^"]+(?:\\.[^"]*)*?)"\}'
@@ -442,8 +458,9 @@ async def _process_node(
         # Handle tool returns
         for part in node.model_response.parts:
             if part.part_kind == "tool-return":
-                obs_msg = f"OBSERVATION[{part.tool_name}]: {part.content[:2_000]}"
-                state_manager.session.messages.append(obs_msg)
+                state_manager.session.messages.append(
+                    f"OBSERVATION[{part.tool_name}]: {part.content}"
+                )
 
                 # Display tool return when thoughts are enabled
                 if state_manager.session.show_thoughts:
@@ -457,9 +474,17 @@ async def _process_node(
         if not has_tool_calls and buffering_callback:
             for part in node.model_response.parts:
                 if hasattr(part, "content") and isinstance(part.content, str):
-                    await extract_and_execute_tool_calls(
-                        part.content, buffering_callback, state_manager
-                    )
+                    try:
+                        await extract_and_execute_tool_calls(
+                            part.content, buffering_callback, state_manager
+                        )
+                    except ToolBatchingJSONError as e:
+                        # Handle JSON parsing failure after retries
+                        logger.error(f"Tool batching JSON error: {e}")
+                        if state_manager.session.show_thoughts:
+                            await ui.error(str(e))
+                        # Continue processing other parts instead of failing completely
+                        continue
 
     # Final flush: disabled temporarily while fixing the parallel execution design
     # The buffer is not being used in the current implementation
@@ -494,6 +519,18 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 # Use a default system prompt if neither file exists
                 system_prompt = "You are a helpful AI assistant for software development tasks."
 
+        # Enhance with DSPy optimization if enabled
+        use_dspy = state_manager.session.user_config.get("settings", {}).get(
+            "use_dspy_optimization", True
+        )
+        if use_dspy:
+            try:
+                dspy_integration = DSPyIntegration(state_manager)
+                system_prompt = dspy_integration.enhance_system_prompt(system_prompt)
+                logger.info("Enhanced system prompt with DSPy optimizations")
+            except Exception as e:
+                logger.warning(f"Failed to enhance prompt with DSPy: {e}")
+
         # Load TUNACODE.md context
         # Use sync version of get_code_style to avoid nested event loop issues
         try:
@@ -510,9 +547,22 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
             else:
                 # Log that TUNACODE.md was not found
                 print("📄 TUNACODE.md not found: Using default context")
-        except Exception:
-            # Ignore errors loading TUNACODE.md
-            pass
+        except Exception as e:
+            # Log errors loading TUNACODE.md at debug level
+            logger.debug(f"Error loading TUNACODE.md: {e}")
+
+        todo_tool = TodoTool(state_manager=state_manager)
+
+        try:
+            # Only add todo section if there are actual todos
+            current_todos = todo_tool.get_current_todos_sync()
+            if current_todos != "No todos found":
+                system_prompt += f'\n\n# Current Todo List\n\nYou have existing todos that need attention:\n\n{current_todos}\n\nRemember to check progress on these todos and update them as you work. Use todo("list") to see current status anytime.'
+        except Exception as e:
+            # Log error but don't fail agent creation
+            import sys
+
+            print(f"Warning: Failed to load todos: {e}", file=sys.stderr)
 
         state_manager.session.agents[model] = Agent(
             model=model,
@@ -524,6 +574,7 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
                 Tool(list_dir, max_retries=max_retries),
                 Tool(read_file, max_retries=max_retries),
                 Tool(run_command, max_retries=max_retries),
+                Tool(todo_tool._execute, max_retries=max_retries),
                 Tool(update_file, max_retries=max_retries),
                 Tool(write_file, max_retries=max_retries),
             ],
@@ -622,7 +673,9 @@ async def parse_json_tool_calls(
                     if isinstance(parsed, dict) and "tool" in parsed and "args" in parsed:
                         potential_jsons.append((parsed["tool"], parsed["args"]))
                 except json.JSONDecodeError:
-                    pass
+                    logger.debug(
+                        f"Failed to parse potential JSON tool call: {potential_json[:50]}..."
+                    )
                 start_pos = -1
 
     matches = potential_jsons
@@ -720,6 +773,116 @@ async def process_request(
         "fallback_response", True
     )
 
+    # Check if DSPy optimization is enabled and if this is a complex task
+    use_dspy = state_manager.session.user_config.get("settings", {}).get(
+        "use_dspy_optimization", True
+    )
+    dspy_integration = None
+    task_breakdown = None
+
+    # Check if recursive execution is enabled
+    use_recursive = state_manager.session.user_config.get("settings", {}).get(
+        "use_recursive_execution", True
+    )
+    recursive_threshold = state_manager.session.user_config.get("settings", {}).get(
+        "recursive_complexity_threshold", 0.7
+    )
+
+    if use_dspy:
+        try:
+            dspy_integration = DSPyIntegration(state_manager)
+
+            # Check if this is a complex task that needs planning
+            if dspy_integration.should_use_task_planner(message):
+                task_breakdown = dspy_integration.get_task_breakdown(message)
+                if task_breakdown and task_breakdown.get("requires_todo"):
+                    # Auto-create todos for complex tasks
+                    from tunacode.tools.todo import TodoTool
+
+                    todo_tool = TodoTool(state_manager=state_manager)
+
+                    if state_manager.session.show_thoughts:
+                        from tunacode.ui import console as ui
+
+                        await ui.muted("DSPy: Detected complex task - creating todo list")
+
+                    # Create todos from subtasks
+                    todos = []
+                    for subtask in task_breakdown["subtasks"][:5]:  # Limit to first 5
+                        todos.append(
+                            {
+                                "content": subtask["task"],
+                                "priority": subtask.get("priority", "medium"),
+                            }
+                        )
+
+                    if todos:
+                        await todo_tool._execute(action="add_multiple", todos=todos)
+        except Exception as e:
+            logger.warning(f"DSPy task planning failed: {e}")
+
+    # Check if recursive execution should be used
+    if use_recursive and state_manager.session.current_recursion_depth == 0:
+        try:
+            # Initialize recursive executor
+            recursive_executor = RecursiveTaskExecutor(
+                state_manager=state_manager,
+                max_depth=state_manager.session.max_recursion_depth,
+                min_complexity_threshold=recursive_threshold,
+                default_iteration_budget=max_iterations,
+            )
+
+            # Analyze task complexity
+            complexity_result = await recursive_executor.decomposer.analyze_and_decompose(message)
+
+            if (
+                complexity_result.should_decompose
+                and complexity_result.total_complexity >= recursive_threshold
+            ):
+                if state_manager.session.show_thoughts:
+                    from tunacode.ui import console as ui
+
+                    await ui.muted(
+                        f"\n🔄 RECURSIVE EXECUTION: Task complexity {complexity_result.total_complexity:.2f} >= {recursive_threshold}"
+                    )
+                    await ui.muted(f"Reasoning: {complexity_result.reasoning}")
+                    await ui.muted(f"Subtasks: {len(complexity_result.subtasks)}")
+
+                # Execute recursively
+                success, result, error = await recursive_executor.execute_task(
+                    request=message, parent_task_id=None, depth=0
+                )
+
+                # Create AgentRun response
+                from datetime import datetime
+
+                if success:
+                    return AgentRun(
+                        messages=[{"role": "assistant", "content": str(result)}],
+                        timestamp=datetime.now(),
+                        model=model,
+                        iterations=1,
+                        status="success",
+                    )
+                else:
+                    return AgentRun(
+                        messages=[{"role": "assistant", "content": f"Task failed: {error}"}],
+                        timestamp=datetime.now(),
+                        model=model,
+                        iterations=1,
+                        status="error",
+                    )
+        except Exception as e:
+            logger.warning(f"Recursive execution failed, falling back to normal: {e}")
+            # Continue with normal execution
+
+    from tunacode.configuration.models import ModelRegistry
+    from tunacode.core.token_usage.usage_tracker import UsageTracker
+
+    parser = ApiResponseParser()
+    registry = ModelRegistry()
+    calculator = CostCalculator(registry)
+    usage_tracker = UsageTracker(parser, calculator, state_manager)
     response_state = ResponseState()
 
     # Reset iteration tracking for this request
@@ -763,7 +926,14 @@ async def process_request(
                             if event.delta.content_delta:
                                 await streaming_callback(event.delta.content_delta)
 
-            await _process_node(node, tool_callback, state_manager, tool_buffer, streaming_callback)
+            await _process_node(
+                node,
+                tool_callback,
+                state_manager,
+                tool_buffer,
+                streaming_callback,
+                usage_tracker,
+            )
             if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
                 if node.result.output:
                     response_state.has_user_response = True

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/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",
+]