tunacode-cli 0.0.34__tar.gz → 0.0.35__tar.gz

{tunacode_cli-0.0.34 → tunacode_cli-0.0.35}/CLAUDE.md

@@ -10,251 +10,18 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 # Install development environment (recommended approach)
 ./scripts/setup_dev_env.sh    # Creates fresh venv, installs deps, verifies setup
 
-# You must always follow the flow for working
- Project structure:
-  agent-tools/
-  ├── wakeup.sh          # Read memory bank
-  ├── scratchpad.sh      # Task logging
-  ├── check_workflow.sh  # Simple verification
-  ├── bankctl.sh         # Memory bank control
-  └── WORKFLOW_GUIDE.md  # Complete workflow documentation
-
-  memory-bank/
-  ├── project_brief.md
-  ├── tech_context.md
-  ├── product_context.md
-  ├── current_state_summary.md
-  └── progress_overview.md
-
-🚀 Quick start:
-  1. Edit memory-bank/*.md files with your project details
-  2. ./wakeup.sh                    # Read current context
-  3. ./scratchpad.sh start 'Task'   # Begin new task
-  4. ./scratchpad.sh step 'Action'  # Log progress
-  5. ./scratchpad.sh close 'Done'   # Complete task
-
-📖 Full guide: cat agent-tools/WORKFLOW_GUIDE.md
-<?xml version="1.0" encoding="UTF-8"?>
-<system_prompt>
-
-###Instruction###
-
-You are an expert software engineering assistant equipped with specialized bash tools for memory management and task tracking. Your primary goal is to maintain persistent context across sessions while following a structured workflow.
-
-You MUST use these tools proactively and frequently. You will be penalized for failing to use appropriate tools when they would improve task outcomes.
-
-<role>Expert Software Engineering Assistant with Memory Management Tools</role>
-
-<available_tools>
-1. wakeup.sh - Read memory bank to regain project context
-2. scratchpad.sh - Task logging and progress tracking
-3. check_workflow.sh - Simple verification check
-4. bankctl.sh - Memory bank initialization and management
-</available_tools>
-
-<critical_requirements>
-- Think step by step when approaching any task
-- Always run wakeup.sh at the start of a new session to regain context
-- Use scratchpad.sh for EVERY task to maintain detailed work logs
-- Update memory-bank/current_state_summary.md after completing tasks
-- Occasionally run check_workflow.sh to verify nothing was missed
-- Ensure that your approach is unbiased and does not rely on stereotypes
-</critical_requirements>
-
-###Example###
-
-<example_workflow>
-User: "Help me implement a new user registration feature"
-
-CORRECT APPROACH:
-1. ./wakeup.sh (read memory bank to understand project context)
-2. ./scratchpad.sh start "Implement user registration feature"
-3. ./scratchpad.sh plan "1. Create user model 2. Design API endpoint 3. Add validation 4. Write tests"
-4. ./scratchpad.sh step "Created User model in models.py with email, username, password_hash"
-5. ./scratchpad.sh step "Implemented POST /register endpoint with input validation"
-6. ./scratchpad.sh step "Added password hashing using bcrypt"
-7. ./scratchpad.sh step "Wrote unit tests for registration flow"
-8. ./scratchpad.sh close "User registration feature complete"
-9. Update memory-bank/current_state_summary.md with session outcome
-10. ./check_workflow.sh (verify workflow was followed)
-
-INCORRECT APPROACH:
-- Starting work without reading memory bank
-- Making changes without tracking steps in scratchpad
-- Not updating current_state_summary.md after task completion
-- Never checking if workflow was properly followed
-</example_workflow>
-
-###Guidelines###
-
-<wakeup_usage>
-WHEN TO USE:
-- At the start of EVERY new session
-- When returning to a project after any break
-- To understand project context and current state
-
-OUTPUT:
-- Reads all memory bank files in priority order
-- Shows current_state_summary.md first (most important)
-- Displays project brief, technical context, product context, and progress
-
-You MUST:
-- Always run wakeup.sh before starting any work
-- Pay special attention to current_state_summary.md
-- Use the context to inform your approach
-</wakeup_usage>
-
-<scratchpad_usage>
-WHEN TO USE:
-- For EVERY task, regardless of complexity
-- Even for single-step tasks (maintains history)
-- When exploring, debugging, or implementing features
-
-COMMANDS:
-- start "task_name": Begin new task tracking
-- plan "plan_details": Document your approach
-- step "action_taken": Log each action/decision
-- close "completion_message": Archive the task
-
-You MUST:
-- Start scratchpad for every task
-- Log detailed steps as you work
-- Close and archive when complete
-- Note: close command auto-sanitizes filenames
-</scratchpad_usage>
-
-<check_workflow_usage>
-WHEN TO USE:
-- After completing a few tasks
-- When you want to verify workflow compliance
-- Periodically to ensure nothing was missed
-
-OUTPUT:
-- Shows when memory bank was last updated
-- Lists recent archived scratchpads
-- Displays current state summary
-
-You SHOULD:
-- Run this occasionally (not after every single task)
-- Use it as a sanity check for workflow adherence
-- Pay attention if updates are getting stale
-</check_workflow_usage>
-
-<bankctl_usage>
-WHEN TO USE:
-- First time setup of a project
-- When memory bank structure needs initialization
-- For memory bank maintenance tasks
-
-COMMANDS:
-- init: Initialize memory bank structure
-- Other commands vary by implementation
-
-You MUST:
-- Use bankctl.sh init for new projects
-- Ensure memory bank exists before using other tools
-</bankctl_usage>
-
-<memory_bank_structure>
-CORE FILES:
-1. project_brief.md - What & why of the project
-2. tech_context.md - Technical decisions & architecture
-3. product_context.md - User experience goals
-4. current_state_summary.md - CRITICAL: Latest state & next steps
-5. progress_overview.md - Feature/task tracker
-
-UPDATE STRATEGY:
-- current_state_summary.md: Update after EVERY session
-- progress_overview.md: Update when features complete
-- Other files: Update only when fundamentals change
-
-You MUST:
-- Keep current_state_summary.md concise but complete
-- Include session outcomes and immediate next steps
-- Archive detailed logs in scratchpad, not memory bank
-</memory_bank_structure>
-
-###Workflow_Patterns###
-
-<pattern name="new_session_startup">
-1. ./wakeup.sh
-2. Review current_state_summary.md carefully
-3. Identify immediate next objectives
-4. ./scratchpad.sh start "[next_task_from_summary]"
-5. Continue with task implementation
-</pattern>
-
-<pattern name="feature_implementation">
-1. ./wakeup.sh
-2. ./scratchpad.sh start "Implement [feature_name]"
-3. ./scratchpad.sh plan "Steps: 1. [step1] 2. [step2] 3. [step3]"
-4. ./scratchpad.sh step "Completed [specific action]"
-5. [continue logging each step]
-6. ./scratchpad.sh close "[feature_name] implementation complete"
-7. Update memory-bank/current_state_summary.md
-8. Update memory-bank/progress_overview.md
-9. ./check_workflow.sh (occasionally, to verify)
-</pattern>
-
-<pattern name="debugging_session">
-1. ./wakeup.sh
-2. ./scratchpad.sh start "Debug [issue_description]"
-3. ./scratchpad.sh step "Reproduced issue: [details]"
-4. ./scratchpad.sh step "Identified root cause: [cause]"
-5. ./scratchpad.sh step "Applied fix: [solution]"
-6. ./scratchpad.sh step "Verified fix works"
-7. ./scratchpad.sh close "Fixed [issue_description]"
-8. Update memory-bank/current_state_summary.md
-</pattern>
-
-<pattern name="project_initialization">
-1. ./bankctl.sh init
-2. Edit memory-bank/project_brief.md
-3. Edit memory-bank/tech_context.md
-4. Edit memory-bank/product_context.md
-5. Edit memory-bank/current_state_summary.md
-6. Edit memory-bank/progress_overview.md
-7. ./wakeup.sh (verify setup)
-</pattern>
-
-###Penalties###
-
-You will be penalized for:
-- Not running wakeup.sh at session start
-- Starting any task without scratchpad.sh
-- Failing to update current_state_summary.md after tasks
-- Not archiving completed scratchpads
-- Keeping detailed logs in memory bank instead of scratchpad
-- Never running check_workflow.sh to verify compliance
-
-###Output_Format###
-
-When using tools, always show:
-1. The exact command being executed
-2. Brief explanation of why you're using it
-3. Key findings or results
-
-###Memory_Management_Philosophy###
-
-This workflow is designed for agents that experience complete memory loss between sessions. The system provides:
-
-1. **Memory Bank** - Persistent, summarized knowledge base
-   - Project context and goals
-   - Current state and next steps
-   - High-level progress tracking
-
-2. **Scratchpad** - Detailed, temporary work logs
-   - Step-by-step task documentation
-   - Decisions and observations
-   - Archived after completion
-
-The key is maintaining clear separation between long-term strategic memory (Memory Bank) and short-term operational memory (Scratchpad).
-
-Answer questions in a natural, human-like manner while maintaining technical accuracy.
-
-I'm going to tip $200000 for exceptional workflow adherence that demonstrates mastery of memory management!
-
-</system_prompt>
+# You must always follow the agent tooling workflow specified in agent_tools_prompt.xml
+
+When the directory "llm-agent-tools" exists, you MUST use this tooling flow and will be penalized if you don't:
+
+🚀 Available Tools:
+1. scratchpad-multi.sh - Task tracking with multi-agent support (use --agent <name> for agent-specific work)
+2. knowledge.sh - Knowledge base with private/shared storage (use --agent <name> for agent-specific work) 
+3. codemap.sh - Lightweight code intelligence for instant roadmaps
+4. context.sh - Context gathering for debugging issues
+5. researcher.sh - Online research and multimodal analysis via OpenRouter API
+
+📖 Full workflow guide: see llm-agent-tools/agent_tools_prompt.xml
 
 For new feature YOU MUST folow this flow
 

{tunacode_cli-0.0.34/src/tunacode_cli.egg-info → tunacode_cli-0.0.35}/PKG-INFO

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

{tunacode_cli-0.0.34 → tunacode_cli-0.0.35}/pyproject.toml

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

{tunacode_cli-0.0.34 → tunacode_cli-0.0.35}/src/tunacode/cli/commands.py

@@ -181,26 +181,29 @@ class IterationsCommand(SimpleCommand):
 
     async def execute(self, args: List[str], context: CommandContext) -> None:
         state = context.state_manager.session
-        if args:
-            try:
-                new_limit = int(args[0])
-                if new_limit < 1 or new_limit > 100:
-                    await ui.error("Iterations must be between 1 and 100")
-                    return
-
-                # Update the user config
-                if "settings" not in state.user_config:
-                    state.user_config["settings"] = {}
-                state.user_config["settings"]["max_iterations"] = new_limit
-
-                await ui.success(f"Maximum iterations set to {new_limit}")
-                await ui.muted("Higher values allow more complex reasoning but may be slower")
-            except ValueError:
-                await ui.error("Please provide a valid number")
-        else:
+
+        # Guard clause - handle "no args" case first and return early
+        if not args:
             current = state.user_config.get("settings", {}).get("max_iterations", 40)
             await ui.info(f"Current maximum iterations: {current}")
             await ui.muted("Usage: /iterations <number> (1-100)")
+            return
+
+        # update the logic to not be as nested messely, the above guars needing to get as messy
+        try:
+            new_limit = int(args[0])
+            if new_limit < 1 or new_limit > 100:
+                await ui.error("Iterations must be between 1 and 100")
+                return
+
+            # Update the user config
+            if "settings" not in state.user_config:
+                state.user_config["settings"] = {}
+            state.user_config["settings"]["max_iterations"] = new_limit
+
+            await ui.success(f"Maximum iterations set to {new_limit}")
+        except ValueError:
+            await ui.error("Please provide a valid number")
 
 
 class ClearCommand(SimpleCommand):
@@ -288,7 +291,9 @@ class ParseToolsCommand(SimpleCommand):
 
                         try:
                             await extract_and_execute_tool_calls(
-                                part.content, tool_callback_with_state, context.state_manager
+                                part.content,
+                                tool_callback_with_state,
+                                context.state_manager,
                             )
                             await ui.success("JSON tool parsing completed")
                             found_content = True
@@ -524,7 +529,8 @@ class UpdateCommand(SimpleCommand):
                 result = subprocess.run(
                     ["pipx", "list"], capture_output=True, text=True, timeout=10
                 )
-                if "tunacode" in result.stdout.lower():
+                pipx_installed = "tunacode" in result.stdout.lower()
+                if pipx_installed:
                     installation_method = "pipx"
             except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
                 pass
@@ -555,12 +561,22 @@ class UpdateCommand(SimpleCommand):
             if installation_method == "pipx":
                 await ui.info("Updating via pipx...")
                 result = subprocess.run(
-                    ["pipx", "upgrade", "tunacode"], capture_output=True, text=True, timeout=60
+                    ["pipx", "upgrade", "tunacode"],
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
                 )
             else:  # pip
                 await ui.info("Updating via pip...")
                 result = subprocess.run(
-                    [sys.executable, "-m", "pip", "install", "--upgrade", "tunacode-cli"],
+                    [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "--upgrade",
+                        "tunacode-cli",
+                    ],
                     capture_output=True,
                     text=True,
                     timeout=60,

{tunacode_cli-0.0.34 → tunacode_cli-0.0.35}/src/tunacode/cli/repl.py

@@ -22,6 +22,7 @@ from tunacode.core.tool_handler import ToolHandler
 from tunacode.exceptions import AgentError, UserAbortError, ValidationError
 from tunacode.ui import console as ui
 from tunacode.ui.tool_ui import ToolUI
+from tunacode.utils.security import CommandSecurityError, safe_subprocess_run
 
 from ..types import CommandContext, CommandResult, StateManager, ToolArgs
 from .commands import CommandRegistry
@@ -320,13 +321,24 @@ async def repl(state_manager: StateManager):
                 def run_shell():
                     try:
                         if command:
-                            result = subprocess.run(command, shell=True, capture_output=False)
-                            if result.returncode != 0:
-                                # Use print directly since we're in a terminal context
-                                print(f"\nCommand exited with code {result.returncode}")
+                            # Use secure subprocess execution for shell commands
+                            # Note: User shell commands are inherently risky but this is by design
+                            # We validate but allow shell features since it's explicit user intent
+                            try:
+                                result = safe_subprocess_run(
+                                    command,
+                                    shell=True,
+                                    validate=True,  # Still validate for basic safety
+                                    capture_output=False,
+                                )
+                                if result.returncode != 0:
+                                    print(f"\nCommand exited with code {result.returncode}")
+                            except CommandSecurityError as e:
+                                print(f"\nSecurity validation failed: {str(e)}")
+                                print("If you need to run this command, please ensure it's safe.")
                         else:
                             shell = os.environ.get("SHELL", "bash")
-                            subprocess.run(shell)
+                            subprocess.run(shell)  # Interactive shell is safe
                     except Exception as e:
                         print(f"\nShell command failed: {str(e)}")
 

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

{tunacode_cli-0.0.34 → tunacode_cli-0.0.35}/src/tunacode/tools/run_command.py

@@ -14,6 +14,7 @@ from tunacode.constants import (CMD_OUTPUT_FORMAT, CMD_OUTPUT_NO_ERRORS, CMD_OUT
 from tunacode.exceptions import ToolExecutionError
 from tunacode.tools.base import BaseTool
 from tunacode.types import ToolResult
+from tunacode.utils.security import CommandSecurityError, safe_subprocess_popen
 
 
 class RunCommandTool(BaseTool):
@@ -34,16 +35,23 @@ class RunCommandTool(BaseTool):
 
         Raises:
             FileNotFoundError: If command not found
+            CommandSecurityError: If command fails security validation
             Exception: Any command execution errors
         """
-        process = subprocess.Popen(
-            command,
-            shell=True,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        stdout, stderr = process.communicate()
+        try:
+            # Use secure subprocess execution with validation
+            process = safe_subprocess_popen(
+                command,
+                shell=True,  # CLI tool requires shell features
+                validate=True,  # Enable security validation
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
+        except CommandSecurityError as e:
+            # Security validation failed - return error without execution
+            return f"Security validation failed: {str(e)}"
         output = stdout.strip() or CMD_OUTPUT_NO_OUTPUT
         error = stderr.strip() or CMD_OUTPUT_NO_ERRORS
         resp = CMD_OUTPUT_FORMAT.format(output=output, error=error).strip()
@@ -70,6 +78,8 @@ class RunCommandTool(BaseTool):
         """
         if isinstance(error, FileNotFoundError):
             err_msg = ERROR_COMMAND_EXECUTION.format(command=command, error=error)
+        elif isinstance(error, CommandSecurityError):
+            err_msg = f"Command blocked for security: {str(error)}"
         else:
             # Use parent class handling for other errors
             await super()._handle_error(error, command)

tunacode_cli-0.0.35/src/tunacode/utils/security.py

@@ -0,0 +1,208 @@
+"""
+Security utilities for safe command execution and input validation.
+Provides defensive measures against command injection attacks.
+"""
+
+import logging
+import re
+import shlex
+import subprocess
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+# Dangerous shell metacharacters that indicate potential injection
+DANGEROUS_CHARS = [
+    ";",
+    "&",
+    "|",
+    "`",
+    "$",
+    "(",
+    ")",
+    "{",
+    "}",
+    "<",
+    ">",
+    "\n",
+    "\r",
+    "\\",
+    '"',
+    "'",
+]
+
+# Common injection patterns
+INJECTION_PATTERNS = [
+    r";\s*\w+",  # Command chaining with semicolon
+    r"&&\s*\w+",  # Command chaining with &&
+    r"\|\s*\w+",  # Piping to another command
+    r"`[^`]+`",  # Command substitution with backticks
+    r"\$\([^)]+\)",  # Command substitution with $()
+    r">\s*[/\w]",  # Output redirection
+    r"<\s*[/\w]",  # Input redirection
+]
+
+
+class CommandSecurityError(Exception):
+    """Raised when a command fails security validation."""
+
+    pass
+
+
+def validate_command_safety(command: str, allow_shell_features: bool = False) -> None:
+    """
+    Validate that a command is safe to execute.
+
+    Args:
+        command: The command string to validate
+        allow_shell_features: If True, allows some shell features like pipes
+
+    Raises:
+        CommandSecurityError: If the command contains potentially dangerous patterns
+    """
+    if not command or not command.strip():
+        raise CommandSecurityError("Empty command not allowed")
+
+    # Log the command being validated
+    logger.info(f"Validating command: {command[:100]}...")
+
+    # Always check for the most dangerous patterns regardless of shell features
+    dangerous_patterns = [
+        r"rm\s+-rf\s+/",  # Dangerous rm commands
+        r"sudo\s+rm",  # Sudo rm commands
+        r">\s*/dev/sd[a-z]",  # Writing to disk devices
+        r"dd\s+.*of=/dev/",  # DD to devices
+        r"mkfs\.",  # Format filesystem
+        r"fdisk",  # Partition manipulation
+        r":\(\)\{.*\}\;",  # Fork bomb pattern
+    ]
+
+    for pattern in dangerous_patterns:
+        if re.search(pattern, command, re.IGNORECASE):
+            logger.error(f"Highly dangerous pattern '{pattern}' detected in command")
+            raise CommandSecurityError("Command contains dangerous pattern and is blocked")
+
+    if not allow_shell_features:
+        # Check for dangerous characters (but allow some for CLI tools)
+        restricted_chars = [";", "&", "`", "$", "{", "}"]  # More permissive for CLI
+        for char in restricted_chars:
+            if char in command:
+                logger.warning(f"Potentially dangerous character '{char}' detected in command")
+                raise CommandSecurityError(f"Potentially unsafe character '{char}' in command")
+
+        # Check for injection patterns (more selective)
+        strict_patterns = [
+            r";\s*rm\s+",  # Command chaining to rm
+            r"&&\s*rm\s+",  # Command chaining to rm
+            r"`[^`]*rm[^`]*`",  # Command substitution with rm
+            r"\$\([^)]*rm[^)]*\)",  # Command substitution with rm
+        ]
+
+        for pattern in strict_patterns:
+            if re.search(pattern, command):
+                logger.warning(f"Dangerous injection pattern '{pattern}' detected in command")
+                raise CommandSecurityError("Potentially unsafe pattern detected in command")
+
+
+def sanitize_command_args(args: List[str]) -> List[str]:
+    """
+    Sanitize command arguments by shell-quoting them.
+
+    Args:
+        args: List of command arguments
+
+    Returns:
+        List of sanitized arguments
+    """
+    return [shlex.quote(arg) for arg in args]
+
+
+def safe_subprocess_run(
+    command: str,
+    shell: bool = False,
+    validate: bool = True,
+    timeout: Optional[int] = None,
+    **kwargs,
+) -> subprocess.CompletedProcess:
+    """
+    Safely execute a subprocess with security validation.
+
+    Args:
+        command: Command to execute (string if shell=True, list if shell=False)
+        shell: Whether to use shell execution (discouraged)
+        validate: Whether to validate command safety
+        timeout: Timeout in seconds
+        **kwargs: Additional subprocess arguments
+
+    Returns:
+        CompletedProcess result
+
+    Raises:
+        CommandSecurityError: If command fails security validation
+    """
+    if validate and shell and isinstance(command, str):
+        validate_command_safety(command, allow_shell_features=shell)
+
+    # Log the command execution
+    logger.info(f"Executing command: {str(command)[:100]}...")
+
+    try:
+        if shell:
+            # When using shell=True, command should be a string
+            result = subprocess.run(command, shell=True, timeout=timeout, **kwargs)
+        else:
+            # When shell=False, command should be a list
+            if isinstance(command, str):
+                # Parse the string into a list
+                command_list = shlex.split(command)
+            else:
+                command_list = command
+
+            result = subprocess.run(command_list, shell=False, timeout=timeout, **kwargs)
+
+        logger.info(f"Command completed with return code: {result.returncode}")
+        return result
+
+    except subprocess.TimeoutExpired:
+        logger.error(f"Command timed out after {timeout} seconds")
+        raise
+    except Exception as e:
+        logger.error(f"Command execution failed: {str(e)}")
+        raise
+
+
+def safe_subprocess_popen(
+    command: str, shell: bool = False, validate: bool = True, **kwargs
+) -> subprocess.Popen:
+    """
+    Safely create a subprocess.Popen with security validation.
+
+    Args:
+        command: Command to execute
+        shell: Whether to use shell execution (discouraged)
+        validate: Whether to validate command safety
+        **kwargs: Additional Popen arguments
+
+    Returns:
+        Popen process object
+
+    Raises:
+        CommandSecurityError: If command fails security validation
+    """
+    if validate and shell and isinstance(command, str):
+        validate_command_safety(command, allow_shell_features=shell)
+
+    # Log the command execution
+    logger.info(f"Creating Popen for command: {str(command)[:100]}...")
+
+    if shell:
+        # When using shell=True, command should be a string
+        return subprocess.Popen(command, shell=True, **kwargs)
+    else:
+        # When shell=False, command should be a list
+        if isinstance(command, str):
+            command_list = shlex.split(command)
+        else:
+            command_list = command
+
+        return subprocess.Popen(command_list, shell=False, **kwargs)