tunacode-cli 0.0.47__tar.gz → 0.0.48__tar.gz

{tunacode_cli-0.0.47/src/tunacode_cli.egg-info → tunacode_cli-0.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.47
+Version: 0.0.48
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License: MIT
@@ -37,7 +37,7 @@ Requires-Dist: textual-dev; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Dynamic: license-file
 
-# TunaCode
+# TunaCode CLI
 
 <div align="center">
 
@@ -48,7 +48,7 @@ Dynamic: license-file
 
 **AI-powered CLI coding assistant**
 
-![TunaCode Example](assets/tunacode_example.png)
+![Demo](docs/assets/demo.gif)
 
 </div>
 

{tunacode_cli-0.0.47 → tunacode_cli-0.0.48}/README.md

@@ -1,4 +1,4 @@
-# TunaCode
+# TunaCode CLI
 
 <div align="center">
 
@@ -9,7 +9,7 @@
 
 **AI-powered CLI coding assistant**
 
-![TunaCode Example](assets/tunacode_example.png)
+![Demo](docs/assets/demo.gif)
 
 </div>
 

{tunacode_cli-0.0.47 → tunacode_cli-0.0.48}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.47"
+version = "0.0.48"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"

{tunacode_cli-0.0.47 → tunacode_cli-0.0.48}/src/tunacode/cli/main.py

@@ -5,7 +5,6 @@ Enhanced CLI entry point with better styling while staying CLI-based.
 """
 
 import asyncio
-import logging
 
 import typer
 
@@ -37,9 +36,6 @@ def main(
 ):
     """Start TunaCode - Your AI-powered development assistant"""
 
-    # Configure logging to suppress INFO messages by default
-    logging.basicConfig(level=logging.WARNING, force=True)
-
     async def async_main():
         if version:
             await ui.version()

{tunacode_cli-0.0.47 → tunacode_cli-0.0.48}/src/tunacode/cli/repl.py

@@ -344,7 +344,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
     except CancelledError:
         await ui.muted(MSG_REQUEST_CANCELLED)
     except UserAbortError:
-        await ui.muted(MSG_OPERATION_ABORTED_BY_USER)
+        await ui.muted(MSG_OPERATION_ABORTED)
     except UnexpectedModelBehavior as e:
         error_message = str(e)
         await ui.muted(error_message)
@@ -385,13 +385,9 @@ 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)
-
-    # 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
+    await ui.muted(f"• Model: {model_name} • {context_display}")
+    await ui.success("Ready to assist")
+    await ui.line()
 
     instance = agent.get_or_create_agent(state_manager.session.current_model, state_manager)
 
@@ -463,16 +459,13 @@ async def repl(state_manager: StateManager):
             state_manager.session.current_task = get_app().create_background_task(
                 process_request(line, state_manager)
             )
+            await state_manager.session.current_task
 
             state_manager.session.update_token_count()
             context_display = get_context_window_display(
                 state_manager.session.total_tokens, state_manager.session.max_tokens
             )
-            # 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}"
-                )
+            await ui.muted(f"• Model: {state_manager.session.current_model} • {context_display}")
 
         if action == "restart":
             await repl(state_manager)
@@ -487,7 +480,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 state_manager.session.show_thoughts and (total_tokens > 0 or total_cost > 0):
+                    if 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_cli-0.0.47 → tunacode_cli-0.0.48}/src/tunacode/configuration/defaults.py

@@ -24,6 +24,7 @@ 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_cli-0.0.47 → tunacode_cli-0.0.48}/src/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.47"
+APP_VERSION = "0.0.48"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"
@@ -157,8 +157,3 @@ MAX_TODOS_PER_SESSION = 100
 
 # Maximum length for todo content
 MAX_TODO_CONTENT_LENGTH = 500
-
-# JSON parsing retry configuration
-JSON_PARSE_MAX_RETRIES = 10
-JSON_PARSE_BASE_DELAY = 0.1  # Initial delay in seconds
-JSON_PARSE_MAX_DELAY = 5.0  # Maximum delay in seconds

tunacode_cli-0.0.48/src/tunacode/core/agents/dspy_integration.py

@@ -0,0 +1,223 @@
+"""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