tunacode-cli 0.0.75__py3-none-any.whl → 0.0.76.1__py3-none-any.whl

tunacode/ui/panels.py

@@ -92,7 +92,7 @@ class StreamingAgentPanel:
     _dots_count: int
     _show_dots: bool
 
-    def __init__(self, bottom: int = 1):
+    def __init__(self, bottom: int = 1, debug: bool = False):
         self.bottom = bottom
         self.title = f"[bold {colors.primary}]●[/bold {colors.primary}] {APP_NAME}"
         self.content = ""
@@ -101,6 +101,24 @@ class StreamingAgentPanel:
         self._dots_task = None
         self._dots_count = 0
         self._show_dots = True  # Start with dots enabled for "Thinking..."
+        # Debug/diagnostic instrumentation (printed after stop to avoid Live interference)
+        self._debug_enabled = debug
+        self._debug_events: list[str] = []
+        self._update_count: int = 0
+        self._first_update_done: bool = False
+        self._dots_tick_count: int = 0
+        self._max_logged_dots: int = 10
+
+    def _log_debug(self, label: str, **data: Any) -> None:
+        if not self._debug_enabled:
+            return
+        try:
+            ts = time.perf_counter_ns()
+        except Exception:
+            ts = 0
+        payload = ", ".join(f"{k}={repr(v)}" for k, v in data.items()) if data else ""
+        line = f"[ui] {label} ts_ns={ts}{(' ' + payload) if payload else ''}"
+        self._debug_events.append(line)
 
     def _create_panel(self) -> Padding:
         """Create a Rich panel with current content."""
@@ -159,6 +177,14 @@ class StreamingAgentPanel:
             if current_time - self._last_update_time > delay_threshold:
                 self._show_dots = True
                 self._dots_count += 1
+                # Log only a few initial ticks to avoid noise
+                if (
+                    self._debug_enabled
+                    and not self.content
+                    and self._dots_tick_count < self._max_logged_dots
+                ):
+                    self._dots_tick_count += 1
+                    self._log_debug("dots_tick", n=self._dots_count)
                 if self.live:
                     self.live.update(self._create_panel())
             else:
@@ -173,6 +199,7 @@ class StreamingAgentPanel:
 
         self.live = Live(self._create_panel(), console=console, refresh_per_second=4)
         self.live.start()
+        self._log_debug("start")
         # For "Thinking...", set time in past to trigger dots immediately
         if not self.content:
             self._last_update_time = time.time() - 0.4  # Triggers dots on first cycle
@@ -188,45 +215,83 @@ class StreamingAgentPanel:
             content_chunk = ""
 
         # Filter out plan mode system prompts and tool definitions from streaming
-        if any(
-            phrase in str(content_chunk)
+        # Use more precise filtering to avoid false positives
+        content_str = str(content_chunk).strip()
+        if content_str and any(
+            content_str.startswith(phrase) or phrase in content_str
             for phrase in [
                 "🔧 PLAN MODE",
                 "TOOL EXECUTION ONLY",
                 "planning assistant that ONLY communicates",
                 "namespace functions {",
                 "namespace multi_tool_use {",
-                "You are trained on data up to",
             ]
         ):
             return
 
+        # Special handling for the training data phrase - only filter if it's a complete system message
+        if "You are trained on data up to" in content_str and len(content_str) > 50:
+            # Only filter if this looks like a complete system message, not user content
+            if (
+                content_str.startswith("You are trained on data up to")
+                or "The current date is" in content_str
+            ):
+                return
+
         # Ensure type safety for concatenation
-        self.content = (self.content or "") + str(content_chunk)
+        incoming = str(content_chunk)
+        # First-chunk diagnostics
+        is_first_chunk = (not self.content) and bool(incoming)
+        if is_first_chunk:
+            self._log_debug(
+                "first_chunk_received",
+                chunk_repr=incoming[:5],
+                chunk_len=len(incoming),
+            )
+        self.content = (self.content or "") + incoming
 
         # Reset the update timer when we get new content
         self._last_update_time = time.time()
-        self._show_dots = False  # Hide dots immediately when new content arrives
+        # Hide dots immediately when new content arrives
+        if self._show_dots:
+            self._log_debug("disable_dots_called")
+        self._show_dots = False
 
         if self.live:
+            # Log timing around the first two live.update() calls
+            self._update_count += 1
+            if self._update_count <= 2:
+                self._log_debug("live_update.start", update_index=self._update_count)
             self.live.update(self._create_panel())
+            if self._update_count <= 2:
+                self._log_debug("live_update.end", update_index=self._update_count)
 
     async def set_content(self, content: str):
         """Set the complete content (overwrites previous)."""
         # Filter out plan mode system prompts and tool definitions
-        if any(
-            phrase in str(content)
+        # Use more precise filtering to avoid false positives
+        content_str = str(content).strip()
+        if content_str and any(
+            content_str.startswith(phrase) or phrase in content_str
             for phrase in [
                 "🔧 PLAN MODE",
                 "TOOL EXECUTION ONLY",
                 "planning assistant that ONLY communicates",
                 "namespace functions {",
                 "namespace multi_tool_use {",
-                "You are trained on data up to",
             ]
         ):
             return
 
+        # Special handling for the training data phrase - only filter if it's a complete system message
+        if "You are trained on data up to" in content_str and len(content_str) > 50:
+            # Only filter if this looks like a complete system message, not user content
+            if (
+                content_str.startswith("You are trained on data up to")
+                or "The current date is" in content_str
+            ):
+                return
+
         self.content = content
         if self.live:
             self.live.update(self._create_panel())
@@ -240,6 +305,8 @@ class StreamingAgentPanel:
                 await self._dots_task
             except asyncio.CancelledError:
                 pass
+            finally:
+                self._log_debug("dots_task_cancelled")
 
         if self.live:
             # Get the console before stopping the live display
@@ -263,6 +330,22 @@ class StreamingAgentPanel:
 
             self.live = None
 
+        # Emit debug diagnostics after Live has been stopped (to avoid interference)
+        if self._debug_enabled:
+            from .output import print as ui_print
+
+            # Summarize UI buffer state
+            ui_prefix = "[debug]"
+            ui_buffer_first5 = repr((self.content or "")[:5])
+            lines = [
+                f"{ui_prefix} ui_buffer_first5={ui_buffer_first5} total_len={len(self.content or '')}",
+            ]
+            # Include recorded event lines
+            lines.extend(self._debug_events)
+            # Flush lines to console
+            for line in lines:
+                await ui_print(line)
+
 
 async def agent_streaming(content_stream, bottom: int = 1):
     """Display an agent panel with streaming content updates.

tunacode/utils/config_comparator.py

@@ -0,0 +1,340 @@
+"""
+Module: tunacode.utils.config_comparator
+
+Configuration comparison utility for analyzing user configurations against defaults.
+Provides detailed analysis of customizations, defaults, and configuration state.
+"""
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Union
+
+from tunacode.configuration.defaults import DEFAULT_USER_CONFIG
+from tunacode.types import UserConfig
+
+
+@dataclass
+class ConfigDifference:
+    """Represents a difference between user config and defaults."""
+
+    key_path: str
+    user_value: Any
+    default_value: Any
+    difference_type: str  # "custom", "missing", "extra", "type_mismatch"
+    section: str
+    description: str
+
+
+@dataclass
+class ConfigAnalysis:
+    """Complete analysis of configuration state."""
+
+    user_config: UserConfig
+    default_config: UserConfig
+    differences: List[ConfigDifference]
+    custom_keys: Set[str]
+    missing_keys: Set[str]
+    extra_keys: Set[str]
+    type_mismatches: Set[str]
+    sections_analyzed: Set[str]
+    total_keys: int
+    custom_percentage: float
+
+
+class ConfigComparator:
+    """Compares user configuration against defaults to identify customizations."""
+
+    def __init__(self, default_config: Optional[UserConfig] = None):
+        """Initialize comparator with default configuration."""
+        self.default_config = default_config or DEFAULT_USER_CONFIG
+
+    def _get_key_description(self, key_path: str, difference_type: str) -> str:
+        """Get a descriptive explanation for a configuration key difference."""
+        try:
+            from tunacode.configuration.key_descriptions import get_key_description
+
+            desc = get_key_description(key_path)
+
+            if desc:
+                if difference_type == "custom":
+                    return f"Custom: {desc.description}"
+                elif difference_type == "missing":
+                    return f"Missing: {desc.description}"
+                elif difference_type == "extra":
+                    return f"Extra: {desc.description}"
+                elif difference_type == "type_mismatch":
+                    return f"Type mismatch: {desc.description}"
+
+        except ImportError:
+            pass  # Fall back to basic descriptions
+
+        # Fallback descriptions
+        if difference_type == "custom":
+            return f"Custom value: {key_path}"
+        elif difference_type == "missing":
+            return f"Missing configuration key: {key_path}"
+        elif difference_type == "extra":
+            return f"Extra configuration key: {key_path}"
+        elif difference_type == "type_mismatch":
+            return f"Type mismatch for: {key_path}"
+
+        return f"Configuration difference: {key_path}"
+
+    def analyze_config(self, user_config: UserConfig) -> ConfigAnalysis:
+        """Perform complete analysis of user configuration."""
+        differences: list[ConfigDifference] = []
+        custom_keys: set[str] = set()
+        missing_keys: set[str] = set()
+        extra_keys: set[str] = set()
+        type_mismatches: set[str] = set()
+
+        # Analyze each section recursively
+        self._analyze_recursive(
+            user_config=user_config,
+            default_config=self.default_config,
+            current_path="",
+            differences=differences,
+            custom_keys=custom_keys,
+            missing_keys=missing_keys,
+            extra_keys=extra_keys,
+            type_mismatches=type_mismatches,
+        )
+
+        # Calculate statistics
+        sections_analyzed: set[str] = set()
+        self._collect_sections(user_config, sections_analyzed)
+        self._collect_sections(self.default_config, sections_analyzed)
+
+        total_keys = len(custom_keys) + len(missing_keys) + len(extra_keys) + len(type_mismatches)
+        custom_percentage = (len(custom_keys) / total_keys * 100) if total_keys > 0 else 0
+
+        return ConfigAnalysis(
+            user_config=user_config,
+            default_config=self.default_config,
+            differences=differences,
+            custom_keys=custom_keys,
+            missing_keys=missing_keys,
+            extra_keys=extra_keys,
+            type_mismatches=type_mismatches,
+            sections_analyzed=sections_analyzed,
+            total_keys=total_keys,
+            custom_percentage=custom_percentage,
+        )
+
+    def _analyze_recursive(
+        self,
+        user_config: Dict[str, Any],
+        default_config: Dict[str, Any],
+        current_path: str,
+        differences: List[ConfigDifference],
+        custom_keys: Set[str],
+        missing_keys: Set[str],
+        extra_keys: Set[str],
+        type_mismatches: Set[str],
+    ) -> None:
+        """Recursively analyze configuration differences."""
+
+        # Check for missing keys (present in default but not in user)
+        for key, default_value in default_config.items():
+            full_key = f"{current_path}.{key}" if current_path else key
+
+            if key not in user_config:
+                missing_keys.add(full_key)
+                differences.append(
+                    ConfigDifference(
+                        key_path=full_key,
+                        user_value=None,
+                        default_value=default_value,
+                        difference_type="missing",
+                        section=current_path or "root",
+                        description=self._get_key_description(full_key, "missing"),
+                    )
+                )
+                continue
+
+            user_value = user_config[key]
+
+            # Recursively analyze nested dictionaries
+            if isinstance(default_value, dict) and isinstance(user_value, dict):
+                self._analyze_recursive(
+                    user_config=user_value,
+                    default_config=default_value,
+                    current_path=full_key,
+                    differences=differences,
+                    custom_keys=custom_keys,
+                    missing_keys=missing_keys,
+                    extra_keys=extra_keys,
+                    type_mismatches=type_mismatches,
+                )
+                continue
+
+            # Check for type mismatches
+            if not isinstance(user_value, type(default_value)):
+                type_mismatches.add(full_key)
+                differences.append(
+                    ConfigDifference(
+                        key_path=full_key,
+                        user_value=user_value,
+                        default_value=default_value,
+                        difference_type="type_mismatch",
+                        section=current_path or "root",
+                        description=self._get_key_description(full_key, "type_mismatch"),
+                    )
+                )
+                continue
+
+            # Check for custom values
+            if user_value != default_value:
+                custom_keys.add(full_key)
+                differences.append(
+                    ConfigDifference(
+                        key_path=full_key,
+                        user_value=user_value,
+                        default_value=default_value,
+                        difference_type="custom",
+                        section=current_path or "root",
+                        description=self._get_key_description(full_key, "custom"),
+                    )
+                )
+
+        # Check for extra keys (present in user but not in default)
+        for key, user_value in user_config.items():
+            if key not in default_config:
+                full_key = f"{current_path}.{key}" if current_path else key
+                extra_keys.add(full_key)
+                differences.append(
+                    ConfigDifference(
+                        key_path=full_key,
+                        user_value=user_value,
+                        default_value=None,
+                        difference_type="extra",
+                        section=current_path or "root",
+                        description=self._get_key_description(full_key, "extra"),
+                    )
+                )
+
+    def _collect_sections(self, config: Dict[str, Any], sections: Set[str]) -> None:
+        """Collect all section names from configuration."""
+        for key, value in config.items():
+            if isinstance(value, dict):
+                sections.add(key)
+                self._collect_sections(value, sections)
+
+    def get_summary_stats(self, analysis: ConfigAnalysis) -> Dict[str, Any]:
+        """Get summary statistics for the configuration analysis."""
+        return {
+            "total_keys_analyzed": analysis.total_keys,
+            "custom_keys_count": len(analysis.custom_keys),
+            "missing_keys_count": len(analysis.missing_keys),
+            "extra_keys_count": len(analysis.extra_keys),
+            "type_mismatches_count": len(analysis.type_mismatches),
+            "custom_percentage": analysis.custom_percentage,
+            "sections_analyzed": len(analysis.sections_analyzed),
+            "has_issues": bool(analysis.missing_keys or analysis.type_mismatches),
+        }
+
+    def get_section_analysis(
+        self, analysis: ConfigAnalysis, section: str
+    ) -> List[ConfigDifference]:
+        """Get differences for a specific section."""
+        return [diff for diff in analysis.differences if diff.section == section]
+
+    def is_config_healthy(self, analysis: ConfigAnalysis) -> bool:
+        """Check if configuration is healthy (no critical issues)."""
+        # Type mismatches are considered critical
+        if analysis.type_mismatches:
+            return False
+
+        # Missing keys might be acceptable depending on the context
+        # For now, we'll consider missing keys as warnings, not errors
+        return True
+
+    def get_recommendations(self, analysis: ConfigAnalysis) -> List[str]:
+        """Get recommendations based on configuration analysis."""
+        recommendations = []
+
+        if analysis.type_mismatches:
+            recommendations.append(
+                f"Fix {len(analysis.type_mismatches)} type mismatch(es) in configuration"
+            )
+
+        if analysis.missing_keys:
+            recommendations.append(
+                f"Consider adding {len(analysis.missing_keys)} missing configuration key(s)"
+            )
+
+        if analysis.custom_percentage > 80:
+            recommendations.append(
+                "High customization detected - consider documenting your configuration"
+            )
+
+        if analysis.extra_keys:
+            recommendations.append(
+                f"Found {len(analysis.extra_keys)} unrecognized configuration key(s)"
+            )
+
+        return recommendations
+
+
+def load_and_analyze_config(config_path: Optional[Union[str, Path]] = None) -> ConfigAnalysis:
+    """Load configuration from file and analyze it."""
+    from tunacode.utils.user_configuration import load_config
+
+    if config_path:
+        try:
+            with open(config_path, "r") as f:
+                user_config = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            raise ValueError(f"Failed to load config from {config_path}: {e}")
+    else:
+        user_config = load_config()
+        if user_config is None:
+            raise ValueError("No user configuration found")
+
+    comparator = ConfigComparator()
+    return comparator.analyze_config(user_config)
+
+
+def create_config_report(analysis: ConfigAnalysis) -> str:
+    """Create a human-readable report of configuration analysis."""
+    stats = ConfigComparator().get_summary_stats(analysis)
+
+    report = [
+        "Configuration Analysis Report",
+        "=" * 50,
+        f"Total keys analyzed: {stats['total_keys_analyzed']}",
+        f"Custom keys: {stats['custom_keys_count']} ({stats['custom_percentage']:.1f}%)",
+        f"Missing keys: {stats['missing_keys_count']}",
+        f"Extra keys: {stats['extra_keys_count']}",
+        f"Type mismatches: {stats['type_mismatches_count']}",
+        f"Sections analyzed: {stats['sections_analyzed']}",
+        f"Configuration healthy: {'Yes' if stats['has_issues'] else 'No'}",
+        "",
+    ]
+
+    if analysis.custom_keys:
+        report.append("Custom Values:")
+        for key in sorted(analysis.custom_keys):
+            report.append(f"  ✓ {key}")
+        report.append("")
+
+    if analysis.missing_keys:
+        report.append("Missing Keys:")
+        for key in sorted(analysis.missing_keys):
+            report.append(f"  ⚠ {key}")
+        report.append("")
+
+    if analysis.type_mismatches:
+        report.append("Type Mismatches:")
+        for key in sorted(analysis.type_mismatches):
+            report.append(f"  ✗ {key}")
+        report.append("")
+
+    recommendations = ConfigComparator().get_recommendations(analysis)
+    if recommendations:
+        report.append("Recommendations:")
+        for rec in recommendations:
+            report.append(f"  • {rec}")
+
+    return "\n".join(report)

{tunacode_cli-0.0.75.dist-info → tunacode_cli-0.0.76.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunacode-cli
-Version: 0.0.75
+Version: 0.0.76.1
 Summary: Your agentic CLI developer.
 Project-URL: Homepage, https://tunacode.xyz/
 Project-URL: Repository, https://github.com/alchemiststudiosDOTai/tunacode
@@ -75,6 +75,27 @@ pip install tunacode-cli
 
 For detailed installation and configuration instructions, see the [**Getting Started Guide**](documentation/user/getting-started.md).
 
+## Quickstart
+
+```bash
+# 1) Install
+pip install tunacode-cli
+
+# 2) Launch the CLI
+tunacode --wizard   # guided setup (enter an API key, pick a model)
+
+# 3) Try common commands in the REPL
+/help        # see commands
+/model       # explore models and set a default
+/plan        # enter read-only Plan Mode
+```
+
+Tip: You can also skip the wizard and set everything via flags:
+
+```bash
+tunacode --model openai:gpt-4.1 --key sk-your-key
+```
+
 ## Development Installation
 
 For contributors and developers who want to work on TunaCode:
@@ -87,13 +108,13 @@ cd tunacode
 # Quick setup (recommended)
 ./scripts/setup_dev_env.sh
 
-# Or manual setup
-python3 -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-pip install -e ".[dev]"
+# Or manual setup with UV (recommended)
+uv venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+uv pip install -e ".[dev]"
 
 # Verify installation
-python -m tunacode --version
+tunacode --version
 ```
 
 See the [Hatch Build System Guide](documentation/development/hatch-build-system.md) for detailed instructions on the development environment.
@@ -102,6 +123,42 @@ See the [Hatch Build System Guide](documentation/development/hatch-build-system.
 
 Choose your AI provider and set your API key. For more details, see the [Configuration Section](documentation/user/getting-started.md#2-configuration) in the Getting Started Guide. For local models (LM Studio, Ollama, etc.), see the [Local Models Setup Guide](documentation/configuration/local-models.md).
 
+### New: Enhanced Model Selection
+
+TunaCode now automatically saves your model selection for future sessions. When you choose a model using `/model <provider:name>`, it will be remembered across restarts.
+
+**If you encounter API key errors**, you can manually create a configuration file that matches the current schema:
+
+```bash
+# Create the config file
+cat > ~/.config/tunacode.json << 'EOF'
+{
+  "default_model": "openai:gpt-4.1",
+  "env": {
+    "OPENAI_API_KEY": "your-openai-api-key-here",
+    "ANTHROPIC_API_KEY": "",
+    "GEMINI_API_KEY": "",
+    "OPENROUTER_API_KEY": ""
+  },
+  "settings": {
+    "enable_streaming": true,
+    "max_iterations": 40,
+    "context_window_size": 200000
+  },
+  "mcpServers": {}
+}
+EOF
+```
+
+Replace the model and API key with your preferred provider and credentials. Examples:
+- `openai:gpt-4.1` (requires OPENAI_API_KEY)
+- `anthropic:claude-4-sonnet-20250522` (requires ANTHROPIC_API_KEY)
+- `google:gemini-2.5-pro` (requires GEMINI_API_KEY)
+
+### ⚠️ Important Notice
+
+I apologize for any recent issues with model selection and configuration. I'm actively working to fix these problems and improve the overall stability of TunaCode. Your patience and feedback are greatly appreciated as I work to make the tool more reliable.
+
 ### Recommended Models
 
 Based on extensive testing, these models provide the best performance: