kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/config/loader.py

@@ -7,16 +7,44 @@ from importlib.metadata import version as get_version, PackageNotFoundError
 
 from ..utils import deep_merge
 from ..utils.error_utils import safe_execute, log_and_continue
-from ..utils.config_utils import get_system_prompt_content
+from ..utils.config_utils import get_system_prompt_content, get_project_data_dir
 from ..utils.prompt_renderer import render_system_prompt
 from .manager import ConfigManager
 from .plugin_config_manager import PluginConfigManager
 
-# Get version from package metadata
-try:
-    _package_version = get_version("kollabor")
-except PackageNotFoundError:
-    _package_version = "0.4.7"  # Fallback for development mode
+def _get_version_from_pyproject() -> str:
+    """Read version from pyproject.toml for development mode."""
+    try:
+        pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            content = pyproject_path.read_text()
+            for line in content.splitlines():
+                if line.startswith("version ="):
+                    # Extract version from: version = "0.4.10"
+                    return line.split("=")[1].strip().strip('"').strip("'")
+    except Exception:
+        pass
+    return None  # Return None if not found
+
+def _is_running_from_source() -> bool:
+    """Check if we're running from source (development mode) vs installed package."""
+    try:
+        # If pyproject.toml exists in parent directory, we're running from source
+        pyproject_path = Path(__file__).parent.parent.parent / "pyproject.toml"
+        return pyproject_path.exists()
+    except Exception:
+        return False
+
+# Get version: prefer pyproject.toml when running from source, otherwise use installed version
+if _is_running_from_source():
+    # Development mode: use pyproject.toml
+    _package_version = _get_version_from_pyproject() or "0.0.0"
+else:
+    # Production mode: use installed package version
+    try:
+        _package_version = get_version("kollabor")
+    except PackageNotFoundError:
+        _package_version = "0.0.0"
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +141,7 @@ class ConfigLoader:
             },
             "logging": {
                 "level": "INFO",
-                "file": ".kollabor-cli/logs/kollabor.log",
+                "file": None,  # Determined dynamically by get_logs_dir()
                 "format_type": "compact",
                 "format": "%(asctime)s - %(levelname)-4s - %(message)-100s - %(filename)s:%(lineno)04d"
             },
@@ -129,11 +157,8 @@ class ConfigLoader:
             },
             "core": {
                 "llm": {
-                    "api_url": "http://localhost:1234",
-                    "api_token": "",
-                    "model": "qwen/qwen3-4b",
-                    "temperature": 0.7,
-                    "timeout": 0,
+                    # Note: api_url, api_token, model, temperature, timeout are now in profiles
+                    # See core.llm.profiles.* for LLM connection settings
                     "max_history": 90,
                     "save_conversations": True,
                     "conversation_format": "jsonl",
@@ -146,11 +171,11 @@ class ConfigLoader:
                     "processing_delay": 0.1,
                     "thinking_delay": 0.3,
                     "api_poll_delay": 0.01,
-                    "terminal_timeout": 30,
+                    "terminal_timeout": 120,
                     "mcp_timeout": 60,
                     "system_prompt": {
                         "base_prompt": system_prompt,
-                        "include_project_structure": True,
+                        "include_project_structure": False,
                         "attachment_files": [],
                         "custom_prompt_files": []
                     },
@@ -384,10 +409,11 @@ class ConfigLoader:
         This is the main entry point for getting a fully merged configuration
         that includes base defaults, plugin configs, and user overrides.
 
-        Priority order for user config:
-        1. Local config (.kollabor-cli/config.json in current directory)
-        2. Global config (~/.kollabor-cli/config.json in home directory)
-        3. Base defaults (if neither exists)
+        Priority order for user config (new layered system):
+        1. Global config (~/.kollabor-cli/config.json) - base layer
+        2. Project config (~/.kollabor-cli/projects/<encoded>/config.json) - project defaults
+        3. Local config (.kollabor-cli/config.json in current directory) - local override
+        4. Base defaults (if none exist)
 
         Returns:
             Complete merged configuration dictionary.
@@ -411,37 +437,81 @@ class ConfigLoader:
         return base_config
 
     def _load_user_config_with_fallback(self) -> Dict[str, Any]:
-        """Load user configuration, falling back to global config if local doesn't exist.
+        """Load user configuration with layered resolution.
 
-        Priority order:
-        1. Local config (current directory's .kollabor-cli/config.json)
-        2. Global config (~/.kollabor-cli/config.json)
+        Priority order (new layered system):
+        1. Explicit config_manager.config_path (if provided and exists)
+        2. Global config (~/.kollabor-cli/config.json) - base layer
+        3. Project config (~/.kollabor-cli/projects/<encoded>/config.json) - project defaults
+        4. Local config (.kollabor-cli/config.json) - local override
+
+        Each layer is merged on top of the previous one using deep_merge.
 
         Returns:
-            User configuration dictionary, or empty dict if none found.
+            Merged user configuration dictionary, or empty dict if none found.
         """
-        # Check if local config exists
-        if self.config_manager.config_path.exists():
-            user_config = self.config_manager.load_config_file()
-            if user_config:
-                logger.debug(f"Loaded local config from: {self.config_manager.config_path}")
-                return user_config
-
-        # Fall back to global config
+        import json
+
+        merged_config = {}
+
+        # Check if an explicit config path was provided (e.g., for testing)
+        explicit_path = None
+        if self.config_manager and self.config_manager.config_path:
+            explicit_path = self.config_manager.config_path
+            # If explicit path exists and is not in standard locations, load only from it
+            standard_paths = [
+                Path.home() / ".kollabor-cli" / "config.json",
+                get_project_data_dir() / "config.json",
+                Path.cwd() / ".kollabor-cli" / "config.json",
+            ]
+            if explicit_path.exists() and explicit_path not in standard_paths:
+                try:
+                    with open(explicit_path, 'r') as f:
+                        return json.load(f) or {}
+                except Exception as e:
+                    logger.warning(f"Failed to load explicit config: {e}")
+                    return {}
+
+        # Layer 1: Global config (base)
         global_config_path = Path.home() / ".kollabor-cli" / "config.json"
         if global_config_path.exists():
             try:
-                import json
                 with open(global_config_path, 'r') as f:
                     global_config = json.load(f)
                 if global_config:
-                    logger.info(f"Using global config as fallback from: {global_config_path}")
-                    return global_config
+                    merged_config = global_config
+                    logger.debug(f"Loaded global config from: {global_config_path}")
             except Exception as e:
                 logger.warning(f"Failed to load global config: {e}")
 
-        logger.debug("No user configuration found (local or global)")
-        return {}
+        # Layer 2: Project config (defaults for this project)
+        project_config_path = get_project_data_dir() / "config.json"
+        if project_config_path.exists():
+            try:
+                with open(project_config_path, 'r') as f:
+                    project_config = json.load(f)
+                if project_config:
+                    merged_config = deep_merge(merged_config, project_config)
+                    logger.debug(f"Merged project config from: {project_config_path}")
+            except Exception as e:
+                logger.warning(f"Failed to load project config: {e}")
+
+        # Layer 3: Local config (override)
+        local_config_path = Path.cwd() / ".kollabor-cli" / "config.json"
+        if local_config_path.exists():
+            try:
+                with open(local_config_path, 'r') as f:
+                    local_config = json.load(f)
+                if local_config:
+                    merged_config = deep_merge(merged_config, local_config)
+                    logger.debug(f"Merged local config from: {local_config_path}")
+            except Exception as e:
+                logger.warning(f"Failed to load local config: {e}")
+
+        if not merged_config:
+            logger.debug("No user configuration found (global, project, or local)")
+
+        return merged_config
     
     def save_merged_config(self, config: Dict[str, Any]) -> bool:
         """Save the complete merged configuration to file.
@@ -449,6 +519,11 @@ class ConfigLoader:
         Note: base_prompt is excluded from saving because it should always
         be dynamically loaded from the system_prompt/*.md files on startup.
 
+        Save path determination (new layered system):
+        1. Local .kollabor-cli/config.json (if exists) - local override
+        2. Project config (if exists) - project defaults
+        3. Global config - fallback
+
         Args:
             config: Configuration dictionary to save.
 
@@ -456,6 +531,7 @@ class ConfigLoader:
             True if save successful, False otherwise.
         """
         import copy
+        import json
         config_to_save = copy.deepcopy(config)
 
         # Remove base_prompt - it should always be loaded fresh from .md files
@@ -466,7 +542,45 @@ class ConfigLoader:
         except (KeyError, TypeError):
             pass  # Config structure doesn't match expected format
 
-        return self.config_manager.save_config_file(config_to_save)
+        # Use the config_manager's path if available, otherwise determine from layered system
+        if self.config_manager and self.config_manager.config_path:
+            save_path = self.config_manager.config_path
+        else:
+            save_path = self._get_config_save_path()
+        save_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            with open(save_path, 'w') as f:
+                json.dump(config_to_save, f, indent=2, ensure_ascii=False)
+            logger.info(f"Saved configuration to: {save_path}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save configuration to {save_path}: {e}")
+            return False
+
+    def _get_config_save_path(self) -> Path:
+        """Determine the appropriate config save path.
+
+        Priority:
+        1. Local .kollabor-cli/config.json (if exists) - local override
+        2. Project config (if exists) - project defaults
+        3. Global config - fallback
+
+        Returns:
+            Path where config should be saved.
+        """
+        # Check local override
+        local_path = Path.cwd() / ".kollabor-cli" / "config.json"
+        if local_path.exists():
+            return local_path
+
+        # Check project config
+        project_path = get_project_data_dir() / "config.json"
+        if project_path.exists():
+            return project_path
+
+        # Default to global
+        return Path.home() / ".kollabor-cli" / "config.json"
     
     def update_with_plugins(self) -> bool:
         """Update the configuration file with newly discovered plugins.

core/config/service.py

@@ -141,18 +141,30 @@ class ConfigService:
     
     def set(self, key_path: str, value: Any) -> bool:
         """Set a configuration value using dot notation.
-        
+
+        Saves to the appropriate location based on the layered config system:
+        1. Local .kollabor-cli/config.json (if exists)
+        2. Project config (if exists)
+        3. Global config (fallback)
+
         Args:
             key_path: Dot-separated path to the config value.
             value: Value to set.
-            
+
         Returns:
             True if set successful, False otherwise.
         """
-        success = self.config_manager.set(key_path, value)
-        if success:
-            logger.debug(f"Configuration updated: {key_path}")
-        return success
+        from ..utils import safe_set
+
+        if safe_set(self.config_manager.config, key_path, value):
+            # Use the loader's save mechanism which respects the layered system
+            success = self.config_loader.save_merged_config(self.config_manager.config)
+            if success:
+                logger.debug(f"Configuration updated: {key_path}")
+                return True
+
+        logger.error(f"Failed to set config key: {key_path}")
+        return False
     
     def reload(self) -> bool:
         """Reload configuration from file and plugins.

core/events/bus.py

@@ -1,36 +1,56 @@
 """Event system for plugin communication."""
 
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from .models import EventType, Hook
 from .registry import HookRegistry
-from .executor import HookExecutor
 from .processor import EventProcessor
 
 logger = logging.getLogger(__name__)
 
+# Import constants after HookExecutor to avoid circular import
+from .executor import (
+    HookExecutor,
+    DEFAULT_HOOK_TIMEOUT,
+    DEFAULT_HOOK_RETRIES,
+    DEFAULT_ERROR_ACTION,
+    ABSOLUTE_MAX_RETRIES,
+    MIN_TIMEOUT,
+    MAX_TIMEOUT,
+    VALID_ERROR_ACTIONS
+)
+
 
 class EventBus:
     """Simplified event bus system for plugin communication.
-    
+
     Coordinates between specialized components for hook registration
     and event processing with clean separation of concerns.
     """
-    
-    def __init__(self) -> None:
-        """Initialize the event bus with specialized components."""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
+        """Initialize the event bus with specialized components.
+
+        Args:
+            config: Configuration dictionary for hook defaults.
+        """
+        self.config = config or {}
         self.hook_registry = HookRegistry()
-        self.hook_executor = HookExecutor()
+        self.hook_executor = HookExecutor(config=self.config)
         self.event_processor = EventProcessor(self.hook_registry, self.hook_executor)
         logger.info("Event bus initialized with specialized components")
     
     async def register_hook(self, hook: Hook) -> bool:
         """Register a hook with the event bus.
-        
+
+        Note: Config defaults are applied during execution in HookExecutor,
+        not during registration. This allows runtime config changes to take
+        effect immediately without re-registering hooks.
+
         Args:
             hook: The hook to register.
-            
+
         Returns:
             True if registration successful, False otherwise.
         """