tunacode-cli 0.0.27__tar.gz → 0.0.29__tar.gz

tunacode_cli-0.0.29/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: tunacode-cli
+Version: 0.0.29
+Summary: Your agentic CLI developer.
+Author-email: larock22 <noreply@github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/larock22/tunacode
+Project-URL: Repository, https://github.com/larock22/tunacode
+Keywords: cli,agent,development,automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer==0.15.3
+Requires-Dist: prompt_toolkit==3.0.51
+Requires-Dist: pydantic-ai[logfire]==0.2.6
+Requires-Dist: pygments==2.19.1
+Requires-Dist: rich==14.0.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: textual-dev; extra == "dev"
+Dynamic: license-file
+
+# TunaCode
+
+<div align="center">
+
+[![PyPI version](https://badge.fury.io/py/tunacode-cli.svg)](https://badge.fury.io/py/tunacode-cli)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**AI-powered CLI coding assistant**
+
+![Demo](demo.gif)
+
+</div>
+
+---
+
+## Quick Install
+
+```bash
+# Option 1: One-line install (Linux/macOS)
+wget -qO- https://raw.githubusercontent.com/alchemiststudiosDOTai/tunacode/master/scripts/install_linux.sh | bash
+
+# Option 2: pip install
+pip install tunacode-cli
+```
+
+## Configuration
+
+Choose your AI provider and set your API key:
+
+```bash
+# OpenAI
+tunacode --model "openai:gpt-4o" --key "sk-your-openai-key"
+
+# Anthropic Claude  
+tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
+
+# OpenRouter (100+ models)
+tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
+```
+
+Your config is saved to `~/.config/tunacode.json`
+
+## Start Coding
+
+```bash
+tunacode
+```
+
+## Basic Commands
+
+| Command | Description |
+| ------- | ----------- |
+| `/help` | Show all commands |
+| `/model <provider:name>` | Switch model |
+| `/clear` | Clear message history |
+| `/compact` | Summarize conversation |
+| `/branch <name>` | Create Git branch |
+| `/yolo` | Skip confirmations |
+| `!<command>` | Run shell command |
+| `exit` | Exit TunaCode |
+
+## Safety First
+
+⚠️ **Important**: TunaCode can modify your codebase. Always:
+- Use Git branches before making changes
+- Review file modifications before confirming
+- Keep backups of important work
+
+## Documentation
+
+- [**Features**](documentation/FEATURES.md) - All features, tools, and commands
+- [**Advanced Configuration**](documentation/ADVANCED-CONFIG.md) - Provider setup, MCP, customization
+- [**Architecture**](documentation/ARCHITECTURE.md) - Source code organization and design
+- [**Development**](documentation/DEVELOPMENT.md) - Contributing and development setup
+
+## Links
+
+- [PyPI Package](https://pypi.org/project/tunacode-cli/)
+- [GitHub Repository](https://github.com/alchemiststudiosDOTai/tunacode)
+- [Report Issues](https://github.com/alchemiststudiosDOTai/tunacode/issues)
+
+---
+
+MIT License - see [LICENSE](LICENSE) file

tunacode_cli-0.0.29/README.md

@@ -0,0 +1,85 @@
+# TunaCode
+
+<div align="center">
+
+[![PyPI version](https://badge.fury.io/py/tunacode-cli.svg)](https://badge.fury.io/py/tunacode-cli)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**AI-powered CLI coding assistant**
+
+![Demo](demo.gif)
+
+</div>
+
+---
+
+## Quick Install
+
+```bash
+# Option 1: One-line install (Linux/macOS)
+wget -qO- https://raw.githubusercontent.com/alchemiststudiosDOTai/tunacode/master/scripts/install_linux.sh | bash
+
+# Option 2: pip install
+pip install tunacode-cli
+```
+
+## Configuration
+
+Choose your AI provider and set your API key:
+
+```bash
+# OpenAI
+tunacode --model "openai:gpt-4o" --key "sk-your-openai-key"
+
+# Anthropic Claude  
+tunacode --model "anthropic:claude-3.5-sonnet" --key "sk-ant-your-anthropic-key"
+
+# OpenRouter (100+ models)
+tunacode --model "openrouter:openai/gpt-4o" --key "sk-or-your-openrouter-key"
+```
+
+Your config is saved to `~/.config/tunacode.json`
+
+## Start Coding
+
+```bash
+tunacode
+```
+
+## Basic Commands
+
+| Command | Description |
+| ------- | ----------- |
+| `/help` | Show all commands |
+| `/model <provider:name>` | Switch model |
+| `/clear` | Clear message history |
+| `/compact` | Summarize conversation |
+| `/branch <name>` | Create Git branch |
+| `/yolo` | Skip confirmations |
+| `!<command>` | Run shell command |
+| `exit` | Exit TunaCode |
+
+## Safety First
+
+⚠️ **Important**: TunaCode can modify your codebase. Always:
+- Use Git branches before making changes
+- Review file modifications before confirming
+- Keep backups of important work
+
+## Documentation
+
+- [**Features**](documentation/FEATURES.md) - All features, tools, and commands
+- [**Advanced Configuration**](documentation/ADVANCED-CONFIG.md) - Provider setup, MCP, customization
+- [**Architecture**](documentation/ARCHITECTURE.md) - Source code organization and design
+- [**Development**](documentation/DEVELOPMENT.md) - Contributing and development setup
+
+## Links
+
+- [PyPI Package](https://pypi.org/project/tunacode-cli/)
+- [GitHub Repository](https://github.com/alchemiststudiosDOTai/tunacode)
+- [Report Issues](https://github.com/alchemiststudiosDOTai/tunacode/issues)
+
+---
+
+MIT License - see [LICENSE](LICENSE) file

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/pyproject.toml

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

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/src/tunacode/cli/commands.py

@@ -521,13 +521,92 @@ class CompactCommand(SimpleCommand):
             await ui.error("Compact command not available - process_request not configured")
             return
 
-        # Get the current agent, create a summary of context, and trim message history
-        await process_request(
-            "Summarize the conversation so far", context.state_manager, output=False
+        # Count current messages
+        original_count = len(context.state_manager.session.messages)
+
+        # Generate summary with output captured
+        summary_prompt = (
+            "Summarize the conversation so far in a concise paragraph, "
+            "focusing on the main topics discussed and any important context "
+            "that should be preserved."
         )
-        await ui.success("Context history has been summarized and truncated.")
+        result = await process_request(
+            summary_prompt,
+            context.state_manager,
+            output=False,  # We'll handle the output ourselves
+        )
+
+        # Extract summary text from result
+        summary_text = ""
+
+        # First try: standard result structure
+        if (
+            result
+            and hasattr(result, "result")
+            and result.result
+            and hasattr(result.result, "output")
+        ):
+            summary_text = result.result.output
+
+        # Second try: check messages for assistant response
+        if not summary_text:
+            messages = context.state_manager.session.messages
+            # Look through new messages in reverse order
+            for i in range(len(messages) - 1, original_count - 1, -1):
+                msg = messages[i]
+                # Handle ModelResponse objects
+                if hasattr(msg, "parts") and msg.parts:
+                    for part in msg.parts:
+                        if hasattr(part, "content") and part.content:
+                            content = part.content
+                            # Skip JSON thought objects
+                            if content.strip().startswith('{"thought"'):
+                                lines = content.split("\n")
+                                # Find the actual summary after the JSON
+                                for i, line in enumerate(lines):
+                                    if (
+                                        line.strip()
+                                        and not line.strip().startswith("{")
+                                        and not line.strip().endswith("}")
+                                    ):
+                                        summary_text = "\n".join(lines[i:]).strip()
+                                        break
+                            else:
+                                summary_text = content
+                            if summary_text:
+                                break
+                # Handle dict-style messages
+                elif isinstance(msg, dict):
+                    if msg.get("role") == "assistant" and msg.get("content"):
+                        summary_text = msg["content"]
+                        break
+                # Handle other message types
+                elif hasattr(msg, "content") and hasattr(msg, "role"):
+                    if getattr(msg, "role", None) == "assistant":
+                        summary_text = msg.content
+                        break
+
+                if summary_text:
+                    break
+
+        if not summary_text:
+            await ui.error("Failed to generate summary - no assistant response found")
+            return
+
+        # Display summary in a formatted panel
+        from tunacode.ui import panels
+
+        await panels.panel("Conversation Summary", summary_text, border_style="cyan")
+
+        # Show statistics
+        await ui.info(f"Current message count: {original_count}")
+        await ui.info("After compaction: 3 (summary + last 2 messages)")
+
+        # Truncate the conversation history
         context.state_manager.session.messages = context.state_manager.session.messages[-2:]
 
+        await ui.success("Context history has been summarized and truncated.")
+
 
 class UpdateCommand(SimpleCommand):
     """Update TunaCode to the latest version."""

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/src/tunacode/configuration/defaults.py

@@ -22,6 +22,7 @@ DEFAULT_USER_CONFIG: UserConfig = {
         "tool_ignore": [TOOL_READ_FILE],
         "guide_file": GUIDE_FILE_NAME,
         "fallback_response": True,
+        "fallback_verbosity": "normal",  # Options: minimal, normal, detailed
     },
     "mcpServers": {},
 }

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/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.27"
+APP_VERSION = "0.0.29"
 
 # File patterns
 GUIDE_FILE_PATTERN = "{name}.md"

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/src/tunacode/core/agents/main.py

@@ -375,10 +375,91 @@ async def process_request(
         if not response_state.has_user_response and i >= max_iterations and fallback_enabled:
             patch_tool_messages("Task incomplete", state_manager=state_manager)
             response_state.has_final_synthesis = True
+
+            # Extract context from the agent run
+            tool_calls_summary = []
+            files_modified = set()
+            commands_run = []
+
+            # Analyze message history for context
+            for msg in state_manager.session.messages:
+                if hasattr(msg, "parts"):
+                    for part in msg.parts:
+                        if hasattr(part, "part_kind") and part.part_kind == "tool-call":
+                            tool_name = getattr(part, "tool_name", "unknown")
+                            tool_calls_summary.append(tool_name)
+
+                            # Track specific operations
+                            if tool_name in ["write_file", "update_file"] and hasattr(part, "args"):
+                                if "file_path" in part.args:
+                                    files_modified.add(part.args["file_path"])
+                            elif tool_name in ["run_command", "bash"] and hasattr(part, "args"):
+                                if "command" in part.args:
+                                    commands_run.append(part.args["command"])
+
+            # Build fallback response with context
             fallback = FallbackResponse(
                 summary="Reached maximum iterations without producing a final response.",
-                progress=f"{i}/{max_iterations} iterations completed",
+                progress=f"Completed {i} iterations (limit: {max_iterations})",
+            )
+
+            # Get verbosity setting
+            verbosity = state_manager.session.user_config.get("settings", {}).get(
+                "fallback_verbosity", "normal"
+            )
+
+            if verbosity in ["normal", "detailed"]:
+                # Add what was attempted
+                if tool_calls_summary:
+                    tool_counts = {}
+                    for tool in tool_calls_summary:
+                        tool_counts[tool] = tool_counts.get(tool, 0) + 1
+
+                    fallback.issues.append(f"Executed {len(tool_calls_summary)} tool calls:")
+                    for tool, count in sorted(tool_counts.items()):
+                        fallback.issues.append(f"  • {tool}: {count}x")
+
+                if verbosity == "detailed":
+                    if files_modified:
+                        fallback.issues.append(f"\nFiles modified ({len(files_modified)}):")
+                        for f in sorted(files_modified)[:5]:  # Limit to 5 files
+                            fallback.issues.append(f"  • {f}")
+                        if len(files_modified) > 5:
+                            fallback.issues.append(f"  • ... and {len(files_modified) - 5} more")
+
+                    if commands_run:
+                        fallback.issues.append(f"\nCommands executed ({len(commands_run)}):")
+                        for cmd in commands_run[:3]:  # Limit to 3 commands
+                            # Truncate long commands
+                            display_cmd = cmd if len(cmd) <= 60 else cmd[:57] + "..."
+                            fallback.issues.append(f"  • {display_cmd}")
+                        if len(commands_run) > 3:
+                            fallback.issues.append(f"  • ... and {len(commands_run) - 3} more")
+
+            # Add helpful next steps
+            fallback.next_steps.append(
+                "The task may be too complex - try breaking it into smaller steps"
             )
+            fallback.next_steps.append("Check the output above for any errors or partial progress")
+            if files_modified:
+                fallback.next_steps.append("Review modified files to see what changes were made")
+
+            # Create comprehensive output
+            output_parts = [fallback.summary, ""]
+
+            if fallback.progress:
+                output_parts.append(f"Progress: {fallback.progress}")
+
+            if fallback.issues:
+                output_parts.append("\nWhat happened:")
+                output_parts.extend(fallback.issues)
+
+            if fallback.next_steps:
+                output_parts.append("\nSuggested next steps:")
+                for step in fallback.next_steps:
+                    output_parts.append(f"  • {step}")
+
+            comprehensive_output = "\n".join(output_parts)
 
             # Create a wrapper object that mimics AgentRun with the required attributes
             class AgentRunWrapper:
@@ -391,7 +472,7 @@ async def process_request(
                     # Delegate all other attributes to the wrapped object
                     return getattr(self._wrapped, name)
 
-            return AgentRunWrapper(agent_run, SimpleResult(fallback.summary))
+            return AgentRunWrapper(agent_run, SimpleResult(comprehensive_output))
 
         # For non-fallback cases, we still need to handle the response_state
         # Create a minimal wrapper just to add response_state

tunacode_cli-0.0.29/src/tunacode/core/agents/orchestrator.py

@@ -0,0 +1,213 @@
+"""Agent orchestration scaffolding.
+
+This module defines an ``OrchestratorAgent`` class that demonstrates how
+higher level planning and delegation could be layered on top of the existing
+``process_request`` workflow.  The goal is to keep orchestration logic isolated
+from the core agent implementation while reusing all current tooling and state
+handling provided by ``main.process_request``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import itertools
+from typing import List
+
+from ...types import AgentRun, FallbackResponse, ModelName, ResponseState
+from ..llm.planner import make_plan
+from ..state import StateManager
+from . import main as agent_main
+from .planner_schema import Task
+from .readonly import ReadOnlyAgent
+
+
+class OrchestratorAgent:
+    """Plan and run a sequence of sub-agent tasks."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state = state_manager
+
+    async def plan(self, request: str, model: ModelName) -> List[Task]:
+        """Plan tasks for a user request using the planner LLM."""
+
+        return await make_plan(request, model, self.state)
+
+    async def _run_sub_task(self, task: Task, model: ModelName) -> AgentRun:
+        """Execute a single task using an appropriate sub-agent."""
+        from rich.console import Console
+
+        console = Console()
+
+        # Show which task is being executed
+        task_type = "WRITE" if task.mutate else "READ"
+        console.print(f"\n[dim][Task {task.id}] {task_type}[/dim]")
+        console.print(f"[dim]  → {task.description}[/dim]")
+
+        if task.mutate:
+            agent_main.get_or_create_agent(model, self.state)
+            result = await agent_main.process_request(model, task.description, self.state)
+        else:
+            agent = ReadOnlyAgent(model, self.state)
+            result = await agent.process_request(task.description)
+
+        console.print(f"[dim][Task {task.id}] Complete[/dim]")
+        return result
+
+    async def run(self, request: str, model: ModelName | None = None) -> List[AgentRun]:
+        """Plan and execute a user request.
+
+        Parameters
+        ----------
+        request:
+            The high level user request to process.
+        model:
+            Optional model name to use for sub agents.  Defaults to the current
+            session model.
+        """
+        from rich.console import Console
+
+        console = Console()
+        model = model or self.state.session.current_model
+
+        # Track response state across all sub-tasks
+        response_state = ResponseState()
+
+        # Show orchestrator is starting
+        console.print(
+            "\n[cyan]Orchestrator Mode: Analyzing request and creating execution plan...[/cyan]"
+        )
+
+        tasks = await self.plan(request, model)
+
+        # Show execution is starting
+        console.print(f"\n[cyan]Executing plan with {len(tasks)} tasks...[/cyan]")
+
+        results: List[AgentRun] = []
+        task_progress = []
+
+        for mutate_flag, group in itertools.groupby(tasks, key=lambda t: t.mutate):
+            if mutate_flag:
+                for t in group:
+                    result = await self._run_sub_task(t, model)
+                    results.append(result)
+
+                    # Track task progress
+                    task_progress.append(
+                        {
+                            "task": t,
+                            "completed": True,
+                            "had_output": hasattr(result, "result")
+                            and result.result
+                            and getattr(result.result, "output", None),
+                        }
+                    )
+
+                    # Check if this task produced user-visible output
+                    if hasattr(result, "response_state"):
+                        response_state.has_user_response |= result.response_state.has_user_response
+            else:
+                # Show parallel execution
+                task_list = list(group)
+                if len(task_list) > 1:
+                    console.print(
+                        f"\n[dim][Parallel Execution] Running {len(task_list)} read-only tasks concurrently...[/dim]"
+                    )
+                coros = [self._run_sub_task(t, model) for t in task_list]
+                parallel_results = await asyncio.gather(*coros)
+                results.extend(parallel_results)
+
+                # Track parallel task progress
+                for t, result in zip(task_list, parallel_results):
+                    task_progress.append(
+                        {
+                            "task": t,
+                            "completed": True,
+                            "had_output": hasattr(result, "result")
+                            and result.result
+                            and getattr(result.result, "output", None),
+                        }
+                    )
+
+                    # Check if this task produced user-visible output
+                    if hasattr(result, "response_state"):
+                        response_state.has_user_response |= result.response_state.has_user_response
+
+        console.print("\n[green]Orchestrator completed all tasks successfully![/green]")
+
+        # Check if we need a fallback response
+        has_any_output = any(
+            hasattr(r, "result") and r.result and getattr(r.result, "output", None) for r in results
+        )
+
+        fallback_enabled = self.state.session.user_config.get("settings", {}).get(
+            "fallback_response", True
+        )
+
+        # Use has_any_output as the primary check since response_state might not be set for all agents
+        if not has_any_output and fallback_enabled:
+            # Generate a detailed fallback response
+            completed_count = sum(1 for tp in task_progress if tp["completed"])
+            output_count = sum(1 for tp in task_progress if tp["had_output"])
+
+            fallback = FallbackResponse(
+                summary="Orchestrator completed all tasks but no final response was generated.",
+                progress=f"Executed {completed_count}/{len(tasks)} tasks successfully",
+            )
+
+            # Add task details based on verbosity
+            verbosity = self.state.session.user_config.get("settings", {}).get(
+                "fallback_verbosity", "normal"
+            )
+
+            if verbosity in ["normal", "detailed"]:
+                # List what was done
+                if task_progress:
+                    fallback.issues.append(f"Tasks executed: {completed_count}")
+                    if output_count == 0:
+                        fallback.issues.append("No tasks produced visible output")
+
+                    if verbosity == "detailed":
+                        # Add task descriptions
+                        for i, tp in enumerate(task_progress, 1):
+                            task_type = "WRITE" if tp["task"].mutate else "READ"
+                            status = "✓" if tp["completed"] else "✗"
+                            fallback.issues.append(
+                                f"{status} Task {i} [{task_type}]: {tp['task'].description}"
+                            )
+
+            # Suggest next steps
+            fallback.next_steps.append("Review the task execution above for any errors")
+            fallback.next_steps.append(
+                "Try running individual tasks separately for more detailed output"
+            )
+
+            # Create synthesized response
+            synthesis_parts = [fallback.summary, ""]
+
+            if fallback.progress:
+                synthesis_parts.append(f"Progress: {fallback.progress}")
+
+            if fallback.issues:
+                synthesis_parts.append("\nDetails:")
+                synthesis_parts.extend(f"  • {issue}" for issue in fallback.issues)
+
+            if fallback.next_steps:
+                synthesis_parts.append("\nNext steps:")
+                synthesis_parts.extend(f"  • {step}" for step in fallback.next_steps)
+
+            synthesis = "\n".join(synthesis_parts)
+
+            class FallbackResult:
+                def __init__(self, output: str, response_state: ResponseState):
+                    self.output = output
+                    self.response_state = response_state
+
+            class FallbackRun:
+                def __init__(self, synthesis: str, response_state: ResponseState):
+                    self.result = FallbackResult(synthesis, response_state)
+                    self.response_state = response_state
+
+            response_state.has_final_synthesis = True
+            results.append(FallbackRun(synthesis, response_state))
+
+        return results

{tunacode_cli-0.0.27 → tunacode_cli-0.0.29}/src/tunacode/core/agents/readonly.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from ...tools.grep import grep
 from ...tools.read_file import read_file
-from ...types import AgentRun, ModelName
+from ...types import AgentRun, ModelName, ResponseState
 from ..state import StateManager
 
 if TYPE_CHECKING:
@@ -42,10 +42,24 @@ class ReadOnlyAgent:
     async def process_request(self, request: str) -> AgentRun:
         """Process a request using only read-only tools."""
         agent = self._get_agent()
+        response_state = ResponseState()
 
         # Use iter() like main.py does to get the full run context
         async with agent.iter(request) as agent_run:
-            async for _ in agent_run:
-                pass  # Let it complete
+            async for node in agent_run:
+                # Check if this node produced user-visible output
+                if hasattr(node, "result") and node.result and hasattr(node.result, "output"):
+                    if node.result.output:
+                        response_state.has_user_response = True
 
-        return agent_run
+        # Wrap the agent run to include response_state
+        class AgentRunWithState:
+            def __init__(self, wrapped_run):
+                self._wrapped = wrapped_run
+                self.response_state = response_state
+
+            def __getattr__(self, name):
+                # Delegate all other attributes to the wrapped object
+                return getattr(self._wrapped, name)
+
+        return AgentRunWithState(agent_run)