tunacode-cli 0.0.55__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

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/utils/json_utils.py

@@ -0,0 +1,206 @@
+"""
+Module: tunacode.utils.json_utils
+
+JSON parsing utilities with enhanced error handling and concatenated object support.
+"""
+
+import json
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from tunacode.constants import READ_ONLY_TOOLS
+
+logger = logging.getLogger(__name__)
+
+
+class ConcatenatedJSONError(Exception):
+    """Raised when concatenated JSON objects are detected but cannot be safely handled."""
+
+    def __init__(self, message: str, objects_found: int, tool_name: Optional[str] = None):
+        self.message = message
+        self.objects_found = objects_found
+        self.tool_name = tool_name
+        super().__init__(message)
+
+
+def split_concatenated_json(json_string: str, strict_mode: bool = True) -> List[Dict[str, Any]]:
+    """
+    Split concatenated JSON objects like {"a": 1}{"b": 2} into separate objects.
+
+    Args:
+        json_string: String containing potentially concatenated JSON objects
+        strict_mode: If True, only returns valid JSON objects. If False, attempts
+                    to recover partial objects.
+
+    Returns:
+        List of parsed JSON objects
+
+    Raises:
+        json.JSONDecodeError: If no valid JSON objects can be extracted
+        ConcatenatedJSONError: If multiple objects found but not safe to process
+    """
+    objects = []
+    brace_count = 0
+    start_pos = 0
+    in_string = False
+    escape_next = False
+
+    for i, char in enumerate(json_string):
+        if escape_next:
+            escape_next = False
+            continue
+
+        if char == "\\":
+            escape_next = True
+            continue
+
+        if char == '"' and not escape_next:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char == "{":
+            if brace_count == 0:
+                start_pos = i
+            brace_count += 1
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0:
+                potential_json = json_string[start_pos : i + 1].strip()
+                try:
+                    parsed = json.loads(potential_json)
+                    if isinstance(parsed, dict):
+                        objects.append(parsed)
+                    else:
+                        logger.warning(f"Non-dict JSON object ignored: {type(parsed)}")
+                except json.JSONDecodeError as e:
+                    if strict_mode:
+                        logger.debug(f"Invalid JSON fragment skipped: {potential_json[:100]}...")
+                    else:
+                        logger.warning(f"JSON parse error: {e}")
+                    continue
+
+    if not objects:
+        raise json.JSONDecodeError("No valid JSON objects found", json_string, 0)
+
+    return objects
+
+
+def validate_tool_args_safety(
+    objects: List[Dict[str, Any]], tool_name: Optional[str] = None
+) -> bool:
+    """
+    Validate whether it's safe to execute multiple JSON objects for a given tool.
+
+    Args:
+        objects: List of JSON objects to validate
+        tool_name: Name of the tool (if known)
+
+    Returns:
+        bool: True if safe to execute, False otherwise
+
+    Raises:
+        ConcatenatedJSONError: If multiple objects detected for unsafe tool
+    """
+    if len(objects) <= 1:
+        return True
+
+    # Check if tool is read-only (safer to execute multiple times)
+    if tool_name and tool_name in READ_ONLY_TOOLS:
+        logger.info(f"Multiple JSON objects for read-only tool {tool_name} - allowing execution")
+        return True
+
+    # For write/execute tools, multiple objects are potentially dangerous
+    if tool_name:
+        logger.warning(
+            f"Multiple JSON objects detected for tool {tool_name} "
+            f"({len(objects)} objects). This may indicate a model error."
+        )
+        raise ConcatenatedJSONError(
+            f"Multiple JSON objects not safe for tool {tool_name}",
+            objects_found=len(objects),
+            tool_name=tool_name,
+        )
+    else:
+        logger.warning(f"Multiple JSON objects detected ({len(objects)}) with unknown tool")
+        return False
+
+
+def safe_json_parse(
+    json_string: str, tool_name: Optional[str] = None, allow_concatenated: bool = False
+) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+    """
+    Safely parse JSON with optional concatenated object support.
+
+    Args:
+        json_string: JSON string to parse
+        tool_name: Name of the tool (for safety validation)
+        allow_concatenated: Whether to attempt splitting concatenated objects
+
+    Returns:
+        Single dict if one object, or list of dicts if multiple objects
+
+    Raises:
+        json.JSONDecodeError: If parsing fails
+        ConcatenatedJSONError: If concatenated objects are unsafe
+    """
+    try:
+        # First, try normal JSON parsing
+        result = json.loads(json_string)
+        if isinstance(result, dict):
+            return result
+        else:
+            raise json.JSONDecodeError(f"Expected dict, got {type(result)}", json_string, 0)
+
+    except json.JSONDecodeError as e:
+        if not allow_concatenated or "Extra data" not in str(e):
+            raise
+
+        logger.info("Attempting to split concatenated JSON objects")
+
+        # Try to split concatenated objects
+        objects = split_concatenated_json(json_string)
+
+        # Validate safety
+        if validate_tool_args_safety(objects, tool_name):
+            if len(objects) == 1:
+                return objects[0]
+            else:
+                return objects
+        else:
+            # Not safe - return first object with warning
+            logger.warning(f"Using first of {len(objects)} JSON objects only")
+            return objects[0]
+
+
+def merge_json_objects(objects: List[Dict[str, Any]], strategy: str = "first") -> Dict[str, Any]:
+    """
+    Merge multiple JSON objects using different strategies.
+
+    Args:
+        objects: List of JSON objects to merge
+        strategy: Merge strategy ("first", "last", "combine")
+
+    Returns:
+        Single merged JSON object
+    """
+    if not objects:
+        return {}
+
+    if len(objects) == 1:
+        return objects[0]
+
+    if strategy == "first":
+        return objects[0]
+    elif strategy == "last":
+        return objects[-1]
+    elif strategy == "combine":
+        # Combine all objects, later values override earlier ones
+        result = {}
+        for obj in objects:
+            result.update(obj)
+        return result
+    else:
+        raise ValueError(f"Unknown merge strategy: {strategy}")

tunacode/utils/message_utils.py

@@ -9,11 +9,21 @@ def get_message_content(message: Any) -> str:
         return message
     if isinstance(message, dict):
         if "content" in message:
-            return message["content"]
+            content = message["content"]
+            # Handle nested content structures
+            if isinstance(content, list):
+                return " ".join(get_message_content(item) for item in content)
+            return str(content)
         if "thought" in message:
-            return message["thought"]
+            return str(message["thought"])
     if hasattr(message, "content"):
-        return message.content
+        content = message.content
+        if isinstance(content, list):
+            return " ".join(get_message_content(item) for item in content)
+        return str(content)
     if hasattr(message, "parts"):
-        return " ".join(get_message_content(part) for part in message.parts)
+        parts = message.parts
+        if isinstance(parts, list):
+            return " ".join(get_message_content(part) for part in parts)
+        return str(parts)
     return ""