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

{tunacode_cli-0.0.34 → tunacode_cli-0.0.36}/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.36}/PKG-INFO

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunacode-cli"
-version = "0.0.34"
+version = "0.0.36"
 description = "Your agentic CLI developer."
 keywords = ["cli", "agent", "development", "automation"]
 readme = "README.md"
@@ -56,3 +56,4 @@ line-length = 100
 
 [tool.isort]
 line_length = 100
+profile = "black"

tunacode_cli-0.0.36/src/tunacode/cli/commands/__init__.py

@@ -0,0 +1,62 @@
+"""Command system for TunaCode CLI.
+
+This package provides a modular command system with:
+- Base classes and infrastructure in `base.py`
+- Command registry and factory in `registry.py`
+- Command implementations organized by category in `implementations/`
+
+The main public API provides backward compatibility with the original
+commands.py module while enabling better organization and maintainability.
+"""
+
+# Import base classes and infrastructure
+from .base import Command, CommandCategory, CommandSpec, SimpleCommand
+
+# Import all command implementations for backward compatibility
+from .implementations import (
+    BranchCommand,
+    ClearCommand,
+    CompactCommand,
+    DumpCommand,
+    FixCommand,
+    HelpCommand,
+    InitCommand,
+    IterationsCommand,
+    ModelCommand,
+    ParseToolsCommand,
+    RefreshConfigCommand,
+    ThoughtsCommand,
+    UpdateCommand,
+    YoloCommand,
+)
+
+# Import registry and factory
+from .registry import CommandDependencies, CommandFactory, CommandRegistry
+
+# Maintain backward compatibility by exposing the same public API
+__all__ = [
+    # Base infrastructure
+    "Command",
+    "SimpleCommand",
+    "CommandSpec",
+    "CommandCategory",
+    # Registry and factory
+    "CommandRegistry",
+    "CommandFactory",
+    "CommandDependencies",
+    # All command classes (imported from implementations)
+    "YoloCommand",
+    "DumpCommand",
+    "ThoughtsCommand",
+    "IterationsCommand",
+    "ClearCommand",
+    "FixCommand",
+    "ParseToolsCommand",
+    "RefreshConfigCommand",
+    "HelpCommand",
+    "BranchCommand",
+    "CompactCommand",
+    "UpdateCommand",
+    "ModelCommand",
+    "InitCommand",
+]

tunacode_cli-0.0.36/src/tunacode/cli/commands/base.py

@@ -0,0 +1,99 @@
+"""Base classes and infrastructure for TunaCode CLI commands."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import List
+
+from ...types import CommandArgs, CommandContext, CommandResult
+
+
+class CommandCategory(Enum):
+    """Categories for organizing commands."""
+
+    SYSTEM = "system"
+    NAVIGATION = "navigation"
+    DEVELOPMENT = "development"
+    MODEL = "model"
+    DEBUG = "debug"
+
+
+class Command(ABC):
+    """Base class for all commands."""
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """The primary name of the command."""
+        pass
+
+    @property
+    @abstractmethod
+    def aliases(self) -> CommandArgs:
+        """Alternative names/aliases for the command."""
+        pass
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        return ""
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return CommandCategory.SYSTEM
+
+    @abstractmethod
+    async def execute(self, args: CommandArgs, context: CommandContext) -> CommandResult:
+        """
+        Execute the command.
+
+        Args:
+            args: Command arguments (excluding the command name)
+            context: Execution context with state and config
+
+        Returns:
+            Command-specific return value
+        """
+        pass
+
+
+@dataclass
+class CommandSpec:
+    """Specification for a command's metadata."""
+
+    name: str
+    aliases: List[str]
+    description: str
+    category: CommandCategory = CommandCategory.SYSTEM
+
+
+class SimpleCommand(Command):
+    """Base class for simple commands without complex logic.
+
+    This class provides a standard implementation for commands that don't
+    require special initialization or complex behavior. It reads all
+    properties from a class-level CommandSpec attribute.
+    """
+
+    spec: CommandSpec
+
+    @property
+    def name(self) -> str:
+        """The primary name of the command."""
+        return self.__class__.spec.name
+
+    @property
+    def aliases(self) -> CommandArgs:
+        """Alternative names/aliases for the command."""
+        return self.__class__.spec.aliases
+
+    @property
+    def description(self) -> str:
+        """Description of what the command does."""
+        return self.__class__.spec.description
+
+    @property
+    def category(self) -> CommandCategory:
+        """Category this command belongs to."""
+        return self.__class__.spec.category

tunacode_cli-0.0.36/src/tunacode/cli/commands/implementations/__init__.py

@@ -0,0 +1,37 @@
+"""Command implementations for TunaCode CLI."""
+
+# Import all command classes for easy access
+from .conversation import CompactCommand
+from .debug import (
+    DumpCommand,
+    FixCommand,
+    IterationsCommand,
+    ParseToolsCommand,
+    ThoughtsCommand,
+    YoloCommand,
+)
+from .development import BranchCommand, InitCommand
+from .model import ModelCommand
+from .system import ClearCommand, HelpCommand, RefreshConfigCommand, UpdateCommand
+
+__all__ = [
+    # System commands
+    "HelpCommand",
+    "ClearCommand",
+    "RefreshConfigCommand",
+    "UpdateCommand",
+    # Debug commands
+    "YoloCommand",
+    "DumpCommand",
+    "ThoughtsCommand",
+    "IterationsCommand",
+    "FixCommand",
+    "ParseToolsCommand",
+    # Development commands
+    "BranchCommand",
+    "InitCommand",
+    # Model commands
+    "ModelCommand",
+    # Conversation commands
+    "CompactCommand",
+]

tunacode_cli-0.0.36/src/tunacode/cli/commands/implementations/conversation.py

@@ -0,0 +1,115 @@
+"""Conversation management commands for TunaCode CLI."""
+
+from typing import List, Optional
+
+from ....types import CommandContext, ProcessRequestCallback
+from ....ui import console as ui
+from ..base import CommandCategory, CommandSpec, SimpleCommand
+
+
+class CompactCommand(SimpleCommand):
+    """Compact conversation context."""
+
+    spec = CommandSpec(
+        name="compact",
+        aliases=["/compact"],
+        description="Summarize and compact the conversation history",
+        category=CommandCategory.SYSTEM,
+    )
+
+    def __init__(self, process_request_callback: Optional[ProcessRequestCallback] = None):
+        self._process_request = process_request_callback
+
+    async def execute(self, args: List[str], context: CommandContext) -> None:
+        # Use the injected callback or get it from context
+        process_request = self._process_request or context.process_request
+
+        if not process_request:
+            await ui.error("Compact command not available - process_request not configured")
+            return
+
+        # 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."
+        )
+        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.")