abstractcore 2.4.8__py3-none-any.whl → 2.5.0__py3-none-any.whl

abstractcore/apps/app_config_utils.py

@@ -8,7 +8,7 @@ def get_app_defaults(app_name: str) -> tuple[str, str]:
         from ..config import get_config_manager
         config_manager = get_config_manager()
         return config_manager.get_app_default(app_name)
-    except Exception:
+    except (ImportError, Exception):
         # Fallback to hardcoded defaults if config unavailable
         hardcoded_defaults = {
             'summarizer': ('huggingface', 'unsloth/Qwen3-4B-Instruct-2507-GGUF'),

abstractcore/config/__init__.py

@@ -0,0 +1,10 @@
+"""
+AbstractCore Configuration Module
+
+Provides configuration management and command-line interface for AbstractCore.
+"""
+
+from .vision_config import handle_vision_commands, add_vision_arguments
+from .manager import get_config_manager
+
+__all__ = ['handle_vision_commands', 'add_vision_arguments', 'get_config_manager']

abstractcore/{cli → config}/main.py

@@ -38,7 +38,13 @@ from typing import List, Optional
 # Add parent directory to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
-from abstractcore.config import get_config_manager
+# Import config manager with fallback
+try:
+    from abstractcore.config import get_config_manager
+    CONFIG_AVAILABLE = True
+except ImportError:
+    CONFIG_AVAILABLE = False
+    get_config_manager = None
 
 def download_vision_model(model_name: str = "blip-base-caption") -> bool:
     """Download a vision model for local use."""
@@ -144,10 +150,12 @@ def download_vision_model(model_name: str = "blip-base-caption") -> bool:
         print(f"📁 Model saved to: {models_dir}")
 
         # Configure AbstractCore to use this model
-        from abstractcore.config import get_config_manager
-        config_manager = get_config_manager()
-        # Use the proper HuggingFace model identifier
-        config_manager.set_vision_provider("huggingface", hf_id)
+        if CONFIG_AVAILABLE:
+            config_manager = get_config_manager()
+            # Use the proper HuggingFace model identifier
+            config_manager.set_vision_provider("huggingface", hf_id)
+        else:
+            print("⚠️  Config system not available - manual configuration required")
 
         print(f"✅ Configured AbstractCore to use HuggingFace model: {hf_id}")
         print(f"🎯 Vision fallback is now enabled!")
@@ -256,6 +264,11 @@ def add_arguments(parser: argparse.ArgumentParser):
 
 def print_status():
     """Print comprehensive configuration status with improved readability."""
+    if not CONFIG_AVAILABLE or get_config_manager is None:
+        print("❌ Configuration system not available")
+        print("💡 The AbstractCore configuration module is missing")
+        return
+    
     config_manager = get_config_manager()
     status = config_manager.get_status()
 
@@ -486,6 +499,12 @@ def interactive_configure():
 
 def handle_commands(args) -> bool:
     """Handle AbstractCore configuration commands."""
+    if not CONFIG_AVAILABLE or get_config_manager is None:
+        print("❌ Error: Configuration system not available")
+        print("💡 The AbstractCore configuration module is missing or not properly installed")
+        print("💡 Please reinstall AbstractCore or check your installation")
+        return True
+    
     config_manager = get_config_manager()
     handled = False
 

abstractcore/config/manager.py

@@ -0,0 +1,344 @@
+"""
+AbstractCore Configuration Manager
+
+Provides centralized configuration management for AbstractCore.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, Tuple
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class VisionConfig:
+    """Vision configuration settings."""
+    strategy: str = "disabled"
+    caption_provider: Optional[str] = None
+    caption_model: Optional[str] = None
+    fallback_chain: list = None
+    local_models_path: Optional[str] = None
+
+    def __post_init__(self):
+        if self.fallback_chain is None:
+            self.fallback_chain = []
+
+
+@dataclass
+class EmbeddingsConfig:
+    """Embeddings configuration settings."""
+    provider: Optional[str] = "huggingface"
+    model: Optional[str] = "all-minilm-l6-v2"
+
+
+@dataclass
+class AppDefaults:
+    """Per-application default configurations."""
+    cli_provider: Optional[str] = "huggingface"
+    cli_model: Optional[str] = "unsloth/Qwen3-4B-Instruct-2507-GGUF"
+    summarizer_provider: Optional[str] = "huggingface"
+    summarizer_model: Optional[str] = "unsloth/Qwen3-4B-Instruct-2507-GGUF"
+    extractor_provider: Optional[str] = "huggingface"
+    extractor_model: Optional[str] = "unsloth/Qwen3-4B-Instruct-2507-GGUF"
+    judge_provider: Optional[str] = "huggingface"
+    judge_model: Optional[str] = "unsloth/Qwen3-4B-Instruct-2507-GGUF"
+
+
+@dataclass
+class DefaultModels:
+    """Global default model configurations."""
+    global_provider: Optional[str] = None
+    global_model: Optional[str] = None
+    chat_model: Optional[str] = None
+    code_model: Optional[str] = None
+
+
+@dataclass
+class ApiKeysConfig:
+    """API keys configuration."""
+    openai: Optional[str] = None
+    anthropic: Optional[str] = None
+    google: Optional[str] = None
+
+
+@dataclass
+class CacheConfig:
+    """Cache configuration settings."""
+    default_cache_dir: str = "~/.cache/abstractcore"
+    huggingface_cache_dir: str = "~/.cache/huggingface"
+    local_models_cache_dir: str = "~/.abstractcore/models"
+
+
+@dataclass
+class LoggingConfig:
+    """Logging configuration settings."""
+    console_level: str = "WARNING"
+    file_level: str = "DEBUG"
+    file_logging_enabled: bool = False
+    log_base_dir: Optional[str] = None
+    verbatim_enabled: bool = True
+    console_json: bool = False
+    file_json: bool = True
+
+
+@dataclass
+class AbstractCoreConfig:
+    """Main configuration class."""
+    vision: VisionConfig
+    embeddings: EmbeddingsConfig
+    app_defaults: AppDefaults
+    default_models: DefaultModels
+    api_keys: ApiKeysConfig
+    cache: CacheConfig
+    logging: LoggingConfig
+
+    @classmethod
+    def default(cls):
+        """Create default configuration."""
+        return cls(
+            vision=VisionConfig(),
+            embeddings=EmbeddingsConfig(),
+            app_defaults=AppDefaults(),
+            default_models=DefaultModels(),
+            api_keys=ApiKeysConfig(),
+            cache=CacheConfig(),
+            logging=LoggingConfig()
+        )
+
+
+class ConfigurationManager:
+    """Manages AbstractCore configuration."""
+
+    def __init__(self):
+        self.config_dir = Path.home() / ".abstractcore" / "config"
+        self.config_file = self.config_dir / "abstractcore.json"
+        self.config = self._load_config()
+
+    def _load_config(self) -> AbstractCoreConfig:
+        """Load configuration from file or create default."""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, 'r') as f:
+                    data = json.load(f)
+                return self._dict_to_config(data)
+            except Exception:
+                # If loading fails, return default config
+                return AbstractCoreConfig.default()
+        else:
+            return AbstractCoreConfig.default()
+
+    def _dict_to_config(self, data: Dict[str, Any]) -> AbstractCoreConfig:
+        """Convert dictionary to config object."""
+        # Create config objects from dictionary data
+        vision = VisionConfig(**data.get('vision', {}))
+        embeddings = EmbeddingsConfig(**data.get('embeddings', {}))
+        app_defaults = AppDefaults(**data.get('app_defaults', {}))
+        default_models = DefaultModels(**data.get('default_models', {}))
+        api_keys = ApiKeysConfig(**data.get('api_keys', {}))
+        cache = CacheConfig(**data.get('cache', {}))
+        logging = LoggingConfig(**data.get('logging', {}))
+
+        return AbstractCoreConfig(
+            vision=vision,
+            embeddings=embeddings,
+            app_defaults=app_defaults,
+            default_models=default_models,
+            api_keys=api_keys,
+            cache=cache,
+            logging=logging
+        )
+
+    def _save_config(self):
+        """Save configuration to file."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Convert config to dictionary
+        config_dict = {
+            'vision': asdict(self.config.vision),
+            'embeddings': asdict(self.config.embeddings),
+            'app_defaults': asdict(self.config.app_defaults),
+            'default_models': asdict(self.config.default_models),
+            'api_keys': asdict(self.config.api_keys),
+            'cache': asdict(self.config.cache),
+            'logging': asdict(self.config.logging)
+        }
+
+        with open(self.config_file, 'w') as f:
+            json.dump(config_dict, f, indent=2)
+
+    def set_vision_provider(self, provider: str, model: str) -> bool:
+        """Set vision provider and model."""
+        try:
+            self.config.vision.strategy = "two_stage"
+            self.config.vision.caption_provider = provider
+            self.config.vision.caption_model = model
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_vision_caption(self, model: str) -> bool:
+        """Set vision caption model (deprecated)."""
+        # Auto-detect provider from model name
+        provider = self._detect_provider_from_model(model)
+        if provider:
+            return self.set_vision_provider(provider, model)
+        return False
+
+    def _detect_provider_from_model(self, model: str) -> Optional[str]:
+        """Detect provider from model name."""
+        model_lower = model.lower()
+        
+        if any(x in model_lower for x in ['qwen2.5vl', 'llama3.2-vision', 'llava']):
+            return "ollama"
+        elif any(x in model_lower for x in ['gpt-4', 'gpt-4o']):
+            return "openai"
+        elif any(x in model_lower for x in ['claude-3']):
+            return "anthropic"
+        elif '/' in model:
+            return "lmstudio"
+        
+        return None
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get configuration status."""
+        return {
+            "config_file": str(self.config_file),
+            "vision": {
+                "strategy": self.config.vision.strategy,
+                "status": "✅ Ready" if self.config.vision.caption_provider else "❌ Not configured",
+                "caption_provider": self.config.vision.caption_provider,
+                "caption_model": self.config.vision.caption_model
+            },
+            "app_defaults": {
+                "cli": {
+                    "provider": self.config.app_defaults.cli_provider,
+                    "model": self.config.app_defaults.cli_model
+                },
+                "summarizer": {
+                    "provider": self.config.app_defaults.summarizer_provider,
+                    "model": self.config.app_defaults.summarizer_model
+                },
+                "extractor": {
+                    "provider": self.config.app_defaults.extractor_provider,
+                    "model": self.config.app_defaults.extractor_model
+                },
+                "judge": {
+                    "provider": self.config.app_defaults.judge_provider,
+                    "model": self.config.app_defaults.judge_model
+                }
+            },
+            "global_defaults": {
+                "provider": self.config.default_models.global_provider,
+                "model": self.config.default_models.global_model,
+                "chat_model": self.config.default_models.chat_model,
+                "code_model": self.config.default_models.code_model
+            },
+            "embeddings": {
+                "status": "✅ Ready",
+                "provider": self.config.embeddings.provider,
+                "model": self.config.embeddings.model
+            },
+            "streaming": {
+                "cli_stream_default": False  # Default value
+            },
+            "logging": {
+                "console_level": self.config.logging.console_level,
+                "file_level": self.config.logging.file_level,
+                "file_logging_enabled": self.config.logging.file_logging_enabled
+            },
+            "cache": {
+                "default_cache_dir": self.config.cache.default_cache_dir
+            },
+            "api_keys": {
+                "openai": "✅ Set" if self.config.api_keys.openai else "❌ Not set",
+                "anthropic": "✅ Set" if self.config.api_keys.anthropic else "❌ Not set",
+                "google": "✅ Set" if self.config.api_keys.google else "❌ Not set"
+            }
+        }
+
+    def set_global_default_model(self, provider_model: str) -> bool:
+        """Set global default model in provider/model format."""
+        try:
+            if '/' in provider_model:
+                provider, model = provider_model.split('/', 1)
+            else:
+                # Assume it's just a model name, use default provider
+                provider = "ollama"
+                model = provider_model
+            
+            self.config.default_models.global_provider = provider
+            self.config.default_models.global_model = model
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_app_default(self, app_name: str, provider: str, model: str) -> bool:
+        """Set app-specific default provider and model."""
+        try:
+            if app_name == "cli":
+                self.config.app_defaults.cli_provider = provider
+                self.config.app_defaults.cli_model = model
+            elif app_name == "summarizer":
+                self.config.app_defaults.summarizer_provider = provider
+                self.config.app_defaults.summarizer_model = model
+            elif app_name == "extractor":
+                self.config.app_defaults.extractor_provider = provider
+                self.config.app_defaults.extractor_model = model
+            elif app_name == "judge":
+                self.config.app_defaults.judge_provider = provider
+                self.config.app_defaults.judge_model = model
+            else:
+                raise ValueError(f"Unknown app: {app_name}")
+            
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def set_api_key(self, provider: str, key: str) -> bool:
+        """Set API key for a provider."""
+        try:
+            if provider == "openai":
+                self.config.api_keys.openai = key
+            elif provider == "anthropic":
+                self.config.api_keys.anthropic = key
+            elif provider == "google":
+                self.config.api_keys.google = key
+            else:
+                return False
+            
+            self._save_config()
+            return True
+        except Exception:
+            return False
+
+    def get_app_default(self, app_name: str) -> Tuple[str, str]:
+        """Get default provider and model for an app."""
+        app_defaults = self.config.app_defaults
+        
+        if app_name == "cli":
+            return app_defaults.cli_provider, app_defaults.cli_model
+        elif app_name == "summarizer":
+            return app_defaults.summarizer_provider, app_defaults.summarizer_model
+        elif app_name == "extractor":
+            return app_defaults.extractor_provider, app_defaults.extractor_model
+        elif app_name == "judge":
+            return app_defaults.judge_provider, app_defaults.judge_model
+        else:
+            # Return default fallback
+            return "huggingface", "unsloth/Qwen3-4B-Instruct-2507-GGUF"
+
+
+# Global instance
+_config_manager = None
+
+
+def get_config_manager() -> ConfigurationManager:
+    """Get the global configuration manager instance."""
+    global _config_manager
+    if _config_manager is None:
+        _config_manager = ConfigurationManager()
+    return _config_manager

abstractcore/media/vision_fallback.py

@@ -31,14 +31,28 @@ class VisionFallbackHandler:
     def __init__(self, config_manager=None):
         """Initialize with configuration manager."""
         if config_manager is None:
-            from abstractcore.config import get_config_manager
-            self.config_manager = get_config_manager()
+            try:
+                from abstractcore.config import get_config_manager
+                self.config_manager = get_config_manager()
+            except ImportError:
+                # Config module not available - use fallback behavior
+                logger.warning("Config module not available, vision fallback disabled")
+                self.config_manager = None
         else:
             self.config_manager = config_manager
 
     @property
     def vision_config(self):
         """Get vision configuration from unified config system."""
+        if self.config_manager is None:
+            # Return a minimal config object when config system is not available
+            class FallbackVisionConfig:
+                strategy = "disabled"
+                caption_provider = None
+                caption_model = None
+                fallback_chain = []
+                local_models_path = None
+            return FallbackVisionConfig()
         return self.config_manager.config.vision
 
     def create_description(self, image_path: str, user_prompt: str = None) -> str:

abstractcore/utils/version.py

@@ -11,4 +11,4 @@ including when the package is installed from PyPI where pyproject.toml is not av
 
 # Package version - update this when releasing new versions
 # This must be manually synchronized with the version in pyproject.toml
-__version__ = "2.4.8"
+__version__ = "2.5.0"

{abstractcore-2.4.8.dist-info → abstractcore-2.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.8
+Version: 2.5.0
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>
@@ -551,6 +551,10 @@ abstractcore --set-console-log-level NONE     # Disable console logging
 abstractcore --enable-file-logging            # Save logs to files
 abstractcore --enable-debug-logging           # Full debug mode
 
+# Configure vision for image analysis with text-only models
+abstractcore --set-vision-provider ollama qwen2.5vl:7b
+abstractcore --set-vision-provider lmstudio qwen/qwen3-vl-4b
+
 # Set API keys as needed
 abstractcore --set-api-key openai sk-your-key-here
 abstractcore --set-api-key anthropic your-anthropic-key

{abstractcore-2.4.8.dist-info → abstractcore-2.5.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 abstractcore/__init__.py,sha256=A7Gbn_C-robdWLLQXjtTyWsoaXDGIblSFmLRV_ni6O8,1934
 abstractcore/apps/__init__.py,sha256=sgNOv3lYyOWNBC-w6GnRN6aILGCbdkQtNcuQdJz5ghE,31
 abstractcore/apps/__main__.py,sha256=041daYkoIE1VLEO19IZC5nNIDOQZWNgpB7ogJ3SOlsE,1585
-abstractcore/apps/app_config_utils.py,sha256=GygjtkianBktRvirHya1KbXuB2r5OUDJM6ilvybQWvk,875
+abstractcore/apps/app_config_utils.py,sha256=5GIvXnD996LFIV3-BpfkqII6UqYlStm7ZCgmqDEN8dc,890
 abstractcore/apps/extractor.py,sha256=OfiqB9l_alH9xCGb6zOD__QJkDjdKOlLZngriVgmn7c,23749
 abstractcore/apps/judge.py,sha256=nOgxvn-BbhNY6xU9AlTeD1yidTh73AiVlSN7hQCVE2M,23169
 abstractcore/apps/summarizer.py,sha256=9aD6KH21w-tv_wGp9MaO2uyJuaU71OemW7KpqrG5t6w,14669
@@ -11,9 +11,10 @@ abstractcore/architectures/enums.py,sha256=9vIv2vDBEKhxwzwH9iaSAyf-iVj3p8y9loMeN
 abstractcore/assets/architecture_formats.json,sha256=CIf6SaR_IJs1D7Uvd1K3zWngIXJ_yq3DM_IE3wnpCHY,16076
 abstractcore/assets/model_capabilities.json,sha256=iUkDiljyZUZzPlpYCOFgStXyc6e7dvOfReYQ0HFrX9Q,49703
 abstractcore/assets/session_schema.json,sha256=hMCVrq3KSyVExrMGzuykf7bU-z6WyIVuEGU8du9_zUY,10570
-abstractcore/cli/__init__.py,sha256=rUjLjZSK3wENSw4g_iN43Bc2i5cggcEmj4NPXBMohdc,241
-abstractcore/cli/main.py,sha256=QD38nnfrInavO452WbkXCI37SVsdIu9VhvjEOojXBGY,31834
-abstractcore/cli/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c4KyY,17869
+abstractcore/config/__init__.py,sha256=4mHX5z5Sq8R8xh78tb9jjZLaz_oBNW1eh914OsdDTxs,318
+abstractcore/config/main.py,sha256=PaFzy0Z03mhu293_ato_8qjZJunz1AcXVYny56ct7Zw,32602
+abstractcore/config/manager.py,sha256=6dYtVlwrXxcasDfz98CyocZ1nH9RPiD-yDKtsD3L7Ic,12508
+abstractcore/config/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c4KyY,17869
 abstractcore/core/__init__.py,sha256=2h-86U4QkCQ4gzZ4iRusSTMlkODiUS6tKjZHiEXz6rM,684
 abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,695
 abstractcore/core/factory.py,sha256=ec7WGW2JKK-dhDplziTAeRkebEUFymtEEZ_bS5qkpqY,2798
@@ -31,7 +32,7 @@ abstractcore/media/auto_handler.py,sha256=R3EhifSlGSJ_2oftQ7BdD7nQBMGePHOubuXkqH
 abstractcore/media/base.py,sha256=vWdxscqTGTvd3oc4IzzsBTWhUrznWcqM7M_sFyq6-eE,15971
 abstractcore/media/capabilities.py,sha256=qqKvXGkUT-FNnbFS-EYx8KCT9SZOovO2h4N7ucrHgBA,12844
 abstractcore/media/types.py,sha256=jG-g_2_gzl8eOgEalk9x3Ikhni9GoGfoRjkZWaBhV30,10165
-abstractcore/media/vision_fallback.py,sha256=XcEV5T9ekqd4DRBrhJvxgX5j_puxSlofvuUIfQc2vmg,10629
+abstractcore/media/vision_fallback.py,sha256=yojFTwKqiE0wfQGYphpXUcANpC0Q80s-qlt7gmQGfZg,11282
 abstractcore/media/handlers/__init__.py,sha256=HBqFo15JX1q7RM11076iFQUfPvInLlOizX-LGSznLuI,404
 abstractcore/media/handlers/anthropic_handler.py,sha256=iwcHKnHgHoQGpJKlJmwFJWBvrYg9lAzAnndybwsWZRA,12427
 abstractcore/media/handlers/local_handler.py,sha256=xfMV2Ztre3eUkDno4aSGob96oWUlgicZ3VChs-txjXU,23033
@@ -76,10 +77,10 @@ abstractcore/utils/message_preprocessor.py,sha256=GdHkm6tmrgjm3PwHRSCjIsq1XLkbhy
 abstractcore/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractcore/utils/structured_logging.py,sha256=Vm-HviSa42G9DJCWmaEv4a0QG3NMsADD3ictLOs4En0,19952
 abstractcore/utils/token_utils.py,sha256=eLwFmJ68p9WMFD_MHLMmeJRW6Oqx_4hKELB8FNQ2Mnk,21097
-abstractcore/utils/version.py,sha256=4vhW55aGVOlb2i9Zm_ZxoGAPd5qtSm6ZN1WmH15tBYs,605
-abstractcore-2.4.8.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
-abstractcore-2.4.8.dist-info/METADATA,sha256=UfLD0Zi-Mco6B9NkoWuypgHZuUPJeGYyJVJjBBPlpsA,31907
-abstractcore-2.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.4.8.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
-abstractcore-2.4.8.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
-abstractcore-2.4.8.dist-info/RECORD,,
+abstractcore/utils/version.py,sha256=vI5E04BYQ3mKTIy4xhwGPse-tZLrIK0hLgJzTYZKJMQ,605
+abstractcore-2.5.0.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.5.0.dist-info/METADATA,sha256=VVP8VO51qhQD_zfPbq25CQ3rbeeMD-UYyeloPU_lFbw,32084
+abstractcore-2.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.5.0.dist-info/entry_points.txt,sha256=eUQvRc0sGl4pK3r2zhlGZro7Fk_wl4szw1hDE8SnlDI,460
+abstractcore-2.5.0.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.5.0.dist-info/RECORD,,

{abstractcore-2.4.8.dist-info → abstractcore-2.5.0.dist-info}/entry_points.txt

@@ -1,7 +1,7 @@
 [console_scripts]
-abstractcore = abstractcore.cli.main:main
+abstractcore = abstractcore.config.main:main
 abstractcore-chat = abstractcore.utils.cli:main
-abstractcore-config = abstractcore.cli.main:main
+abstractcore-config = abstractcore.config.main:main
 abstractcore-extractor = abstractcore.apps.extractor:main
 abstractcore-judge = abstractcore.apps.judge:main
 abstractcore-summarizer = abstractcore.apps.summarizer:main

abstractcore/cli/__init__.py

@@ -1,9 +0,0 @@
-"""
-AbstractCore CLI Module
-
-Provides command-line interface for AbstractCore configuration and tools.
-"""
-
-from .vision_config import handle_vision_commands, add_vision_arguments
-
-__all__ = ['handle_vision_commands', 'add_vision_arguments']