tunacode-cli 0.0.44__py3-none-any.whl → 0.0.45__py3-none-any.whl

tunacode/cli/repl.py

@@ -385,9 +385,13 @@ async def repl(state_manager: StateManager):
 
     state_manager.session.update_token_count()
     context_display = get_context_window_display(state_manager.session.total_tokens, max_tokens)
-    await ui.muted(f"• Model: {model_name} • {context_display}")
-    await ui.success("Ready to assist")
-    await ui.line()
+
+    # Only show startup info if thoughts are enabled or on first run
+    if state_manager.session.show_thoughts or not hasattr(state_manager.session, "_startup_shown"):
+        await ui.muted(f"• Model: {model_name} • {context_display}")
+        await ui.success("Ready to assist")
+        await ui.line()
+        state_manager.session._startup_shown = True
 
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
 
@@ -465,7 +469,11 @@ async def repl(state_manager: StateManager):
             context_display = get_context_window_display(
                 state_manager.session.total_tokens, state_manager.session.max_tokens
             )
-            await ui.muted(f"• Model: {state_manager.session.current_model} • {context_display}")
+            # Only show model/context info if thoughts are enabled
+            if state_manager.session.show_thoughts:
+                await ui.muted(
+                    f"• Model: {state_manager.session.current_model} • {context_display}"
+                )
 
         if action == "restart":
             await repl(state_manager)
@@ -480,7 +488,7 @@ async def repl(state_manager: StateManager):
                     total_cost = float(session_total.get("cost", 0) or 0)
 
                     # Only show summary if we have actual token usage
-                    if total_tokens > 0 or total_cost > 0:
+                    if state_manager.session.show_thoughts and (total_tokens > 0 or total_cost > 0):
                         summary = (
                             f"\n[bold cyan]TunaCode Session Summary[/bold cyan]\n"
                             f"  - Total Tokens:      {total_tokens:,}\n"

tunacode/configuration/defaults.py

@@ -24,7 +24,6 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "fallback_response": True,
         "fallback_verbosity": "normal",  # Options: minimal, normal, detailed
         "context_window_size": 200000,
-        "use_dspy_optimization": True,  # Enable DSPy tool selection optimization
     },
     "mcpServers": {},
 }

tunacode/constants.py

@@ -7,7 +7,7 @@ Centralizes all magic strings, UI text, error messages, and application constant
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.44"
+APP_VERSION = "0.0.45"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

tunacode/core/agents/main.py

@@ -30,7 +30,6 @@ 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
@@ -519,18 +518,6 @@ 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:
@@ -773,13 +760,6 @@ 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
@@ -788,39 +768,6 @@ async def process_request(
         "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:
@@ -853,25 +800,9 @@ async def process_request(
                     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",
-                    )
+                # For now, fall back to normal execution
+                # TODO: Properly integrate recursive execution results
+                pass
         except Exception as e:
             logger.warning(f"Recursive execution failed, falling back to normal: {e}")
             # Continue with normal execution

tunacode/core/recursive/aggregator.py

@@ -39,7 +39,7 @@ class TaskResult:
 
     task_id: str
     task_title: str
-    result_data: Any
+    result_data: object
     status: str  # completed, failed, partial
     timestamp: datetime = field(default_factory=datetime.now)
     error: Optional[str] = None
@@ -50,7 +50,7 @@ class TaskResult:
 class AggregatedResult:
     """Aggregated result from multiple tasks."""
 
-    primary_result: Any
+    primary_result: object
     task_results: List[TaskResult]
     strategy_used: AggregationStrategy
     conflicts_resolved: int = 0

tunacode/core/recursive/decomposer.py

@@ -73,7 +73,7 @@ class TaskDecomposer:
         # Get the main agent
         agent = self.state_manager.session.agents.get("main")
         if not agent:
-            logger.warning("Main agent not available, using heuristic decomposition")
+            logger.debug("Main agent not available, using heuristic decomposition")
             return self._heuristic_decomposition(task_description)
 
         # Build context-aware prompt

tunacode/core/recursive/executor.py

@@ -32,7 +32,7 @@ class TaskNode:
     iteration_budget: int = 10
     subtasks: List["TaskNode"] = field(default_factory=list)
     status: str = "pending"  # pending, in_progress, completed, failed
-    result: Optional[Any] = None
+    result: Optional[object] = None
     error: Optional[str] = None
     context: Dict[str, Any] = field(default_factory=dict)
     depth: int = 0
@@ -128,15 +128,17 @@ class RecursiveTaskExecutor:
                 and depth < self.max_depth - 1
             ):
                 # Decompose into subtasks
-                logger.info(
-                    f"Decomposing complex task (score: {complexity_result.complexity_score:.2f})"
-                )
+                if self.state_manager.session.show_thoughts:
+                    logger.info(
+                        f"Decomposing complex task (score: {complexity_result.complexity_score:.2f})"
+                    )
                 return await self._execute_with_decomposition(task_node, complexity_result)
             else:
                 # Execute directly
-                logger.info(
-                    f"Executing task directly (score: {complexity_result.complexity_score:.2f})"
-                )
+                if self.state_manager.session.show_thoughts:
+                    logger.info(
+                        f"Executing task directly (score: {complexity_result.complexity_score:.2f})"
+                    )
                 return await self._execute_directly(task_node)
 
         except Exception as e:
@@ -255,7 +257,8 @@ Respond in JSON format:
             )
 
         for i, (subtask_desc, budget) in enumerate(zip(subtasks, subtask_budgets)):
-            logger.info(f"Executing subtask {i + 1}/{len(subtasks)}: {subtask_desc[:50]}...")
+            if self.state_manager.session.show_thoughts:
+                logger.info(f"Executing subtask {i + 1}/{len(subtasks)}: {subtask_desc[:50]}...")
 
             # Create subtask context
             subtask_context = {

tunacode/ui/panels.py

@@ -9,6 +9,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.pretty import Pretty
 from rich.table import Table
+from rich.text import Text
 
 from tunacode.configuration.models import ModelRegistry
 from tunacode.constants import (
@@ -89,9 +90,15 @@ class StreamingAgentPanel:
         # Use the UI_THINKING_MESSAGE constant instead of hardcoded text
         from tunacode.constants import UI_THINKING_MESSAGE
 
-        markdown_content = Markdown(self.content or UI_THINKING_MESSAGE)
+        # If no content, show thinking message with Rich markup
+        if not self.content:
+            content_to_display = Text.from_markup(UI_THINKING_MESSAGE)
+        else:
+            # Normal content is markdown
+            content_to_display = Markdown(self.content)
+
         panel_obj = Panel(
-            Padding(markdown_content, (0, 1, 0, 1)),
+            Padding(content_to_display, (0, 1, 0, 1)),
             title=f"[bold]{self.title}[/bold]",
             title_align="left",
             border_style=colors.primary,

{tunacode_cli-0.0.44.dist-info → tunacode_cli-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.44
+Version: 0.0.45
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT
@@ -25,8 +25,6 @@ Requires-Dist: pydantic-ai[logfire]==0.2.6
 Requires-Dist: pygments==2.19.1
 Requires-Dist: rich==14.0.0
 Requires-Dist: tiktoken>=0.5.2
-Requires-Dist: dspy-ai>=0.1.0
-Requires-Dist: python-dotenv>=1.0.0
 Provides-Extra: dev
 Requires-Dist: build; extra == "dev"
 Requires-Dist: ruff; extra == "dev"

{tunacode_cli-0.0.44.dist-info → tunacode_cli-0.0.45.dist-info}/RECORD

@@ -1,5 +1,5 @@
 tunacode/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tunacode/constants.py,sha256=e5ew-znjhA7bItbVdVDnF51SR7xhvENeVOR541rc9_E,5168
+tunacode/constants.py,sha256=RivEbBYCMFVkeAO8WwknYut7dIRzAbDjtpVIWMYhdS8,5168
 tunacode/context.py,sha256=_gXVCyjU052jlyRAl9tklZSwl5U_zI_EIX8XN87VVWE,2786
 tunacode/exceptions.py,sha256=oDO1SVKOgjcKIylwqdbqh_g5my4roU5mB9Nv4n_Vb0s,3877
 tunacode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -7,7 +7,7 @@ tunacode/setup.py,sha256=XPt4eAK-qcIZQv64jGZ_ryxcImDwps9OmXjJfIS1xcs,1899
 tunacode/types.py,sha256=Czq7jYXHq7fZQtyqkCN5_7eEu1wyYUcB50C6v3sTWDw,8188
 tunacode/cli/__init__.py,sha256=zgs0UbAck8hfvhYsWhWOfBe5oK09ug2De1r4RuQZREA,55
 tunacode/cli/main.py,sha256=erP6jNXcxVQOVn8sm6uNaLEAYevniVXl6Sem872mW68,2755
-tunacode/cli/repl.py,sha256=CMvl5wlxj7hr45mxil26fwbmWpDYxRsRVS9aIGJvKK0,18525
+tunacode/cli/repl.py,sha256=58UJbKUcKCd1D1x0uOA5ipudZiiYOr-NXuJ6RmEn5_w,18962
 tunacode/cli/commands/__init__.py,sha256=zmE9JcJ9Qd2xJhgdS4jMDJOoZsrAZmL5MAFxbKkk7F8,1670
 tunacode/cli/commands/base.py,sha256=GxUuDsDSpz0iXryy8MrEw88UM3C3yxL__kDK1QhshoA,2517
 tunacode/cli/commands/registry.py,sha256=XVuLpp5S4Fw7GfIZfLrVZFo4jMLMNmYNpYN7xWgXyOk,8223
@@ -19,7 +19,7 @@ tunacode/cli/commands/implementations/model.py,sha256=uthx6IX9KwgwywNTDklkJpqCba
 tunacode/cli/commands/implementations/system.py,sha256=2cGw5iCJO3aNhXTFF28CgAIyLgslvHmpfyL2ZHVB6oQ,7903
 tunacode/cli/commands/implementations/todo.py,sha256=Dtz5bgcuK2VXGPWEBBZQgnWUMYkRXNzTGf_qkVPLF2U,8125
 tunacode/configuration/__init__.py,sha256=MbVXy8bGu0yKehzgdgZ_mfWlYGvIdb1dY2Ly75nfuPE,17
-tunacode/configuration/defaults.py,sha256=Qny32BhbSeRBrE9baWZcAit3XFXgWuXFMDJUZudj55M,922
+tunacode/configuration/defaults.py,sha256=lK_qf3BexmoQh7lbtxYG_ef0Kq3WyiLGOYmiVDO_amQ,840
 tunacode/configuration/models.py,sha256=buH8ZquvcYI3OQBDIZeJ08cu00rSCeNABtUwl3VQS0E,4103
 tunacode/configuration/settings.py,sha256=KoN0u6GG3Hh_TWt02D_wpRfbACYri3gCDTXHtJfHl2w,994
 tunacode/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -27,18 +27,16 @@ tunacode/core/code_index.py,sha256=jgAx3lSWP_DwnyiP5Jkm1YvX4JJyI4teMzlNrJSpEOA,1
 tunacode/core/state.py,sha256=2lsDgq0uIIc_MnXPE9SG_1fYFBDWWlgqgqm2Ik1iFBs,5599
 tunacode/core/tool_handler.py,sha256=BPjR013OOO0cLXPdLeL2FDK0ixUwOYu59FfHdcdFhp4,2277
 tunacode/core/agents/__init__.py,sha256=UUJiPYb91arwziSpjd7vIk7XNGA_4HQbsOIbskSqevA,149
-tunacode/core/agents/dspy_integration.py,sha256=h3gJ-qr0fXpB2CRaU-MVv_8xG--ah-8nra7WO960Gbo,9152
-tunacode/core/agents/dspy_tunacode.py,sha256=tIluqDsHAv3nbNYtqFh4oyZA9yqMrnyY2G-QOpkTLCs,17398
-tunacode/core/agents/main.py,sha256=xYzstmOJgxC1aJ2VbMWw5cevPp87IjpdWU45xydAKMQ,48882
+tunacode/core/agents/main.py,sha256=jaEGGyqlBdu_GWGAQSIz0jUMkBxUebcgza4VrlrdQls,45967
 tunacode/core/agents/utils.py,sha256=7kJAiUlkyWO3-b4T07XsGgycVrcNhv3NEPLdaktBnP4,12847
 tunacode/core/background/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/background/manager.py,sha256=rJdl3eDLTQwjbT7VhxXcJbZopCNR3M8ZGMbmeVnwwMc,1126
 tunacode/core/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tunacode/core/recursive/__init__.py,sha256=S9_dN0faJqam3Pnaum9PRC8Hd90bpES8syFgAD8-QbI,446
-tunacode/core/recursive/aggregator.py,sha256=iKKKd_tZT1sXaPjpjRVVoCG8zFfuxilktSGUdalzTUM,15719
+tunacode/core/recursive/aggregator.py,sha256=KlWajEyT8OokWeY6ZwQ4EsVu05V4KeH3o2cYUz-Ce1Y,15725
 tunacode/core/recursive/budget.py,sha256=0wY6xSrZKmudUwthwX1mlcF5yat2_y3fNu5shX_IzvA,14131
-tunacode/core/recursive/decomposer.py,sha256=7JbRPPXK083jipaaMSpnWIH4wtJC_yjhxBY-ZSkKqr0,14552
-tunacode/core/recursive/executor.py,sha256=5UcFPK57KP2WhtUeHrBPE3BxkKsZ7QxoMaSUHTYrsoE,16436
+tunacode/core/recursive/decomposer.py,sha256=k8rgaPEMMb2mZ9W0m_Yg0oEBqbYpqDnK0zyTkx6eTPs,14550
+tunacode/core/recursive/executor.py,sha256=7taFsjYjSfL8OUQLM1ZVn9Xix7YoputFBAZSo9tDtDM,16646
 tunacode/core/recursive/hierarchy.py,sha256=67tdDCKB5mTSn6VIwm-knEHB_VKUkeljFdwH62U5chE,15648
 tunacode/core/setup/__init__.py,sha256=lzdpY6rIGf9DDlDBDGFvQZaSOQeFsNglHbkpq1-GtU8,376
 tunacode/core/setup/agent_setup.py,sha256=trELO8cPnWo36BBnYmXDEnDPdhBg0p-VLnx9A8hSSSQ,1401
@@ -50,8 +48,6 @@ tunacode/core/setup/git_safety_setup.py,sha256=CRIqrQt0QUJQRS344njty_iCqTorrDhHl
 tunacode/core/token_usage/api_response_parser.py,sha256=CTtqGaFaxpkzkW3TEbe00QJzyRULpWN1EQxIYMleseg,1622
 tunacode/core/token_usage/cost_calculator.py,sha256=oQPMphGhqIt7NKdOg1o5Zbo59_nwFWmRJMQ30ViiCWs,1835
 tunacode/core/token_usage/usage_tracker.py,sha256=uKCpdZgmDfLauwsawSCifMu0kJE3lAnK7Sjd-0KYUgA,3894
-tunacode/prompts/dspy_task_planning.md,sha256=RNimkmnFcNgskwQrguGb3wB8A-Zngp6Qc9lXfPj61OU,2512
-tunacode/prompts/dspy_tool_selection.md,sha256=CPBHrI4QlWD2mzNdoVkFK7GydgCLW9Bi20sD8ZEysRo,3070
 tunacode/prompts/system.md,sha256=hXpjZ8Yiv2Acr2_6EmC2uOklP8FbmvyYR9oais-1KLk,16290
 tunacode/services/__init__.py,sha256=w_E8QK6RnvKSvU866eDe8BCRV26rAm4d3R-Yg06OWCU,19
 tunacode/services/mcp.py,sha256=R48X73KQjQ9vwhBrtbWHSBl-4K99QXmbIhh5J_1Gezo,3046
@@ -76,7 +72,7 @@ tunacode/ui/input.py,sha256=E_zAJqNYoAVFA-j4xE9Qgs22y-GrdSZNqiseX-Or0ho,2955
 tunacode/ui/keybindings.py,sha256=h0MlD73CW_3i2dQzb9EFSPkqy0raZ_isgjxUiA9u6ts,691
 tunacode/ui/lexers.py,sha256=tmg4ic1enyTRLzanN5QPP7D_0n12YjX_8ZhsffzhXA4,1340
 tunacode/ui/output.py,sha256=51O0VHajte4dXHK5Az5SSP4IOb2q5SbCwvqdAoxyg7c,5665
-tunacode/ui/panels.py,sha256=ckL-TYxYWlpBAFj8SC9Od8vrW7Kf5N92bZRYBWR14jE,8338
+tunacode/ui/panels.py,sha256=dBZEVIJqliWreY-hz6HpW5rdBmPOJZ6sPrv8KQ3eNhk,8570
 tunacode/ui/prompt_manager.py,sha256=U2cntB34vm-YwOj3gzFRUK362zccrz8pigQfpxr5sv8,4650
 tunacode/ui/recursive_progress.py,sha256=V0dGpJWt19TVArOYcQ3Lki8cR3ZepFT6iGwnChSFhFI,12906
 tunacode/ui/tool_ui.py,sha256=qp1aZUpLO5UOdJziY8tw0URC8gjoWoSKdGu5y2wuTUU,7013
@@ -95,9 +91,9 @@ tunacode/utils/system.py,sha256=FSoibTIH0eybs4oNzbYyufIiV6gb77QaeY2yGqW39AY,1138
 tunacode/utils/text_utils.py,sha256=6YBD9QfkDO44-6jxnwRWIpmfIifPG-NqMzy_O2NAouc,7277
 tunacode/utils/token_counter.py,sha256=lLbkrNUraRQn5RMhwnGurqq1RHFDyn4AaFhruONWIxo,2690
 tunacode/utils/user_configuration.py,sha256=Ilz8dpGVJDBE2iLWHAPT0xR8D51VRKV3kIbsAz8Bboc,3275
-tunacode_cli-0.0.44.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-tunacode_cli-0.0.44.dist-info/METADATA,sha256=MNphC8b7Fo9Q2kGx7pWgCkqM5k9dNaON0d02wKOu-9o,5203
-tunacode_cli-0.0.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tunacode_cli-0.0.44.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
-tunacode_cli-0.0.44.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
-tunacode_cli-0.0.44.dist-info/RECORD,,
+tunacode_cli-0.0.45.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+tunacode_cli-0.0.45.dist-info/METADATA,sha256=ZEVJDRAxDDjMG8DR64Hj9_Txw7h0lD9YwrhAAwft_nY,5137
+tunacode_cli-0.0.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tunacode_cli-0.0.45.dist-info/entry_points.txt,sha256=hbkytikj4dGu6rizPuAd_DGUPBGF191RTnhr9wdhORY,51
+tunacode_cli-0.0.45.dist-info/top_level.txt,sha256=lKy2P6BWNi5XSA4DHFvyjQ14V26lDZctwdmhEJrxQbU,9
+tunacode_cli-0.0.45.dist-info/RECORD,,

tunacode/core/agents/dspy_integration.py

@@ -1,223 +0,0 @@
-"""DSPy Integration for TunaCode - Enhanced Tool Selection and Task Planning.
-
-This module integrates DSPy's optimized prompts and tool selection logic
-into TunaCode's agent system for 3x performance improvements.
-"""
-
-import logging
-import os
-import re
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from tunacode.core.state import StateManager
-
-logger = logging.getLogger(__name__)
-
-
-class DSPyIntegration:
-    """Integrates DSPy optimization into TunaCode's agent system."""
-
-    def __init__(self, state_manager: StateManager):
-        self.state_manager = state_manager
-        self._dspy_agent = None
-        self._tool_selection_prompt = None
-        self._task_planning_prompt = None
-        self._load_prompts()
-
-    def _load_prompts(self):
-        """Load DSPy-optimized prompts from files."""
-        prompts_dir = Path(__file__).parent.parent.parent / "prompts"
-
-        try:
-            # Load tool selection prompt
-            tool_selection_path = prompts_dir / "dspy_tool_selection.md"
-            if tool_selection_path.exists():
-                self._tool_selection_prompt = tool_selection_path.read_text(encoding="utf-8")
-                logger.debug("Loaded DSPy tool selection prompt")
-
-            # Load task planning prompt
-            task_planning_path = prompts_dir / "dspy_task_planning.md"
-            if task_planning_path.exists():
-                self._task_planning_prompt = task_planning_path.read_text(encoding="utf-8")
-                logger.debug("Loaded DSPy task planning prompt")
-        except Exception as e:
-            logger.error(f"Failed to load DSPy prompts: {e}")
-
-    def get_dspy_agent(self, api_key: Optional[str] = None):
-        """Get or create the DSPy agent instance."""
-        if self._dspy_agent is None:
-            try:
-                # Import DSPy components
-                from tunacode.core.agents.dspy_tunacode import create_optimized_agent
-
-                # Use API key from environment or config
-                if not api_key:
-                    api_key = os.getenv(
-                        "OPENROUTER_API_KEY"
-                    ) or self.state_manager.session.user_config.get("env", {}).get(
-                        "OPENROUTER_API_KEY"
-                    )
-
-                if api_key:
-                    self._dspy_agent = create_optimized_agent(api_key)
-                    logger.info("DSPy agent initialized successfully")
-                else:
-                    logger.warning("No OpenRouter API key found for DSPy optimization")
-            except Exception as e:
-                logger.error(f"Failed to initialize DSPy agent: {e}")
-
-        return self._dspy_agent
-
-    def enhance_system_prompt(self, base_prompt: str) -> str:
-        """Enhance the system prompt with DSPy optimizations."""
-        if not self._tool_selection_prompt:
-            return base_prompt
-
-        # Extract the learned patterns from DSPy prompts
-        enhanced_sections = []
-
-        # Add DSPy tool selection insights
-        enhanced_sections.append("\n\n# DSPy-Optimized Tool Selection Patterns\n")
-        enhanced_sections.append("**Based on learned optimization patterns:**\n")
-        enhanced_sections.append("- Always batch 3-4 read-only tools for parallel execution")
-        enhanced_sections.append("- Group grep, list_dir, glob, read_file operations together")
-        enhanced_sections.append("- Execute write/modify operations sequentially")
-        enhanced_sections.append("- Use Chain of Thought reasoning for tool selection\n")
-
-        # Add specific examples from DSPy prompt
-        if "Example" in self._tool_selection_prompt:
-            enhanced_sections.append("\n## Optimal Tool Batching Examples:\n")
-            # Extract examples section
-            examples_match = re.search(
-                r"### Example.*?(?=###|\Z)", self._tool_selection_prompt, re.DOTALL
-            )
-            if examples_match:
-                enhanced_sections.append(examples_match.group(0))
-
-        return base_prompt + "".join(enhanced_sections)
-
-    def should_use_task_planner(self, user_request: str) -> bool:
-        """Determine if the request is complex enough for task planning."""
-        complex_indicators = [
-            "implement",
-            "create",
-            "build",
-            "refactor",
-            "add feature",
-            "fix all",
-            "update multiple",
-            "migrate",
-            "integrate",
-            "debug",
-            "optimize performance",
-            "authentication",
-            "setup",
-        ]
-
-        request_lower = user_request.lower()
-
-        # Check for multiple files
-        file_pattern = r"\b\w+\.\w+\b"
-        files_mentioned = len(re.findall(file_pattern, user_request)) > 2
-
-        # Check for complex keywords
-        has_complex_keyword = any(indicator in request_lower for indicator in complex_indicators)
-
-        # Check for multiple operations
-        operation_words = ["and", "then", "also", "after", "before", "plus"]
-        has_multiple_ops = sum(1 for word in operation_words if word in request_lower) >= 2
-
-        return files_mentioned or has_complex_keyword or has_multiple_ops
-
-    def optimize_tool_selection(
-        self, user_request: str, tools_to_execute: List[Dict[str, Any]]
-    ) -> List[List[Dict[str, Any]]]:
-        """Optimize tool selection using DSPy patterns.
-
-        Returns tool calls organized in optimal batches for parallel execution.
-        """
-        if not tools_to_execute:
-            return []
-
-        # Try to use DSPy agent if available
-        dspy_agent = self.get_dspy_agent()
-        if dspy_agent:
-            try:
-                result = dspy_agent(user_request, self.state_manager.session.cwd or ".")
-                if hasattr(result, "tool_batches") and result.tool_batches:
-                    return result.tool_batches
-            except Exception as e:
-                logger.debug(f"DSPy optimization failed, using fallback: {e}")
-
-        # Fallback: Apply DSPy-learned patterns manually
-        return self._apply_dspy_patterns(tools_to_execute)
-
-    def _apply_dspy_patterns(self, tools: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
-        """Apply DSPy-learned batching patterns manually."""
-        from tunacode.constants import READ_ONLY_TOOLS
-
-        batches = []
-        current_batch = []
-
-        for tool in tools:
-            tool_name = tool.get("tool", "")
-
-            if tool_name in READ_ONLY_TOOLS:
-                current_batch.append(tool)
-                # Optimal batch size is 3-4 tools
-                if len(current_batch) >= 4:
-                    batches.append(current_batch)
-                    current_batch = []
-            else:
-                # Flush current batch if any
-                if current_batch:
-                    batches.append(current_batch)
-                    current_batch = []
-                # Add write/execute tool as single batch
-                batches.append([tool])
-
-        # Add remaining tools
-        if current_batch:
-            batches.append(current_batch)
-
-        return batches
-
-    def get_task_breakdown(self, complex_request: str) -> Optional[Dict[str, Any]]:
-        """Get task breakdown for complex requests using DSPy."""
-        dspy_agent = self.get_dspy_agent()
-        if not dspy_agent:
-            return None
-
-        try:
-            result = dspy_agent(complex_request, self.state_manager.session.cwd or ".")
-            if result.get("is_complex") and result.get("subtasks"):
-                return {
-                    "subtasks": result["subtasks"],
-                    "total_tool_calls": result.get("total_tool_calls", 0),
-                    "requires_todo": result.get("requires_todo", False),
-                    "parallelization_opportunities": result.get("parallelization_opportunities", 0),
-                }
-        except Exception as e:
-            logger.error(f"Failed to get task breakdown: {e}")
-
-        return None
-
-    def format_chain_of_thought(self, request: str, tools: List[str]) -> str:
-        """Format a Chain of Thought reasoning for tool selection."""
-        reasoning = f"Let's think step by step about '{request}':\n"
-
-        if "search" in request.lower() or "find" in request.lower():
-            reasoning += "1. This requires searching for information\n"
-            reasoning += "2. I'll use grep for content search and glob for file patterns\n"
-            reasoning += "3. These read-only tools can be executed in parallel\n"
-        elif "read" in request.lower() or "show" in request.lower():
-            reasoning += "1. This requires reading file contents\n"
-            reasoning += "2. I'll batch multiple read_file operations together\n"
-            reasoning += "3. All reads can happen in parallel for speed\n"
-        elif "fix" in request.lower() or "update" in request.lower():
-            reasoning += "1. First, I need to understand the current state\n"
-            reasoning += "2. I'll search and read relevant files in parallel\n"
-            reasoning += "3. Then make modifications sequentially for safety\n"
-
-        return reasoning

tunacode/core/agents/dspy_tunacode.py

@@ -1,458 +0,0 @@
-#!/usr/bin/env python3
-"""
-TunaCode DSPy Production Module
-
-Optimizes tool selection and task planning for TunaCode using DSPy.
-Includes 3-4 tool batching optimization for 3x performance gains.
-"""
-
-import json
-import logging
-import os
-import re
-from typing import Dict, List
-
-import dspy
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-# Tool Categories for TunaCode
-TOOL_CATEGORIES = {
-    "read_only": ["read_file", "grep", "list_dir", "glob"],  # Parallel-executable
-    "task_management": ["todo"],  # Fast, sequential
-    "write_execute": [
-        "write_file",
-        "update_file",
-        "run_command",
-        "bash",
-    ],  # Sequential, needs confirmation
-}
-
-ALL_TOOLS = [tool for category in TOOL_CATEGORIES.values() for tool in category]
-
-
-class ToolSelectionSignature(dspy.Signature):
-    """Select optimal tools with batching awareness."""
-
-    user_request: str = dspy.InputField(desc="The user's request or task")
-    current_directory: str = dspy.InputField(desc="Current working directory context")
-    tools_json: str = dspy.OutputField(
-        desc="JSON array of tool calls with batch grouping, e.g. [[tool1, tool2, tool3], [tool4]]"
-    )
-    requires_confirmation: bool = dspy.OutputField(
-        desc="Whether any tools require user confirmation"
-    )
-    reasoning: str = dspy.OutputField(desc="Explanation of tool choice and batching strategy")
-
-
-class TaskPlanningSignature(dspy.Signature):
-    """Break down complex tasks with tool hints."""
-
-    complex_request: str = dspy.InputField(desc="A complex task that needs breakdown")
-    subtasks_with_tools: str = dspy.OutputField(
-        desc="JSON array of {task, tools, priority} objects"
-    )
-    total_tool_calls: int = dspy.OutputField(desc="Estimated total number of tool calls")
-    requires_todo: bool = dspy.OutputField(desc="Whether todo tool should be used")
-    parallelization_opportunities: int = dspy.OutputField(
-        desc="Number of parallel execution opportunities"
-    )
-
-
-class PathValidationSignature(dspy.Signature):
-    """Validate and convert paths to relative format."""
-
-    path: str = dspy.InputField(desc="Path to validate")
-    current_directory: str = dspy.InputField(desc="Current working directory")
-    is_valid: bool = dspy.OutputField(desc="Whether path is valid relative path")
-    relative_path: str = dspy.OutputField(desc="Converted relative path")
-    reason: str = dspy.OutputField(desc="Validation result explanation")
-
-
-class OptimizedToolSelector(dspy.Module):
-    """Tool selection with batching optimization"""
-
-    def __init__(self):
-        self.predict = dspy.ChainOfThought(ToolSelectionSignature)
-
-    def forward(self, user_request: str, current_directory: str = "."):
-        logger.debug(f"Tool Selection for: {user_request}")
-        result = self.predict(user_request=user_request, current_directory=current_directory)
-
-        # Parse and validate tool batches
-        try:
-            tool_batches = json.loads(result.tools_json)
-            validated_batches = self._validate_batches(tool_batches)
-            result.tool_batches = validated_batches
-        except Exception as e:
-            logger.error(f"Failed to parse tool batches: {e}")
-            result.tool_batches = []
-
-        return result
-
-    def _validate_batches(self, batches: List[List[str]]) -> List[List[Dict]]:
-        """Validate and optimize tool batches for 3-4 tool rule"""
-        validated = []
-
-        for batch in batches:
-            # Check if batch contains only read-only tools
-            all_read_only = all(
-                any(tool_name in tool for tool_name in TOOL_CATEGORIES["read_only"])
-                for tool in batch
-            )
-
-            # Optimize batch size (3-4 tools is optimal)
-            if all_read_only and len(batch) > 4:
-                # Split large batches
-                for i in range(0, len(batch), 4):
-                    sub_batch = batch[i : i + 4]
-                    validated.append(self._parse_tools(sub_batch))
-            else:
-                validated_batch = self._parse_tools(batch)
-                if validated_batch:
-                    validated.append(validated_batch)
-
-        return validated
-
-    def _parse_tools(self, tools: List[str]) -> List[Dict]:
-        """Parse tool strings into proper format"""
-        parsed = []
-        for tool_str in tools:
-            # Extract tool name and args from string like "read_file('main.py')"
-            match = re.match(r"(\w+)\((.*)\)", tool_str)
-            if match:
-                tool_name = match.group(1)
-                args_str = match.group(2)
-
-                tool_dict = {"tool": tool_name, "args": {}}
-                if args_str:
-                    # Handle simple cases like 'file.py' or "pattern", "dir"
-                    args = [arg.strip().strip("\"'") for arg in args_str.split(",")]
-                    if tool_name == "read_file":
-                        tool_dict["args"]["filepath"] = args[0]
-                    elif tool_name == "grep":
-                        tool_dict["args"]["pattern"] = args[0]
-                        if len(args) > 1:
-                            tool_dict["args"]["directory"] = args[1]
-                    elif tool_name == "list_dir":
-                        tool_dict["args"]["directory"] = args[0] if args else "."
-                    elif tool_name == "glob":
-                        tool_dict["args"]["pattern"] = args[0]
-                        if len(args) > 1:
-                            tool_dict["args"]["directory"] = args[1]
-                    elif tool_name == "todo":
-                        tool_dict["args"]["action"] = args[0] if args else "list"
-                    elif tool_name in ["write_file", "update_file"]:
-                        if args:
-                            tool_dict["args"]["filepath"] = args[0]
-                    elif tool_name in ["run_command", "bash"]:
-                        if args:
-                            tool_dict["args"]["command"] = args[0]
-
-                parsed.append(tool_dict)
-
-        return parsed
-
-
-class EnhancedTaskPlanner(dspy.Module):
-    """Task planning with tool awareness"""
-
-    def __init__(self):
-        self.predict = dspy.ChainOfThought(TaskPlanningSignature)
-
-    def forward(self, complex_request: str):
-        logger.debug(f"Task Planning for: {complex_request}")
-        result = self.predict(complex_request=complex_request)
-
-        # Parse subtasks
-        try:
-            result.subtasks = json.loads(result.subtasks_with_tools)
-        except Exception as e:
-            logger.error(f"Failed to parse subtasks: {e}")
-            result.subtasks = []
-
-        return result
-
-
-class PathValidator(dspy.Module):
-    """Ensure all paths are relative"""
-
-    def __init__(self):
-        self.predict = dspy.Predict(PathValidationSignature)
-
-    def forward(self, path: str, current_directory: str = "."):
-        return self.predict(path=path, current_directory=current_directory)
-
-
-class TunaCodeDSPy(dspy.Module):
-    """Main TunaCode DSPy agent"""
-
-    def __init__(self):
-        self.tool_selector = OptimizedToolSelector()
-        self.task_planner = EnhancedTaskPlanner()
-        self.path_validator = PathValidator()
-
-    def forward(self, user_request: str, current_directory: str = "."):
-        """Process request with optimization"""
-
-        # Detect request complexity
-        is_complex = self._is_complex_task(user_request)
-
-        result = {
-            "request": user_request,
-            "is_complex": is_complex,
-            "current_directory": current_directory,
-        }
-
-        if is_complex:
-            # Use task planner for complex tasks
-            task_plan = self.task_planner(complex_request=user_request)
-            result["subtasks"] = task_plan.subtasks
-            result["total_tool_calls"] = task_plan.total_tool_calls
-            result["requires_todo"] = task_plan.requires_todo
-            result["parallelization_opportunities"] = task_plan.parallelization_opportunities
-
-            if task_plan.requires_todo:
-                result["initial_action"] = "Use todo tool to create task list"
-        else:
-            # Direct tool selection with batching
-            tool_selection = self.tool_selector(
-                user_request=user_request, current_directory=current_directory
-            )
-            result["tool_batches"] = tool_selection.tool_batches
-            result["requires_confirmation"] = tool_selection.requires_confirmation
-            result["reasoning"] = tool_selection.reasoning
-
-        return result
-
-    def _is_complex_task(self, request: str) -> bool:
-        """Detect if task is complex based on keywords and patterns"""
-        complex_indicators = [
-            "implement",
-            "create",
-            "build",
-            "refactor",
-            "add feature",
-            "fix all",
-            "update multiple",
-            "migrate",
-            "integrate",
-            "debug",
-            "optimize performance",
-            "add authentication",
-            "setup",
-            "configure",
-            "test suite",
-        ]
-
-        request_lower = request.lower()
-
-        # Check for multiple files mentioned
-        file_pattern = r"\b\w+\.\w+\b"
-        files_mentioned = len(re.findall(file_pattern, request)) > 2
-
-        # Check for complex keywords
-        has_complex_keyword = any(indicator in request_lower for indicator in complex_indicators)
-
-        # Check for multiple operations
-        operation_words = ["and", "then", "also", "after", "before", "plus"]
-        has_multiple_ops = sum(1 for word in operation_words if word in request_lower) >= 2
-
-        return files_mentioned or has_complex_keyword or has_multiple_ops
-
-    def validate_path(self, path: str, current_directory: str = ".") -> Dict:
-        """Validate a path is relative and safe"""
-        return self.path_validator(path, current_directory)
-
-
-def get_tool_selection_examples():
-    """Training examples for tool selection"""
-    return [
-        dspy.Example(
-            user_request="Show me the authentication system implementation",
-            current_directory=".",
-            tools_json='[["grep(\\"auth\\", \\"src/\\")", "list_dir(\\"src/auth/\\")", "glob(\\"**/*auth*.py\\")"]]',
-            requires_confirmation=False,
-            reasoning="Batch 3 read-only tools for parallel search - optimal performance",
-        ).with_inputs("user_request", "current_directory"),
-        dspy.Example(
-            user_request="Read all config files and the main module",
-            current_directory=".",
-            tools_json='[["read_file(\\"config.json\\")", "read_file(\\"settings.py\\")", "read_file(\\".env\\")", "read_file(\\"main.py\\")"]]',
-            requires_confirmation=False,
-            reasoning="Batch 4 file reads together - maximum optimal batch size",
-        ).with_inputs("user_request", "current_directory"),
-        dspy.Example(
-            user_request="Find the bug in validation and fix it",
-            current_directory=".",
-            tools_json='[["grep(\\"error\\", \\"logs/\\")", "grep(\\"validation\\", \\"src/\\")", "list_dir(\\"src/validators/\\")"], ["read_file(\\"src/validators/user.py\\")"], ["update_file(\\"src/validators/user.py\\", \\"old\\", \\"new\\")"]]',
-            requires_confirmation=True,
-            reasoning="Search tools batched, then read, then sequential write operation",
-        ).with_inputs("user_request", "current_directory"),
-    ]
-
-
-def get_task_planning_examples():
-    """Training examples for task planning"""
-    return [
-        dspy.Example(
-            complex_request="Implement user authentication system with JWT tokens",
-            subtasks_with_tools='[{"task": "Analyze current app structure", "tools": ["list_dir", "grep", "read_file"], "priority": "high"}, {"task": "Design user model", "tools": ["write_file"], "priority": "high"}, {"task": "Create auth endpoints", "tools": ["write_file", "update_file"], "priority": "high"}, {"task": "Add JWT tokens", "tools": ["write_file", "grep"], "priority": "high"}, {"task": "Write tests", "tools": ["write_file", "run_command"], "priority": "medium"}]',
-            total_tool_calls=15,
-            requires_todo=True,
-            parallelization_opportunities=3,
-        ).with_inputs("complex_request"),
-    ]
-
-
-def tool_selection_metric(example, prediction):
-    """Metric for tool selection evaluation"""
-    score = 0.0
-
-    # Tool accuracy (40%)
-    if hasattr(prediction, "tool_batches") and hasattr(example, "tools_json"):
-        try:
-            expected = json.loads(example.tools_json)
-            predicted = prediction.tool_batches
-
-            # Check tool selection accuracy
-            expected_tools = set()
-            predicted_tools = set()
-
-            for batch in expected:
-                for tool in batch:
-                    tool_name = re.match(r"(\w+)\(", tool)
-                    if tool_name:
-                        expected_tools.add(tool_name.group(1))
-
-            for batch in predicted:
-                for tool in batch:
-                    if isinstance(tool, dict):
-                        predicted_tools.add(tool.get("tool", ""))
-
-            if expected_tools == predicted_tools:
-                score += 0.4
-            else:
-                overlap = len(expected_tools & predicted_tools)
-                total = len(expected_tools | predicted_tools)
-                if total > 0:
-                    score += 0.4 * (overlap / total)
-        except Exception:
-            pass
-
-    # Batching optimization (30%)
-    if hasattr(prediction, "tool_batches"):
-        batches = prediction.tool_batches
-        optimal_batching = True
-
-        for batch in batches:
-            if len(batch) > 0:
-                batch_tools = [tool.get("tool", "") for tool in batch if isinstance(tool, dict)]
-                if all(tool in TOOL_CATEGORIES["read_only"] for tool in batch_tools):
-                    if len(batch) < 3 or len(batch) > 4:
-                        optimal_batching = False
-                        break
-
-        if optimal_batching:
-            score += 0.3
-
-    # Confirmation accuracy (20%)
-    if hasattr(prediction, "requires_confirmation") and hasattr(example, "requires_confirmation"):
-        if prediction.requires_confirmation == example.requires_confirmation:
-            score += 0.2
-
-    # Reasoning quality (10%)
-    if hasattr(prediction, "reasoning") and prediction.reasoning and len(prediction.reasoning) > 20:
-        score += 0.1
-
-    return score
-
-
-def task_planning_metric(example, prediction):
-    """Metric for task planning evaluation"""
-    score = 0.0
-
-    # Subtask quality (30%)
-    if hasattr(prediction, "subtasks") and hasattr(example, "subtasks_with_tools"):
-        try:
-            expected = json.loads(example.subtasks_with_tools)
-            predicted = prediction.subtasks
-
-            if abs(len(expected) - len(predicted)) <= 1:
-                score += 0.3
-            elif abs(len(expected) - len(predicted)) <= 2:
-                score += 0.15
-        except Exception:
-            pass
-
-    # Tool estimation accuracy (30%)
-    if hasattr(prediction, "total_tool_calls") and hasattr(example, "total_tool_calls"):
-        if abs(prediction.total_tool_calls - example.total_tool_calls) <= 5:
-            score += 0.3
-        elif abs(prediction.total_tool_calls - example.total_tool_calls) <= 10:
-            score += 0.15
-
-    # Todo requirement (20%)
-    if hasattr(prediction, "requires_todo") and hasattr(example, "requires_todo"):
-        if prediction.requires_todo == example.requires_todo:
-            score += 0.2
-
-    # Parallelization awareness (20%)
-    if hasattr(prediction, "parallelization_opportunities") and hasattr(
-        example, "parallelization_opportunities"
-    ):
-        if (
-            abs(prediction.parallelization_opportunities - example.parallelization_opportunities)
-            <= 2
-        ):
-            score += 0.2
-
-    return score
-
-
-def create_optimized_agent(api_key: str = None, model: str = "openrouter/openai/gpt-4.1-mini"):
-    """Create and optimize the TunaCode DSPy agent"""
-
-    # Configure DSPy
-    if not api_key:
-        api_key = os.getenv("OPENROUTER_API_KEY")
-        if not api_key:
-            raise ValueError("Please set OPENROUTER_API_KEY environment variable")
-
-    lm = dspy.LM(
-        model,
-        api_base="https://openrouter.ai/api/v1",
-        api_key=api_key,
-        temperature=0.3,
-    )
-    dspy.configure(lm=lm)
-
-    # Create agent
-    agent = TunaCodeDSPy()
-
-    # Optimize tool selector
-    tool_examples = get_tool_selection_examples()
-    tool_optimizer = dspy.BootstrapFewShot(
-        metric=lambda ex, pred, trace: tool_selection_metric(ex, pred),
-        max_bootstrapped_demos=3,
-    )
-    agent.tool_selector = tool_optimizer.compile(agent.tool_selector, trainset=tool_examples)
-
-    # Optimize task planner
-    task_examples = get_task_planning_examples()
-    task_optimizer = dspy.BootstrapFewShot(
-        metric=lambda ex, pred, trace: task_planning_metric(ex, pred),
-        max_bootstrapped_demos=2,
-    )
-    agent.task_planner = task_optimizer.compile(agent.task_planner, trainset=task_examples)
-
-    return agent
-
-
-agent = create_optimized_agent()
-result = agent("Show me the authentication implementation", ".")

tunacode/prompts/dspy_task_planning.md

@@ -1,45 +0,0 @@
-# DSPy Task Planning Prompt
-
-This prompt is automatically generated and optimized by DSPy for TunaCode's complex task planning.
-
-## Format
-
-Given the fields `complex_request`, produce the fields `subtasks_with_tools`, `total_tool_calls`, `requires_todo`, `parallelization_opportunities`.
-
----
-
-Follow the following format.
-
-Complex Request: A complex task that needs breakdown
-Reasoning: Let's think step by step in order to ${produce the answer}. We need to break this down into manageable subtasks...
-Subtasks With Tools: JSON array of {task, tools, priority} objects
-Total Tool Calls: Estimated total number of tool calls
-Requires Todo: Whether todo tool should be used
-Parallelization Opportunities: Number of parallel execution opportunities
-
----
-
-## Learned Example (Selected by DSPy)
-
-### Example: Authentication System Implementation
-Complex Request: Implement user authentication system with JWT tokens
-Reasoning: Let's think step by step. This is a complex implementation task that requires multiple components. First, I need to analyze the current application structure to understand how to integrate authentication. Then I'll design the user model and database schema. Next, I'll create the authentication endpoints for registration and login. I'll need to implement JWT token generation and validation. Finally, I'll add tests to ensure everything works correctly. Several of these tasks can be done in parallel once the initial analysis is complete.
-Subtasks With Tools: [{"task": "Analyze current app structure", "tools": ["list_dir", "grep", "read_file"], "priority": "high"}, {"task": "Design user model", "tools": ["write_file"], "priority": "high"}, {"task": "Create auth endpoints", "tools": ["write_file", "update_file"], "priority": "high"}, {"task": "Add JWT tokens", "tools": ["write_file", "grep"], "priority": "high"}, {"task": "Write tests", "tools": ["write_file", "run_command"], "priority": "medium"}]
-Total Tool Calls: 15
-Requires Todo: true
-Parallelization Opportunities: 3
-
----
-
-## Key Patterns for Complex Tasks
-
-1. **Break Down First**: Start with analysis/exploration before implementation
-2. **Priority Levels**: High for core functionality, medium for tests/docs, low for nice-to-haves
-3. **Tool Grouping**: Group related tools together for each subtask
-4. **Todo Usage**: Use todo tool for tasks with 5+ subtasks
-5. **Parallelization**: Identify independent subtasks that can run concurrently
-
----
-
-Complex Request: ${complex_request}
-Reasoning: Let's think step by step...

tunacode/prompts/dspy_tool_selection.md

@@ -1,58 +0,0 @@
-# DSPy Tool Selection Prompt
-
-This prompt is automatically generated and optimized by DSPy for TunaCode's tool selection.
-
-## Format
-
-Given the fields `user_request`, `current_directory`, produce the fields `tools_json`, `requires_confirmation`, `reasoning`.
-
----
-
-Follow the following format.
-
-User Request: The user's request or task
-Current Directory: Current working directory context
-Reasoning: Let's think step by step in order to ${produce the answer}. We ...
-Tools Json: JSON array of tool calls with batch grouping, e.g. [[tool1, tool2, tool3], [tool4]]
-Requires Confirmation: Whether any tools require user confirmation
-
----
-
-## Learned Examples (Automatically Selected by DSPy)
-
-### Example 1: Searching for Implementation
-User Request: Show me the authentication system implementation
-Current Directory: .
-Reasoning: Let's think step by step. To show the authentication implementation, I need to search for auth-related files across the codebase. I'll use grep to find files containing 'auth', list the auth directory if it exists, and use glob to find all auth-related Python files. These are all read-only operations that can be executed in parallel.
-Tools Json: [["grep(\"auth\", \"src/\")", "list_dir(\"src/auth/\")", "glob(\"**/*auth*.py\")"]]
-Requires Confirmation: false
-
-### Example 2: Reading Multiple Files (Optimal Batching)
-User Request: Read all config files and the main module  
-Current Directory: .
-Reasoning: Let's think step by step. I need to read multiple specific files. All of these are read operations that can be batched together for parallel execution. I'll batch them in a group of 4 for optimal performance.
-Tools Json: [["read_file(\"config.json\")", "read_file(\"settings.py\")", "read_file(\".env\")", "read_file(\"main.py\")"]]
-Requires Confirmation: false
-
-### Example 3: Search, Read, then Modify Pattern
-User Request: Find the bug in validation and fix it
-Current Directory: .
-Reasoning: Let's think step by step. First, I need to search for validation-related code and errors. I'll use grep to search for error patterns and validation code, and list the validators directory. These search operations can be parallelized. After finding the issue, I'll need to read the specific file and then update it to fix the bug.
-Tools Json: [["grep(\"error\", \"logs/\")", "grep(\"validation\", \"src/\")", "list_dir(\"src/validators/\")"], ["read_file(\"src/validators/user.py\")"], ["update_file(\"src/validators/user.py\", \"old\", \"new\")"]]
-Requires Confirmation: true
-
----
-
-## Key Patterns Learned by DSPy
-
-1. **3-4 Tool Batching**: Optimal batch size for parallel read-only operations
-2. **Read-Only Parallelization**: grep, list_dir, glob, read_file can run in parallel
-3. **Sequential Writes**: write_file, update_file, run_command, bash must run sequentially
-4. **Confirmation Required**: Any write/execute operation needs confirmation
-5. **Search → Read → Modify**: Common pattern for debugging and fixes
-
----
-
-User Request: ${user_request}
-Current Directory: ${current_directory}
-Reasoning: Let's think step by step...