tunacode-cli 0.0.22__tar.gz → 0.0.23__tar.gz

tunacode_cli-0.0.23/CLAUDE.md

@@ -0,0 +1,120 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+### Development Commands
+```bash
+# Install development environment
+pip install -e ".[dev]"
+
+# Run linting (black, isort, flake8)
+make lint
+
+# Run tests
+make test
+pytest tests/                 # Run all tests
+pytest tests/test_import.py  # Run single test file
+pytest -k "test_name"        # Run specific test
+
+# Run tests with coverage
+make coverage
+
+# Build distribution packages
+make build
+
+# Clean build artifacts
+make clean
+```
+
+### Version Management
+When updating versions, modify both:
+- `pyproject.toml`: version field
+- `src/tunacode/constants.py`: VERSION constant
+
+## Architecture
+
+TunaCode is a CLI tool that provides an AI-powered coding assistant using pydantic-ai. Key architectural decisions:
+
+### Agent System
+- Uses `pydantic-ai` for LLM agent implementation
+- Central agent in `src/tunacode/core/agents/main.py` with retryable tools
+- Supports multiple LLM providers (Anthropic, OpenAI, Google, OpenRouter) through unified interface
+- Model format: `provider:model-name` (e.g., `openai:gpt-4`, `anthropic:claude-3-opus`)
+
+### Tool System
+Four internal tools with confirmation UI:
+1. `read_file` - Read file contents
+2. `write_file` - Create new files (fails if exists)
+3. `update_file` - Update existing files with target/patch pattern
+4. `run_command` - Execute shell commands
+
+Tools extend `BaseTool` or `FileBasedTool` base classes. External tools supported via MCP (Model Context Protocol).
+
+### State Management
+- `StateManager` (core/state.py) maintains all session state
+- Includes user config, agent instances, message history, costs, permissions
+- Single source of truth passed throughout the application
+
+### Command System
+- Command registry pattern in `cli/commands.py`
+- Commands implement `BaseCommand` with `matches()` and `execute()` methods
+- Registered via `@CommandRegistry.register` decorator
+- Process flow: REPL → CommandRegistry → Command → Action
+
+### Setup Coordinator
+Modular setup with validation steps:
+1. Environment detection
+2. Model validation
+3. Configuration setup
+4. Git safety checks
+Each step implements `BaseSetupStep` interface.
+
+### UI Components
+- REPL uses `prompt_toolkit` for multiline input with syntax highlighting
+- Output formatting via `rich` library
+- Tool confirmations show diffs for file operations
+- Spinner during agent processing
+
+## Configuration
+
+### User Configuration
+Location: `~/.config/tunacode.json`
+```json
+{
+    "default_model": "provider:model-name",
+    "env": {
+        "ANTHROPIC_API_KEY": "...",
+        "OPENAI_API_KEY": "..."
+    }
+}
+```
+
+### Project Guide
+Location: `TUNACODE.md` in project root
+- Project-specific context for the AI assistant
+- Loaded automatically when present
+- Can include codebase conventions, architecture notes
+
+## Key Design Patterns
+
+### Error Handling
+- Custom exceptions in `exceptions.py`
+- `ModelRetry` from pydantic-ai for retryable errors
+- Graceful degradation for missing features
+
+### Permissions
+- File operation permissions tracked per session
+- "Yolo mode" to skip confirmations: `/yolo`
+- Permissions stored in StateManager
+
+### Async Architecture
+- All agent operations are async
+- Tool executions use async/await
+- REPL handles async with prompt_toolkit integration
+
+### Safety Notes
+- No automatic git commits (removed for safety)
+- File operations require explicit confirmation
+- Encourages git branches for experiments: `/branch <name>`

tunacode_cli-0.0.23/MANIFEST.in

@@ -0,0 +1,19 @@
+# Include all prompt files
+include src/tunacode/prompts/*.txt
+include src/tunacode/prompts/*.md
+
+# Include other important files
+include README.md
+include LICENSE
+include pyproject.toml
+include CLAUDE.md
+include TUNACODE.md
+
+# Include test files (optional, but good for development)
+recursive-include tests *.py
+
+# Exclude compiled files
+global-exclude *.pyc
+global-exclude __pycache__
+global-exclude *.so
+global-exclude *.egg-info

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.22
+Version: 0.0.23
 Summary: Your agentic CLI developer.
 Author-email: larock22 <noreply@github.com>
 License-Expression: MIT

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/pyproject.toml

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

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/setup.py

@@ -5,6 +5,6 @@ setup(
     packages=find_namespace_packages(where="src"),
     include_package_data=True,
     package_data={
-        "tunacode": ["prompts/*.txt"],
+        "tunacode": ["prompts/*.txt", "prompts/*.md"],
     },
 )

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/cli/commands.py

@@ -192,7 +192,7 @@ class ArchitectCommand(SimpleCommand):
                 await ui.error("Usage: /architect [on|off]")
                 return
         else:
-            state.architect_mode = not getattr(state, 'architect_mode', False)
+            state.architect_mode = not getattr(state, "architect_mode", False)
         status = "ON" if state.architect_mode else "OFF"
         if state.architect_mode:
             await ui.success(f"Architect mode {status} - Requests will be planned before execution")

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/cli/main.py

@@ -51,6 +51,7 @@ def main(
             await repl(state_manager)
         except Exception as e:
             from tunacode.exceptions import ConfigurationError
+
             if isinstance(e, ConfigurationError):
                 # ConfigurationError already printed helpful message, just exit cleanly
                 update_task.cancel()  # Cancel the update check

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/cli/repl.py

@@ -172,7 +172,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             return _tool_handler(part, node, state_manager)
 
         # Check if architect mode is enabled
-        if getattr(state_manager.session, 'architect_mode', False):
+        if getattr(state_manager.session, "architect_mode", False):
             # Expand @file references before sending to the orchestrator
             try:
                 from tunacode.utils.text_utils import expand_file_refs
@@ -184,14 +184,18 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             # Use orchestrator for planning and execution
             orchestrator = OrchestratorAgent(state_manager)
             results = await orchestrator.run(text, state_manager.session.current_model)
-            
+
             if output:
                 # Process results from all sub-agents
                 for res in results:
                     # Check if result exists and has output
-                    if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                    if (
+                        hasattr(res, "result")
+                        and res.result is not None
+                        and hasattr(res.result, "output")
+                    ):
                         await ui.agent(res.result.output)
-                
+
                 if not results:
                     # Fallback: show that the request was processed
                     await ui.muted("Request completed")
@@ -204,7 +208,7 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
             except ValueError as e:
                 await ui.error(str(e))
                 return
-            
+
             # Use normal agent processing
             res = await agent.process_request(
                 state_manager.session.current_model,
@@ -219,7 +223,11 @@ async def process_request(text: str, state_manager: StateManager, output: bool =
                         if isinstance(msg, dict) and "thought" in msg:
                             await ui.muted(f"THOUGHT: {msg['thought']}")
                 # Check if result exists and has output
-                if hasattr(res, "result") and res.result is not None and hasattr(res.result, "output"):
+                if (
+                    hasattr(res, "result")
+                    and res.result is not None
+                    and hasattr(res.result, "output")
+                ):
                     await ui.agent(res.result.output)
                 else:
                     # Fallback: show that the request was processed

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/cli/textual_app.py

@@ -11,18 +11,13 @@ Provides a rich, interactive terminal user interface with:
 import asyncio
 from typing import Optional
 
-from rich.markdown import Markdown
-from textual import on, work
+from textual import on
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Container, Horizontal, Vertical, VerticalScroll
 from textual.message import Message
-from textual.reactive import reactive
-from textual.widgets import Button, Footer, Header, Input, Label
-from textual.widgets import Markdown as MarkdownWidget
-from textual.widgets import Static, TabbedContent, TabPane, TextArea
+from textual.widgets import Button, Footer, Header, Static, TextArea
 
-from tunacode.configuration.settings import ApplicationSettings
 from tunacode.core.state import StateManager
 from tunacode.setup import setup
 from tunacode.utils.system import check_for_updates
@@ -130,78 +125,78 @@ class TunaCodeApp(App):
         border: thick $primary;
         padding: 1;
     }
-    
+
     .sidebar-title {
         text-align: center;
         color: $primary;
         margin-bottom: 1;
     }
-    
+
     .section-title {
         color: $accent;
         margin: 1 0;
     }
-    
+
     .command-item {
         color: $text-muted;
         margin-left: 1;
     }
-    
+
     .status-ready {
         color: $success;
     }
-    
+
     .status-busy {
         color: $warning;
     }
-    
+
     .status-error {
         color: $error;
     }
-    
+
     ChatHistory {
         border: thick $primary;
         padding: 1;
         height: 1fr;
     }
-    
+
     .user-message {
         background: $surface;
         border-left: thick $primary;
         padding: 1;
         margin: 1 0;
     }
-    
+
     .agent-message {
         background: $surface;
         border-left: thick $success;
         padding: 1;
         margin: 1 0;
     }
-    
+
     .system-message {
         background: $surface;
         border-left: thick $warning;
         padding: 1;
         margin: 1 0;
     }
-    
+
     .tool-message {
         background: $surface;
         border-left: thick $accent;
         padding: 1;
         margin: 1 0;
     }
-    
+
     InputArea {
         height: 5;
         padding: 1;
     }
-    
+
     #message-input {
         height: 3;
     }
-    
+
     #send-button {
         width: 10;
         margin-left: 1;
@@ -250,7 +245,8 @@ class TunaCodeApp(App):
         )
         self.chat_history.add_message(
             "System",
-            "⚠️ IMPORTANT: Always use git branches before making major changes\nType '/help' for available commands",
+            "⚠️ IMPORTANT: Always use git branches before making major changes\n"
+            "Type '/help' for available commands",
             "system",
         )
 
@@ -280,7 +276,7 @@ class TunaCodeApp(App):
         """Handle slash commands."""
         if command == "/help":
             help_text = """Available Commands:
-            
+
 /help - Show this help message
 /clear - Clear chat history
 /model - Show current model info
@@ -371,8 +367,6 @@ def main():
 
     # Initialize state manager
     state_manager = StateManager()
-    app_settings = ApplicationSettings()
-
     # Show banner
     print("🐟 TunaCode - Modern AI Development Assistant")
     print("=" * 50)

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/cli/textual_bridge.py

@@ -5,9 +5,8 @@ This module adapts the existing REPL and agent processing logic to work
 with the new Textual-based interface while maintaining compatibility.
 """
 
-import asyncio
 from asyncio.exceptions import CancelledError
-from typing import Callable, Optional
+from typing import Callable
 
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 
@@ -129,7 +128,7 @@ class TextualAgentBridge:
             # Check if confirmation is needed
             if tool_handler.should_confirm(part.tool_name):
                 # Create confirmation request
-                request = tool_handler.create_confirmation_request(part.tool_name, args)
+                tool_handler.create_confirmation_request(part.tool_name, args)
 
                 # For now, show a simple confirmation in the UI
                 # In a full implementation, this would show a proper modal dialog

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

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/context.py

@@ -1,5 +1,3 @@
-import json
-import os
 import subprocess
 from pathlib import Path
 from typing import Dict, List

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/core/agents/main.py

@@ -7,11 +7,22 @@ Handles agent creation, configuration, and request processing.
 import json
 import re
 from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
-# Lazy import for Agent and Tool
+from tunacode.core.state import StateManager
+from tunacode.services.mcp import get_mcp_servers
+from tunacode.tools.bash import bash
+from tunacode.tools.grep import grep
+from tunacode.tools.read_file import read_file
+from tunacode.tools.run_command import run_command
+from tunacode.tools.update_file import update_file
+from tunacode.tools.write_file import write_file
+from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
+                            ToolCallId, ToolName)
 
 
+# Lazy import for Agent and Tool
 def get_agent_tool():
     import importlib
 
@@ -26,18 +37,6 @@ def get_model_messages():
     return messages.ModelRequest, messages.ToolReturnPart
 
 
-from tunacode.core.state import StateManager
-from tunacode.services.mcp import get_mcp_servers
-from tunacode.tools.bash import bash
-from tunacode.tools.grep import grep
-from tunacode.tools.read_file import read_file
-from tunacode.tools.run_command import run_command
-from tunacode.tools.update_file import update_file
-from tunacode.tools.write_file import write_file
-from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
-                            ToolCallId, ToolName)
-
-
 async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
@@ -125,21 +124,25 @@ async def _process_node(node, tool_callback: Optional[ToolCallback], state_manag
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     if model not in state_manager.session.agents:
-        max_retries = state_manager.session.user_config["settings"]["max_retries"]
+        max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
 
         # Lazy import Agent and Tool
         Agent, Tool = get_agent_tool()
 
         # Load system prompt
-        import os
-        from pathlib import Path
-
         prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.md"
         try:
             with open(prompt_path, "r", encoding="utf-8") as f:
                 system_prompt = f.read().strip()
         except FileNotFoundError:
-            system_prompt = None
+            # Fallback to system.txt if system.md not found
+            prompt_path = Path(__file__).parent.parent.parent / "prompts" / "system.txt"
+            try:
+                with open(prompt_path, "r", encoding="utf-8") as f:
+                    system_prompt = f.read().strip()
+            except FileNotFoundError:
+                # Use a default system prompt if neither file exists
+                system_prompt = "You are a helpful AI assistant for software development tasks."
 
         state_manager.session.agents[model] = Agent(
             model=model,

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/core/llm/planner.py

@@ -1,4 +1,3 @@
-import json
 from typing import List
 
 from ...types import ModelName

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/core/setup/config_setup.py

@@ -99,11 +99,15 @@ class ConfigSetup(BaseSetup):
                     "  [green]tunacode --model 'anthropic:claude-3-opus' --key 'your-key'[/green]"
                 )
                 console.print(
-                    "  [green]tunacode --model 'openrouter:anthropic/claude-3.5-sonnet' --key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]"
+                    "  [green]tunacode --model 'openrouter:anthropic/claude-3.5-sonnet' "
+                    "--key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]"
                 )
                 console.print("\n[yellow]Run 'tunacode --help' for more options[/yellow]\n")
                 from tunacode.exceptions import ConfigurationError
-                raise ConfigurationError("No configuration found. Please use CLI flags to configure.")
+
+                raise ConfigurationError(
+                    "No configuration found. Please use CLI flags to configure."
+                )
 
         if not self.state_manager.session.user_config.get("default_model"):
             raise ConfigurationError(

tunacode_cli-0.0.23/src/tunacode/prompts/system.md

@@ -0,0 +1,92 @@
+\###Instruction###
+
+You are **"TunaCode"**, a **senior software developer AI assistant operating inside the user's terminal (CLI)**.
+
+**YOU ARE NOT A CHATBOT. YOU ARE AN OPERATIONAL AGENT WITH TOOLS.**
+
+Your task is to **execute real actions** via tools and **report observations** after every tool use.
+
+You MUST follow these rules:
+
+---
+
+\###Tool Access Rules###
+
+You HAVE the following tools available. USE THEM IMMEDIATELY and CONSTANTLY:
+
+* `run_command(command: str)` — Execute any shell command
+* `read_file(filepath: str)` — Read any file
+* `write_file(filepath: str, content: str)` — Create or write any file
+* `update_file(filepath: str, target: str, patch: str)` — Update existing files
+
+---
+
+\###Mandatory Operating Principles###
+
+1. **TOOLS FIRST, ALWAYS**: Start every response with tool usage—**no assumptions**.
+2. **USE REAL PATHS**: Files live in `/cli/`, `/core/`, `/tools/`, `/services/`, `/configuration/`, `/utils/`, or `/ui/`.
+3. **CHAIN TOOLS**: First explore (`run_command`), then read (`read_file`), then modify (`update_file`, `write_file`).
+4. **ACT IMMEDIATELY**: Don’t describe what to do—**just do it**.
+5. **NO GUESSING**: Verify file existence with `run_command("ls path/")` before reading or writing.
+6. **ASSUME NOTHING**: Always fetch and verify before responding.
+
+---
+
+\###Prompt Design Style###
+
+* Be **blunt and direct**. Avoid soft language (e.g., “please,” “let me,” “I think”).
+* **Use role-specific language**: you are a CLI-level senior engineer, not a tutor or assistant.
+* Write using affirmative imperatives: *Do this. Check that. Show me.*
+* Ask for clarification if needed: “Specify the path.” / “Which class do you mean?”
+* Break complex requests into sequenced tool actions.
+
+---
+
+\###Example Prompts (Correct vs Incorrect)###
+
+**User**: What's in the tools directory?
+✅ `run_command("ls -la tools/")`
+❌ "The tools directory likely includes..."
+
+**User**: Fix the import in `core/agents/main.py`
+✅ `read_file("core/agents/main.py")`, then `update_file("core/agents/main.py", "from old_module", "from new_module")`
+❌ "To fix the import, modify the code to..."
+
+**User**: What commands are available?
+✅ `run_command("grep -E 'class.*Command' cli/commands.py")`
+❌ "Available commands usually include..."
+
+---
+
+\###Meta Behavior###
+
+Use the **ReAct** (Reasoning + Action) framework:
+
+* {"thought": "I need to inspect the file before modifying."}
+* → run tool
+* {"thought": "I see the old import. Now I'll patch it."}
+* → update file
+* {"thought": "Patch complete. Ready for next instruction."}
+
+---
+
+\###Reminder###
+
+You were created by **tunahorse21**.
+You are not a chatbot.
+You are an autonomous code execution agent.
+You will be penalized for failing to use tools.
+---
+
+\###Example###
+
+```plaintext
+User: What’s the current app version?
+
+THINK: {"thought": "I should search for APP_VERSION in the constants file."}
+ACT: run_command("grep -n 'APP_VERSION' constants.py")
+OBSERVE: {"thought": "Found APP_VERSION at line 12."}
+ACT: read_file("constants.py")
+OBSERVE: {"thought": "APP_VERSION is set to '2.4.1'. This is the current version."}
+RESPONSE: "Current version is 2.4.1 (from constants.py)"
+```

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/tools/__init__.py

@@ -7,4 +7,4 @@ def __getattr__(name):
     try:
         return importlib.import_module(f".{name}", __name__)
     except ImportError as e:
-        raise AttributeError(f"module {{__name__}} has no attribute '{{name}}'") from e
+        raise AttributeError(f"module {__name__} has no attribute '{name}'") from e

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/tools/grep.py

@@ -16,7 +16,7 @@ import subprocess
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Union
+from typing import List, Optional
 
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import BaseTool
@@ -239,7 +239,7 @@ class ParallelGrep(BaseTool):
             results = await self._ripgrep_search(pattern, directory, config)
             if results:
                 return results
-        except:
+        except Exception:
             pass
 
         # Fallback to Python implementation

{tunacode_cli-0.0.22 → tunacode_cli-0.0.23}/src/tunacode/types.py

@@ -107,9 +107,13 @@ class UILogger(Protocol):
     """Protocol for UI logging operations."""
 
     async def info(self, message: str) -> None: ...
+
     async def error(self, message: str) -> None: ...
+
     async def warning(self, message: str) -> None: ...
+
     async def debug(self, message: str) -> None: ...
+
     async def success(self, message: str) -> None: ...