tunacode-cli 0.0.49__tar.gz → 0.0.50__tar.gz

{tunacode_cli-0.0.49/src/tunacode_cli.egg-info → tunacode_cli-0.0.50}/PKG-INFO

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

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50}/pyproject.toml

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

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50}/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.49"
+APP_VERSION = "0.0.50"
 
 
 # File patterns

tunacode_cli-0.0.50/src/tunacode/core/logging/config.py

@@ -0,0 +1,57 @@
+import logging
+import logging.config
+import os
+
+import yaml
+
+from tunacode.utils import user_configuration
+
+DEFAULT_CONFIG_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
+)
+
+
+class LogConfig:
+    @staticmethod
+    def load(config_path=None):
+        """
+        Load logging configuration based on user preferences.
+        If logging is disabled (default), use minimal configuration.
+        """
+        # First check if user has enabled logging
+        user_config = user_configuration.load_config()
+        logging_enabled = False
+        custom_logging_config = None
+
+        if user_config:
+            logging_enabled = user_config.get("logging_enabled", False)
+            custom_logging_config = user_config.get("logging", None)
+
+        if not logging_enabled:
+            # Configure minimal logging - only critical errors to console
+            logging.basicConfig(level=logging.CRITICAL, handlers=[logging.NullHandler()])
+            # Ensure no file handlers are created
+            logging.getLogger().handlers = [logging.NullHandler()]
+            return
+
+        # Logging is enabled, load configuration
+        if custom_logging_config:
+            # Use user's custom logging configuration
+            try:
+                logging.config.dictConfig(custom_logging_config)
+            except Exception as e:
+                print(f"Failed to configure custom logging: {e}")
+                logging.basicConfig(level=logging.INFO)
+        else:
+            # Use default configuration from YAML file
+            path = config_path or DEFAULT_CONFIG_PATH
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"Logging config file not found: {path}")
+            with open(path, "r") as f:
+                config = yaml.safe_load(f)
+            logging_config = config.get("logging", config)
+            try:
+                logging.config.dictConfig(logging_config)
+            except Exception as e:
+                print(f"Failed to configure logging: {e}")
+                logging.basicConfig(level=logging.INFO)

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50}/src/tunacode/types.py

@@ -49,6 +49,10 @@ SessionId = str
 DeviceId = str
 InputSessions = Dict[str, Any]
 
+# Logging configuration types
+LoggingConfig = Dict[str, Any]
+LoggingEnabled = bool
+
 # =============================================================================
 # Configuration Types
 # =============================================================================

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50/src/tunacode_cli.egg-info}/PKG-INFO

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

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50}/src/tunacode_cli.egg-info/SOURCES.txt

@@ -115,6 +115,7 @@ src/tunacode_cli.egg-info/top_level.txt
 tests/conftest.py
 tests/test_agent_output_formatting.py
 tests/test_json_retry.py
+tests/test_logging_config.py
 tests/test_prompt_changes_validation.py
 tests/test_security.py
 tests/test_tool_batching_retry.py

tunacode_cli-0.0.50/tests/characterization/context/test_tunacode_logging.py

@@ -0,0 +1,84 @@
+"""Test TUNACODE.md logging when thoughts are enabled."""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_tunacode_loading_message_displayed():
+    """Test that TUNACODE.md loading message is logged when found."""
+    # Create a temporary directory with TUNACODE.md
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tunacode_path = Path(tmpdir) / "TUNACODE.md"
+        tunacode_content = """# TUNACODE.md
+
+This file provides guidance to AI assistants.
+
+## Build Commands
+- Run tests: `make test`
+- Run single test: `pytest tests/test_file.py::test_name`
+- Lint: `make lint`
+
+## Code Style
+- Use type hints for all functions
+- Follow PEP 8 conventions
+- Prefer guard clauses over nested conditionals
+"""
+        tunacode_path.write_text(tunacode_content)
+
+        # Change to temp directory
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(tmpdir)
+
+            # Mock the logger to capture calls
+            with patch("tunacode.core.agents.main.logger") as mock_logger:
+                from tunacode.core.agents.main import get_or_create_agent
+                from tunacode.core.state import StateManager
+
+                # Create state manager with thoughts enabled
+                state_manager = StateManager()
+                state_manager.session.show_thoughts = True
+
+                # Create agent (this should log the message)
+                get_or_create_agent("openai:gpt-4", state_manager)
+
+                # Check that the logger was called with the expected message
+                mock_logger.info.assert_called_with("📄 TUNACODE.md located: Loading context...")
+
+        finally:
+            os.chdir(original_cwd)
+
+
+@pytest.mark.asyncio
+async def test_tunacode_not_found_message():
+    """Test that TUNACODE.md not found message is logged when file doesn't exist."""
+    # Create a temporary directory WITHOUT TUNACODE.md
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Change to temp directory
+        original_cwd = os.getcwd()
+        try:
+            os.chdir(tmpdir)
+
+            # Mock the logger to capture calls
+            with patch("tunacode.core.agents.main.logger") as mock_logger:
+                from tunacode.core.agents.main import get_or_create_agent
+                from tunacode.core.state import StateManager
+
+                # Create state manager
+                state_manager = StateManager()
+
+                # Create agent (should log not found message)
+                get_or_create_agent("openai:gpt-4", state_manager)
+
+                # Check that the logger was called with the expected message
+                mock_logger.info.assert_called_with(
+                    "📄 TUNACODE.md not found: Using default context"
+                )
+
+        finally:
+            os.chdir(original_cwd)

{tunacode_cli-0.0.49 → tunacode_cli-0.0.50}/tests/characterization/ui/test_async_ui.py

@@ -3,7 +3,7 @@ Characterization tests for TunaCode UI async UI updates.
 Covers: async output functions and async-safe UI flows.
 """
 
-from unittest.mock import patch
+from unittest.mock import AsyncMock, patch
 
 import pytest
 
@@ -24,7 +24,9 @@ async def test_async_print_calls_console_print():
 
 
 @pytest.mark.asyncio
-async def test_async_info_formats_and_prints(caplog):
-    # info() now goes through ui_logger, let's test that
-    await output_mod.info("Test info")
-    assert "Test info" in caplog.text
+async def test_async_info_formats_and_prints():
+    # info() now goes through ui_logger, let's test that it's called
+    with patch("tunacode.ui.output.ui_logger") as mock_logger:
+        mock_logger.info = AsyncMock()
+        await output_mod.info("Test info")
+        mock_logger.info.assert_called_once_with("Test info")

tunacode_cli-0.0.50/tests/test_logging_config.py

@@ -0,0 +1,112 @@
+"""Test logging configuration with user preferences."""
+
+import logging
+from unittest.mock import patch
+
+import pytest
+
+from tunacode.core.logging.config import LogConfig
+
+
+class TestLoggingConfiguration:
+    """Test cases for logging configuration based on user preferences."""
+
+    def test_logging_disabled_by_default(self, tmp_path):
+        """Test that logging is disabled when no config exists."""
+        with patch("tunacode.utils.user_configuration.load_config", return_value=None):
+            LogConfig.load()
+
+            # Check that root logger has only NullHandler
+            root_logger = logging.getLogger()
+            assert len(root_logger.handlers) == 1
+            assert isinstance(root_logger.handlers[0], logging.NullHandler)
+
+    def test_logging_explicitly_disabled(self, tmp_path):
+        """Test that logging stays disabled when explicitly set to false."""
+        config = {"default_model": "test:model", "logging_enabled": False}
+
+        with patch("tunacode.utils.user_configuration.load_config", return_value=config):
+            LogConfig.load()
+
+            # Check that root logger has only NullHandler
+            root_logger = logging.getLogger()
+            assert len(root_logger.handlers) == 1
+            assert isinstance(root_logger.handlers[0], logging.NullHandler)
+
+    def test_logging_enabled_with_defaults(self, tmp_path):
+        """Test that default logging config is used when enabled without custom config."""
+        config = {"default_model": "test:model", "logging_enabled": True}
+
+        with patch("tunacode.utils.user_configuration.load_config", return_value=config):
+            # This will load from the default YAML file
+            try:
+                LogConfig.load()
+                # If YAML exists, it should configure handlers
+                root_logger = logging.getLogger()
+                # Should have more than just NullHandler
+                assert not all(isinstance(h, logging.NullHandler) for h in root_logger.handlers)
+            except FileNotFoundError:
+                # If YAML doesn't exist in test environment, that's expected
+                pass
+
+    def test_logging_enabled_with_custom_config(self, tmp_path):
+        """Test that custom logging configuration is applied correctly."""
+        # Create a test log file path
+        log_file = tmp_path / "test.log"
+
+        config = {
+            "default_model": "test:model",
+            "logging_enabled": True,
+            "logging": {
+                "version": 1,
+                "disable_existing_loggers": False,
+                "formatters": {"simple": {"format": "[TEST] %(message)s"}},
+                "handlers": {
+                    "test_file": {
+                        "class": "logging.FileHandler",
+                        "level": "DEBUG",
+                        "formatter": "simple",
+                        "filename": str(log_file),
+                    }
+                },
+                "root": {"level": "DEBUG", "handlers": ["test_file"]},
+            },
+        }
+
+        with patch("tunacode.utils.user_configuration.load_config", return_value=config):
+            # Clear existing handlers first
+            logging.getLogger().handlers = []
+
+            LogConfig.load()
+
+            # Test that logging works with custom config
+            test_logger = logging.getLogger("test")
+            test_logger.debug("Test message")
+
+            # Check that log file was created and contains our message
+            assert log_file.exists()
+            content = log_file.read_text()
+            assert "[TEST] Test message" in content
+
+    def test_invalid_custom_config_fallback(self, tmp_path):
+        """Test that invalid custom config falls back to basic config."""
+        config = {
+            "default_model": "test:model",
+            "logging_enabled": True,
+            "logging": {"invalid": "config"},
+        }
+
+        # Clear any existing handlers
+        logging.getLogger().handlers = []
+
+        with patch("tunacode.utils.user_configuration.load_config", return_value=config):
+            # Should not raise exception
+            LogConfig.load()
+
+            # Should have some configuration (not NullHandler)
+            root_logger = logging.getLogger()
+            assert len(root_logger.handlers) > 0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tunacode_cli-0.0.49/src/tunacode/core/logging/config.py

@@ -1,28 +0,0 @@
-import logging
-import logging.config
-import os
-
-import yaml
-
-DEFAULT_CONFIG_PATH = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "config", "logging.yaml"
-)
-
-
-class LogConfig:
-    @staticmethod
-    def load(config_path=None):
-        """
-        Load logging configuration from YAML file and apply it.
-        """
-        path = config_path or DEFAULT_CONFIG_PATH
-        if not os.path.exists(path):
-            raise FileNotFoundError(f"Logging config file not found: {path}")
-        with open(path, "r") as f:
-            config = yaml.safe_load(f)
-        logging_config = config.get("logging", config)
-        try:
-            logging.config.dictConfig(logging_config)
-        except Exception as e:
-            print(f"Failed to configure logging: {e}")
-            logging.basicConfig(level=logging.INFO)

tunacode_cli-0.0.49/tests/characterization/context/test_tunacode_logging.py

@@ -1,74 +0,0 @@
-"""Test TUNACODE.md logging when thoughts are enabled."""
-
-import os
-import tempfile
-from pathlib import Path
-
-import pytest
-
-from tunacode.core.agents.main import get_or_create_agent
-from tunacode.core.state import StateManager
-
-
-@pytest.mark.asyncio
-async def test_tunacode_loading_message_displayed(caplog):
-    """Test that TUNACODE.md loading message is displayed when found."""
-    # Create a temporary directory with TUNACODE.md
-    with tempfile.TemporaryDirectory() as tmpdir:
-        tunacode_path = Path(tmpdir) / "TUNACODE.md"
-        tunacode_content = """# TUNACODE.md
-
-This file provides guidance to AI assistants.
-
-## Build Commands
-- Run tests: `make test`
-- Run single test: `pytest tests/test_file.py::test_name`
-- Lint: `make lint`
-
-## Code Style
-- Use type hints for all functions
-- Follow PEP 8 conventions
-- Prefer guard clauses over nested conditionals
-"""
-        tunacode_path.write_text(tunacode_content)
-
-        # Change to temp directory
-        original_cwd = os.getcwd()
-        try:
-            os.chdir(tmpdir)
-
-            # Create state manager with thoughts enabled
-            state_manager = StateManager()
-            state_manager.session.show_thoughts = True
-
-            # Create agent (this should log the message)
-            get_or_create_agent("openai:gpt-4", state_manager)
-
-            # Check the log messages
-            assert "📄 TUNACODE.md located: Loading context..." in caplog.text
-
-        finally:
-            os.chdir(original_cwd)
-
-
-@pytest.mark.asyncio
-async def test_tunacode_not_found_message(caplog):
-    """Test that TUNACODE.md not found message is displayed when file doesn't exist."""
-    # Create a temporary directory WITHOUT TUNACODE.md
-    with tempfile.TemporaryDirectory() as tmpdir:
-        # Change to temp directory
-        original_cwd = os.getcwd()
-        try:
-            os.chdir(tmpdir)
-
-            # Create state manager
-            state_manager = StateManager()
-
-            # Create agent (should log not found message)
-            get_or_create_agent("openai:gpt-4", state_manager)
-
-            # Check the log messages
-            assert "📄 TUNACODE.md not found: Using default context" in caplog.text
-
-        finally:
-            os.chdir(original_cwd)