code-puppy 0.0.153__py3-none-any.whl → 0.0.155__py3-none-any.whl

code_puppy/token_utils.py

@@ -1,67 +0,0 @@
-import json
-
-import pydantic
-from pydantic_ai.messages import ModelMessage
-
-
-def estimate_token_count(text: str) -> int:
-    """
-    Simple token estimation using len(message) - 4.
-    This replaces tiktoken with a much simpler approach.
-    """
-    return max(1, len(text) - 4)
-
-
-def stringify_message_part(part) -> str:
-    """
-    Convert a message part to a string representation for token estimation or other uses.
-
-    Args:
-        part: A message part that may contain content or be a tool call
-
-    Returns:
-        String representation of the message part
-    """
-    result = ""
-    if hasattr(part, "part_kind"):
-        result += part.part_kind + ": "
-    else:
-        result += str(type(part)) + ": "
-
-    # Handle content
-    if hasattr(part, "content") and part.content:
-        # Handle different content types
-        if isinstance(part.content, str):
-            result = part.content
-        elif isinstance(part.content, pydantic.BaseModel):
-            result = json.dumps(part.content.model_dump())
-        elif isinstance(part.content, dict):
-            result = json.dumps(part.content)
-        else:
-            result = str(part.content)
-
-    # Handle tool calls which may have additional token costs
-    # If part also has content, we'll process tool calls separately
-    if hasattr(part, "tool_name") and part.tool_name:
-        # Estimate tokens for tool name and parameters
-        tool_text = part.tool_name
-        if hasattr(part, "args"):
-            tool_text += f" {str(part.args)}"
-        result += tool_text
-
-    return result
-
-
-def estimate_tokens_for_message(message: ModelMessage) -> int:
-    """
-    Estimate the number of tokens in a message using len(message) - 4.
-    Simple and fast replacement for tiktoken.
-    """
-    total_tokens = 0
-
-    for part in message.parts:
-        part_str = stringify_message_part(part)
-        if part_str:
-            total_tokens += estimate_token_count(part_str)
-
-    return max(1, total_tokens)

code_puppy/tools/token_check.py

@@ -1,32 +0,0 @@
-try:
-    from code_puppy.token_utils import estimate_tokens_for_message
-    from code_puppy.tools.common import get_model_context_length
-except ImportError:
-    # Fallback if these modules aren't available in the internal version
-    def get_model_context_length():
-        return 128000  # Default context length
-
-    def estimate_tokens_for_message(msg):
-        # Simple fallback estimation
-        return len(str(msg)) // 4  # Rough estimate: 4 chars per token
-
-
-def token_guard(num_tokens: int):
-    try:
-        from code_puppy import state_management
-
-        current_history = state_management.get_message_history()
-        message_hist_tokens = sum(
-            estimate_tokens_for_message(msg) for msg in current_history
-        )
-
-        if message_hist_tokens + num_tokens > (get_model_context_length() * 0.9):
-            raise ValueError(
-                "Tokens produced by this tool call would exceed model capacity"
-            )
-    except ImportError:
-        # Fallback: simple check against a reasonable limit
-        if num_tokens > 10000:
-            raise ValueError(
-                f"Token count {num_tokens} exceeds safety limit of 10,000 tokens"
-            )

code_puppy/tui/tests/__init__.py

@@ -1 +0,0 @@
-# Test package for tui

code_puppy/tui/tests/test_agent_command.py

@@ -1,79 +0,0 @@
-"""Tests for the /agent command handling in TUI mode."""
-
-from unittest.mock import MagicMock, patch
-
-from code_puppy.tui.app import CodePuppyTUI
-
-
-class TestTUIAgentCommand:
-    """Test the TUI's handling of /agent commands."""
-
-    @patch("code_puppy.tui.app.get_runtime_agent_manager")
-    @patch("code_puppy.tui.app.handle_command")
-    def test_tui_handles_agent_command(self, mock_handle_command, mock_get_manager):
-        """Test that TUI properly delegates /agent commands to command handler."""
-        # Create a TUI app instance
-        app = CodePuppyTUI()
-
-        # Mock the agent manager and agent
-        mock_agent_instance = MagicMock()
-        mock_manager = MagicMock()
-        mock_manager.get_agent.return_value = mock_agent_instance
-        mock_get_manager.return_value = mock_manager
-
-        # Mock handle_command to simulate successful processing
-        mock_handle_command.return_value = True
-
-        # Simulate processing an /agent command
-        message = "/agent code-puppy"
-        app.agent = mock_agent_instance
-
-        # Call the method that processes messages
-        # We'll need to mock some UI elements to avoid complex setup
-        with (
-            patch.object(app, "add_user_message"),
-            patch.object(app, "_update_submit_cancel_button"),
-            patch.object(app, "start_agent_progress"),
-            patch.object(app, "stop_agent_progress"),
-            patch.object(app, "refresh_history_display"),
-        ):
-            import asyncio
-
-            # Create an event loop for the async test
-            loop = asyncio.get_event_loop()
-            loop.run_until_complete(app.process_message(message))
-
-        # Verify that handle_command was called with the correct argument
-        mock_handle_command.assert_called_once_with(message)
-
-        # Verify that agent manager's get_agent was called to refresh the agent instance
-        mock_manager.get_agent.assert_called()
-
-    @patch("code_puppy.tui.app.get_runtime_agent_manager")
-    def test_tui_refreshes_agent_after_command(self, mock_get_manager):
-        """Test that TUI refreshes its agent instance after processing /agent command."""
-        # Create a TUI app instance
-        app = CodePuppyTUI()
-
-        # Mock the agent manager
-        mock_manager = MagicMock()
-        initial_agent = MagicMock()
-        new_agent = MagicMock()
-
-        # Set initial agent
-        app.agent = initial_agent
-        app.agent_manager = mock_manager
-
-        # Mock manager to return a new agent instance
-        mock_manager.get_agent.return_value = new_agent
-        mock_get_manager.return_value = mock_manager
-
-        # Simulate that an /agent command was processed
-        with patch("code_puppy.tui.app.handle_command"):
-            import asyncio
-
-            loop = asyncio.get_event_loop()
-            loop.run_until_complete(app.process_message("/agent code-puppy"))
-
-        # Verify that the agent was refreshed through the manager
-        mock_manager.get_agent.assert_called()

code_puppy/tui/tests/test_chat_message.py

@@ -1,28 +0,0 @@
-import unittest
-from datetime import datetime
-
-from code_puppy.tui.models.chat_message import ChatMessage
-from code_puppy.tui.models.enums import MessageType
-
-
-class TestChatMessage(unittest.TestCase):
-    def test_chat_message_defaults(self):
-        msg = ChatMessage(
-            id="1", type=MessageType.USER, content="hi", timestamp=datetime.now()
-        )
-        self.assertEqual(msg.metadata, {})
-
-    def test_chat_message_with_metadata(self):
-        meta = {"foo": "bar"}
-        msg = ChatMessage(
-            id="2",
-            type=MessageType.AGENT,
-            content="hello",
-            timestamp=datetime.now(),
-            metadata=meta,
-        )
-        self.assertEqual(msg.metadata, meta)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_chat_view.py

@@ -1,88 +0,0 @@
-import unittest
-from datetime import datetime
-from unittest.mock import patch
-
-from code_puppy.tui.components.chat_view import ChatView
-from code_puppy.tui.models.chat_message import ChatMessage
-from code_puppy.tui.models.enums import MessageType
-
-
-class TestChatView(unittest.TestCase):
-    def setUp(self):
-        self.chat_view = ChatView()
-
-    @patch.object(ChatView, "mount")
-    def test_add_message_user(self, mock_mount):
-        msg = ChatMessage(
-            id="test-user-1",
-            type=MessageType.USER,
-            content="Hello",
-            timestamp=datetime.now(),
-        )
-        self.chat_view.add_message(msg)
-        self.assertIn(msg, self.chat_view.messages)
-        mock_mount.assert_called_once()
-
-    @patch.object(ChatView, "mount")
-    def test_add_message_agent(self, mock_mount):
-        msg = ChatMessage(
-            id="test-agent-1",
-            type=MessageType.AGENT,
-            content="Hi there!",
-            timestamp=datetime.now(),
-        )
-        self.chat_view.add_message(msg)
-        self.assertIn(msg, self.chat_view.messages)
-        mock_mount.assert_called_once()
-
-    @patch.object(ChatView, "mount")
-    def test_add_message_system(self, mock_mount):
-        msg = ChatMessage(
-            id="test-system-1",
-            type=MessageType.SYSTEM,
-            content="System message",
-            timestamp=datetime.now(),
-        )
-        self.chat_view.add_message(msg)
-        self.assertIn(msg, self.chat_view.messages)
-        mock_mount.assert_called_once()
-
-    @patch.object(ChatView, "mount")
-    def test_add_message_error(self, mock_mount):
-        msg = ChatMessage(
-            id="test-error-1",
-            type=MessageType.ERROR,
-            content="Error occurred",
-            timestamp=datetime.now(),
-        )
-        self.chat_view.add_message(msg)
-        self.assertIn(msg, self.chat_view.messages)
-        mock_mount.assert_called_once()
-
-    @patch.object(ChatView, "mount")
-    @patch.object(ChatView, "query")
-    def test_clear_messages(self, mock_query, mock_mount):
-        # Mock the query method to return empty iterables
-        mock_query.return_value = []
-
-        msg = ChatMessage(
-            id="test-clear-1",
-            type=MessageType.USER,
-            content="Hello",
-            timestamp=datetime.now(),
-        )
-        self.chat_view.add_message(msg)
-        self.chat_view.clear_messages()
-        self.assertEqual(len(self.chat_view.messages), 0)
-        # Verify that query was called to find widgets to remove
-        self.assertTrue(mock_query.called)
-
-    def test_render_agent_message_with_syntax(self):
-        prefix = "Agent: "
-        content = "Some text\n```python\nprint('hi')\n```"
-        group = self.chat_view._render_agent_message_with_syntax(prefix, content)
-        self.assertIsNotNone(group)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_command_history.py

@@ -1,89 +0,0 @@
-import re
-import unittest
-from unittest.mock import MagicMock, patch
-
-from code_puppy.config import COMMAND_HISTORY_FILE
-from code_puppy.tui.app import CodePuppyTUI
-from code_puppy.tui.components.custom_widgets import CustomTextArea
-
-
-class TestCommandHistory(unittest.TestCase):
-    def setUp(self):
-        self.app = CodePuppyTUI()
-
-    @patch("builtins.open", new_callable=unittest.mock.mock_open)
-    def test_action_send_message_saves_to_history(self, mock_open):
-        # Setup test mocks
-        self.app.query_one = MagicMock()
-        input_field_mock = MagicMock(spec=CustomTextArea)
-        input_field_mock.text = "test command"
-        self.app.query_one.return_value = input_field_mock
-
-        # Mock other methods to prevent full execution
-        self.app.add_user_message = MagicMock()
-        self.app._update_submit_cancel_button = MagicMock()
-        self.app.run_worker = MagicMock()
-
-        # Execute
-        self.app.action_send_message()
-
-        # Assertions
-        mock_open.assert_called_once_with(COMMAND_HISTORY_FILE, "a")
-        # Check that write was called with timestamped format
-        write_calls = mock_open().write.call_args_list
-        self.assertEqual(len(write_calls), 1)
-        written_content = write_calls[0][0][0]
-        # Should match pattern: \n# YYYY-MM-DDTHH:MM:SS\ntest command\n
-        self.assertTrue(
-            re.match(
-                r"^\n# \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\ntest command\n$",
-                written_content,
-            )
-        )
-        self.app.add_user_message.assert_called_once_with("test command")
-
-    @patch("builtins.open", new_callable=unittest.mock.mock_open)
-    def test_action_send_message_empty_command(self, mock_open):
-        # Setup test mocks
-        self.app.query_one = MagicMock()
-        input_field_mock = MagicMock(spec=CustomTextArea)
-        input_field_mock.text = "   "  # Empty or whitespace-only command
-        self.app.query_one.return_value = input_field_mock
-
-        # Mock other methods
-        self.app.add_user_message = MagicMock()
-
-        # Execute
-        self.app.action_send_message()
-
-        # Assertions - nothing should happen with empty commands
-        mock_open.assert_not_called()
-        self.app.add_user_message.assert_not_called()
-
-    @patch("builtins.open")
-    def test_action_send_message_handles_error(self, mock_open):
-        # Setup test mocks
-        self.app.query_one = MagicMock()
-        input_field_mock = MagicMock(spec=CustomTextArea)
-        input_field_mock.text = "test command"
-        self.app.query_one.return_value = input_field_mock
-
-        # Mock other methods to prevent full execution
-        self.app.add_user_message = MagicMock()
-        self.app._update_submit_cancel_button = MagicMock()
-        self.app.run_worker = MagicMock()
-        self.app.add_error_message = MagicMock()
-
-        # Make open throw an exception
-        mock_open.side_effect = Exception("File error")
-
-        # Execute
-        self.app.action_send_message()
-
-        # Assertions - error is printed to stdout, not added to UI
-        # Message should still be processed despite error saving to history
-        self.app.add_user_message.assert_called_once_with("test command")
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_copy_button.py

@@ -1,191 +0,0 @@
-"""
-Tests for the copy button component.
-"""
-
-from unittest.mock import MagicMock, patch
-
-from code_puppy.tui.components.copy_button import CopyButton
-
-
-class TestCopyButton:
-    """Test cases for the CopyButton widget."""
-
-    def test_copy_button_creation(self):
-        """Test that a copy button can be created with text."""
-        test_text = "Hello, World!"
-        button = CopyButton(test_text)
-
-        assert button.text_to_copy == test_text
-        assert button.label == "📋 Copy"
-
-    def test_update_text_to_copy(self):
-        """Test updating the text to copy."""
-        button = CopyButton("Initial text")
-        new_text = "Updated text"
-
-        button.update_text_to_copy(new_text)
-
-        assert button.text_to_copy == new_text
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_macos_success(self, mock_run):
-        """Test successful clipboard copy on macOS."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "darwin"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["pbcopy"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_windows_success(self, mock_run):
-        """Test successful clipboard copy on Windows."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "win32"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["clip"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_linux_success(self, mock_run):
-        """Test successful clipboard copy on Linux with xclip."""
-        mock_run.return_value = MagicMock(returncode=0)
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            mock_run.assert_called_once_with(
-                ["xclip", "-selection", "clipboard"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_linux_xsel_fallback(self, mock_run):
-        """Test Linux clipboard copy falls back to xsel when xclip fails."""
-        # First call (xclip) fails, second call (xsel) succeeds
-        mock_run.side_effect = [
-            FileNotFoundError("xclip not found"),
-            MagicMock(returncode=0),
-        ]
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is True
-            assert error is None
-            assert mock_run.call_count == 2
-            # Check that xsel was called as fallback
-            mock_run.assert_any_call(
-                ["xsel", "--clipboard", "--input"],
-                input="test content",
-                text=True,
-                check=True,
-                capture_output=True,
-            )
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_failure(self, mock_run):
-        """Test clipboard copy failure handling."""
-        from subprocess import CalledProcessError
-
-        mock_run.side_effect = CalledProcessError(1, "pbcopy", "Command failed")
-
-        with patch("sys.platform", "darwin"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is False
-            assert "Clipboard command failed" in error
-
-    @patch("subprocess.run")
-    def test_copy_to_clipboard_no_utility(self, mock_run):
-        """Test clipboard copy when utility is not found."""
-        mock_run.side_effect = FileNotFoundError("Command not found")
-
-        with patch("sys.platform", "linux"):
-            button = CopyButton("test content")
-            success, error = button.copy_to_clipboard("test content")
-
-            assert success is False
-            assert "Clipboard utilities not found" in error
-
-    def test_copy_button_labels(self):
-        """Test that copy button has correct labels."""
-        button = CopyButton("test")
-
-        assert button._original_label == "📋 Copy"
-        assert button._copied_label == "✅ Copied!"
-
-    def test_copy_completed_message(self):
-        """Test CopyCompleted message creation."""
-        # Test success message
-        success_msg = CopyButton.CopyCompleted(True)
-        assert success_msg.success is True
-        assert success_msg.error is None
-
-        # Test error message
-        error_msg = CopyButton.CopyCompleted(False, "Test error")
-        assert error_msg.success is False
-        assert error_msg.error == "Test error"
-
-    @patch.object(CopyButton, "copy_to_clipboard")
-    @patch.object(CopyButton, "post_message")
-    def test_action_press_success(self, mock_post_message, mock_copy):
-        """Test action_press method with successful copy."""
-        mock_copy.return_value = (True, None)
-
-        button = CopyButton("test content")
-        button.action_press()
-
-        mock_copy.assert_called_once_with("test content")
-        mock_post_message.assert_called_once()
-        # Note: timer is currently commented out in implementation
-
-        # Check that the message posted is a CopyCompleted with success=True
-        call_args = mock_post_message.call_args[0][0]
-        assert isinstance(call_args, CopyButton.CopyCompleted)
-        assert call_args.success is True
-
-    @patch.object(CopyButton, "copy_to_clipboard")
-    @patch.object(CopyButton, "post_message")
-    def test_action_press_failure(self, mock_post_message, mock_copy):
-        """Test action_press method with failed copy."""
-        mock_copy.return_value = (False, "Test error")
-
-        button = CopyButton("test content")
-        button.action_press()
-
-        mock_copy.assert_called_once_with("test content")
-        mock_post_message.assert_called_once()
-
-        # Check that the message posted is a CopyCompleted with success=False
-        call_args = mock_post_message.call_args[0][0]
-        assert isinstance(call_args, CopyButton.CopyCompleted)
-        assert call_args.success is False
-        assert call_args.error == "Test error"

code_puppy/tui/tests/test_custom_widgets.py

@@ -1,27 +0,0 @@
-import unittest
-
-from code_puppy.tui.components.custom_widgets import CustomTextArea
-
-
-class DummyEvent:
-    def __init__(self, key):
-        self.key = key
-
-
-class TestCustomTextArea(unittest.TestCase):
-    def setUp(self):
-        self.text_area = CustomTextArea()
-
-    def test_message_sent_on_enter(self):
-        # Simulate pressing Enter
-        event = DummyEvent("enter")
-        # Should not raise
-        self.text_area._on_key(event)
-
-    def test_message_sent_class(self):
-        msg = CustomTextArea.MessageSent()
-        self.assertIsInstance(msg, CustomTextArea.MessageSent)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_disclaimer.py

@@ -1,27 +0,0 @@
-import unittest
-from unittest.mock import MagicMock
-
-# Skip importing the non-existent module
-# Commenting out: from code_puppy.tui.screens.disclaimer import DisclaimerScreen
-
-
-# We'll use unittest.skip to skip the entire test class
-@unittest.skip("DisclaimerScreen has been removed from the codebase")
-class TestDisclaimerScreen(unittest.TestCase):
-    def setUp(self):
-        # Create a mock screen instead of the real one
-        self.screen = MagicMock()
-        self.screen.get_disclaimer_content.return_value = "Prompt responsibly"
-        self.screen.compose.return_value = [MagicMock()]
-
-    def test_get_disclaimer_content(self):
-        content = self.screen.get_disclaimer_content()
-        self.assertIn("Prompt responsibly", content)
-
-    def test_compose(self):
-        widgets = list(self.screen.compose())
-        self.assertGreaterEqual(len(widgets), 1)
-
-
-if __name__ == "__main__":
-    unittest.main()

code_puppy/tui/tests/test_enums.py

@@ -1,15 +0,0 @@
-import unittest
-
-from code_puppy.tui.models.enums import MessageType
-
-
-class TestMessageType(unittest.TestCase):
-    def test_enum_values(self):
-        self.assertEqual(MessageType.USER.value, "user")
-        self.assertEqual(MessageType.AGENT.value, "agent")
-        self.assertEqual(MessageType.SYSTEM.value, "system")
-        self.assertEqual(MessageType.ERROR.value, "error")
-
-
-if __name__ == "__main__":
-    unittest.main()