cinchdb 0.1.14__py3-none-any.whl → 0.1.17__py3-none-any.whl

cinchdb/plugins/base.py

@@ -0,0 +1,80 @@
+"""
+Simple base class for CinchDB plugins.
+"""
+
+from typing import Any, Dict, Optional
+
+
+class Plugin:
+    """Simple base class for CinchDB plugins."""
+    
+    # Plugin metadata - override in subclass
+    name: str = "unnamed_plugin"
+    version: str = "1.0.0"
+    description: str = ""
+    
+    def extend_database(self, db) -> None:
+        """Add methods or modify the database instance.
+        
+        Override this method to add custom methods to database instances:
+        
+        Example:
+            def extend_database(self, db):
+                db.my_custom_method = self.my_custom_method
+        """
+        pass
+    
+    def before_query(self, sql: str, params: Optional[tuple] = None) -> tuple:
+        """Called before executing any SQL query.
+        
+        Args:
+            sql: The SQL statement to be executed
+            params: Parameters for the SQL statement
+            
+        Returns:
+            Tuple of (modified_sql, modified_params)
+        """
+        return sql, params
+    
+    def after_query(self, sql: str, params: Optional[tuple], result: Any) -> Any:
+        """Called after executing any SQL query.
+        
+        Args:
+            sql: The SQL statement that was executed
+            params: Parameters that were used
+            result: The query result
+            
+        Returns:
+            Modified result (or original result)
+        """
+        return result
+    
+    def on_connect(self, db_path: str, connection) -> None:
+        """Called when a database connection is established.
+        
+        Args:
+            db_path: Path to the database file
+            connection: SQLite connection object
+        """
+        pass
+    
+    def on_disconnect(self, db_path: str) -> None:
+        """Called when a database connection is closed.
+        
+        Args:
+            db_path: Path to the database file
+        """
+        pass
+    
+    def cleanup(self) -> None:
+        """Called when plugin is being unloaded."""
+        pass
+    
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        """Get plugin metadata."""
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+        }

cinchdb/plugins/decorators.py

@@ -0,0 +1,49 @@
+"""
+Simple decorators for plugin development.
+"""
+
+from typing import Callable
+
+
+def database_method(method_name: str):
+    """Decorator to mark a method for database extension.
+    
+    Usage:
+        class Plugin:
+            @database_method("my_method")
+            def my_custom_method(self, db):
+                return "Hello from plugin!"
+    """
+    def decorator(func: Callable) -> Callable:
+        func._database_method_name = method_name
+        return func
+    return decorator
+
+
+def auto_extend(plugin_class):
+    """Class decorator to automatically extend databases with decorated methods.
+    
+    Usage:
+        @auto_extend
+        class Plugin:
+            @database_method("custom_query")
+            def custom_query_method(self, db, query):
+                # Method will be added to db instances as db.custom_query()
+                return "Custom result"
+    """
+    original_extend = getattr(plugin_class, 'extend_database', None)
+    
+    def new_extend_database(self, db):
+        # Call original extend_database if it exists
+        if original_extend:
+            original_extend(self, db)
+        
+        # Auto-add decorated methods
+        for attr_name in dir(self):
+            attr = getattr(self, attr_name)
+            if callable(attr) and hasattr(attr, '_database_method_name'):
+                method_name = attr._database_method_name
+                setattr(db, method_name, lambda *args, **kwargs: attr(db, *args, **kwargs))
+    
+    plugin_class.extend_database = new_extend_database
+    return plugin_class

cinchdb/plugins/manager.py

@@ -0,0 +1,210 @@
+"""
+Simple plugin manager for CinchDB.
+"""
+
+import importlib
+import importlib.util
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+
+from .base import Plugin
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """Simple plugin manager for CinchDB."""
+    
+    def __init__(self):
+        self.plugins: Dict[str, Plugin] = {}
+        self._database_instances: List[Any] = []
+        
+    def register_plugin(self, plugin: Union[Plugin, type]) -> None:
+        """Register a plugin instance or class."""
+        # If it's a class, instantiate it
+        if isinstance(plugin, type):
+            plugin = plugin()
+            
+        plugin_name = plugin.name
+        
+        if plugin_name in self.plugins:
+            logger.warning(f"Plugin {plugin_name} already registered, replacing")
+        
+        self.plugins[plugin_name] = plugin
+        
+        # Apply to existing database instances
+        for db_instance in self._database_instances:
+            try:
+                plugin.extend_database(db_instance)
+            except Exception as e:
+                logger.error(f"Failed to extend database with plugin {plugin_name}: {e}")
+        
+        logger.info(f"Plugin {plugin_name} registered successfully")
+    
+    def unregister_plugin(self, plugin_name: str) -> None:
+        """Unregister a plugin."""
+        if plugin_name in self.plugins:
+            plugin = self.plugins[plugin_name]
+            try:
+                plugin.cleanup()
+            except Exception as e:
+                logger.error(f"Error cleaning up plugin {plugin_name}: {e}")
+            
+            del self.plugins[plugin_name]
+            logger.info(f"Plugin {plugin_name} unregistered")
+    
+    def load_plugin_from_module(self, module_name: str) -> None:
+        """Load a plugin from a module name."""
+        try:
+            module = importlib.import_module(module_name)
+            
+            # Look for Plugin class first
+            if hasattr(module, 'Plugin'):
+                plugin_instance = module.Plugin()
+                self.register_plugin(plugin_instance)
+                return
+            
+            # Fallback: look for any Plugin subclass
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (isinstance(attr, type) and 
+                    issubclass(attr, Plugin) and 
+                    attr != Plugin):
+                    
+                    plugin_instance = attr()
+                    self.register_plugin(plugin_instance)
+                    return
+            
+            logger.warning(f"No Plugin class found in module {module_name}")
+            
+        except ImportError as e:
+            logger.error(f"Failed to import plugin module {module_name}: {e}")
+        except Exception as e:
+            logger.error(f"Failed to load plugin from {module_name}: {e}")
+    
+    def load_plugin_from_file(self, file_path: Path) -> None:
+        """Load a plugin from a Python file."""
+        try:
+            spec = importlib.util.spec_from_file_location("plugin_module", file_path)
+            if spec and spec.loader:
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+                
+                # Look for Plugin class
+                if hasattr(module, 'Plugin'):
+                    plugin_instance = module.Plugin()
+                    self.register_plugin(plugin_instance)
+                    return
+                
+                logger.warning(f"No Plugin class found in file {file_path}")
+        
+        except Exception as e:
+            logger.error(f"Failed to load plugin from file {file_path}: {e}")
+    
+    def load_plugins_from_directory(self, plugins_dir: Path) -> None:
+        """Load all plugins from a directory."""
+        if not plugins_dir.exists():
+            logger.info(f"Plugins directory {plugins_dir} does not exist")
+            return
+            
+        for plugin_file in plugins_dir.glob("*.py"):
+            if plugin_file.name == "__init__.py":
+                continue
+            self.load_plugin_from_file(plugin_file)
+    
+    def discover_plugins(self) -> None:
+        """Discover plugins using entry points and plugins directory."""
+        # Try entry points for installed plugins
+        try:
+            try:
+                from importlib.metadata import entry_points
+            except ImportError:
+                from importlib_metadata import entry_points
+                
+            eps = entry_points()
+            if hasattr(eps, 'select'):
+                plugin_eps = eps.select(group='cinchdb.plugins')
+            else:
+                plugin_eps = eps.get('cinchdb.plugins', [])
+            
+            for entry_point in plugin_eps:
+                try:
+                    plugin_class = entry_point.load()
+                    self.register_plugin(plugin_class)
+                except Exception as e:
+                    logger.error(f"Failed to load plugin {entry_point.name}: {e}")
+        except Exception as e:
+            logger.debug(f"Entry points not available: {e}")
+        
+        # Also check for local plugins directory
+        plugins_dir = Path("plugins")
+        if plugins_dir.exists():
+            self.load_plugins_from_directory(plugins_dir)
+    
+    def register_database(self, db_instance) -> None:
+        """Register a database instance with all plugins."""
+        self._database_instances.append(db_instance)
+        
+        # Apply all plugins to this database instance
+        for plugin in self.plugins.values():
+            try:
+                plugin.extend_database(db_instance)
+            except Exception as e:
+                logger.error(f"Failed to extend database with plugin {plugin.name}: {e}")
+    
+    def unregister_database(self, db_instance) -> None:
+        """Unregister a database instance."""
+        if db_instance in self._database_instances:
+            self._database_instances.remove(db_instance)
+    
+    def before_query(self, sql: str, params: Optional[tuple] = None) -> tuple:
+        """Call before_query on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                sql, params = plugin.before_query(sql, params)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} before_query failed: {e}")
+        return sql, params
+    
+    def after_query(self, sql: str, params: Optional[tuple], result: Any) -> Any:
+        """Call after_query on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                result = plugin.after_query(sql, params, result)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} after_query failed: {e}")
+        return result
+    
+    def on_connect(self, db_path: str, connection) -> None:
+        """Call on_connect on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                plugin.on_connect(db_path, connection)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} on_connect failed: {e}")
+    
+    def on_disconnect(self, db_path: str) -> None:
+        """Call on_disconnect on all plugins."""
+        for plugin in self.plugins.values():
+            try:
+                plugin.on_disconnect(db_path)
+            except Exception as e:
+                logger.error(f"Plugin {plugin.name} on_disconnect failed: {e}")
+    
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        """Get a plugin by name."""
+        return self.plugins.get(name)
+    
+    def list_plugins(self) -> List[Dict[str, Any]]:
+        """List all registered plugins with their metadata."""
+        return [plugin.metadata for plugin in self.plugins.values()]
+    
+    def plugin_exists(self, name: str) -> bool:
+        """Check if a plugin is registered."""
+        return name in self.plugins
+    
+    def cleanup_all(self) -> None:
+        """Cleanup all plugins."""
+        for plugin_name in list(self.plugins.keys()):
+            self.unregister_plugin(plugin_name)

{cinchdb-0.1.14.dist-info → cinchdb-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.14
+Version: 0.1.17
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -31,6 +31,10 @@ Description-Content-Type: text/markdown
 
 **Git-like SQLite database management with branching and multi-tenancy**
 
+[![PyPI version](https://badge.fury.io/py/cinchdb.svg)](https://badge.fury.io/py/cinchdb)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
 CinchDB is for projects that need fast queries, isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
@@ -156,24 +160,16 @@ db.update("posts", post_id, {"content": "Updated content"})
 - **Python SDK**: Core functionality for local development
 - **CLI**: Full-featured command-line interface
 
-## Security & Encryption
+## Security
 
-Optional transparent encryption for tenant databases:
+CinchDB uses standard SQLite security features:
 
-```bash
-# Enable encryption
-export CINCH_ENCRYPT_DATA=true
-export CINCH_ENCRYPTION_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
+- **WAL mode**: Better concurrency and crash recovery
+- **Foreign key constraints**: Enforced data integrity  
+- **File permissions**: Standard OS-level access control
+- **Multi-tenant isolation**: Separate database files per tenant
 
-# Install encryption library
-pip install pysqlcipher3
-```
-
-- **Tenant databases**: Encrypted with ChaCha20-Poly1305 (~2-5% overhead)
-- **Metadata**: Unencrypted for operational simplicity
-- **Integration**: Transparent - no code changes needed
-
-Works without encryption libraries - gracefully falls back to standard SQLite.
+For production deployments, consider additional security measures at the infrastructure level.
 
 ## Development
 
@@ -186,14 +182,13 @@ make test
 
 ## Future
 
-Though probably not, perhaps I'll evolve it into something bigger and more full-featured, with things like
-- data backups
-- replication to S3
-- audit access
-- SaaS-like dynamics
-- multi-project hosting
-- auth proxying
-- leader-follower abilities for edge deployment
+CinchDB focuses on being a simple, reliable SQLite management layer. Future development will prioritize:
+
+- Remote API server improvements
+- Better CLI user experience  
+- Performance optimizations
+- Additional language SDKs (TypeScript, Go, etc.)
+- Enhanced codegen features
 
 
 ## License

{cinchdb-0.1.14.dist-info → cinchdb-0.1.17.dist-info}/RECORD

@@ -1,44 +1,46 @@
-cinchdb/__init__.py,sha256=m-yJkJh1kFCBWHjgEi9Aqz7LrrxlhRWc13Daa8PJv74,477
+cinchdb/__init__.py,sha256=qnBv5kpL4GJjNbQkp-nBcOgrsskwDr7WTnUPCGwg3zs,603
 cinchdb/__main__.py,sha256=OpkDqn9zkTZhhYgvv_grswWLAHKbmxs4M-8C6Z5HfWY,85
-cinchdb/config.py,sha256=gocjMnYKLWhgvnteo6zprgwtK6Oevoxq547J_v-C9Ns,5265
+cinchdb/config.py,sha256=hYcT91mMcV0NEvJMAgtJkihfaxHJ97qqGOetnlaNZjI,4889
 cinchdb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cinchdb/cli/main.py,sha256=G26O3EqOaKwOfwkOXOfp2XgyS5fslMgKidOAgW5k6qU,4764
+cinchdb/cli/main.py,sha256=x2bF19e0lY_0V3_tx6CO9M3AaFlII75bAdWaOg0ne_A,4587
 cinchdb/cli/utils.py,sha256=InAGuo7uENvsfBQu6EKIbbiNXqmvg-BecLmhLvOz5qg,6485
-cinchdb/cli/commands/__init__.py,sha256=IRUIPHgdpF4hBDbDy0SgaWn39o5GNUjH54_C42sjlQg,273
+cinchdb/cli/commands/__init__.py,sha256=Wjj_cmfscb_mpC-yFXxWW0-pJoBlI-Vpunb37SARsTs,291
 cinchdb/cli/commands/branch.py,sha256=Nz8YQYJ7lizSXEAv0usTx85TDOC-N5Ul9KIxN8JQtKc,17973
 cinchdb/cli/commands/codegen.py,sha256=WsRWmXNTDuaLPyECW5psXM9zOQnKHpUiv8BJnBAjMII,6189
 cinchdb/cli/commands/column.py,sha256=nUVgjYbxSobJR9CC-qdOvrCl1TgFySr-ctQb0djKZtQ,11676
+cinchdb/cli/commands/data.py,sha256=tRXVeYCShVp5VKJ--Q_XzTokPE6G0gaHSad48iFHa3E,12662
 cinchdb/cli/commands/database.py,sha256=A3ew8Z987a25dRxmY5XeoB-Ka6SXLKtWogj3XAKUNZE,7332
-cinchdb/cli/commands/index.py,sha256=P0sM9lu1rVliacYl49LPqtxNYdrwzKzpVKW10jC-5i4,6096
+cinchdb/cli/commands/index.py,sha256=qL3-UOk_cBLBNR4qK2uPTyFI7qAMxQSE7YtXFXNeSdg,6094
 cinchdb/cli/commands/query.py,sha256=XW_YL6M5IYHHHMpVB5p-M01kawFxwDOK5B5hGIy_BA8,5044
 cinchdb/cli/commands/remote.py,sha256=i07hfiAxgrROB9lVJVaKK_nWxT1SGiSbtFb4jvEwxEo,4445
 cinchdb/cli/commands/table.py,sha256=K233WOV102-g6QlHhL97FhfiGz67zIctbxZblAjY4Lg,10516
-cinchdb/cli/commands/tenant.py,sha256=cOWs9Gf13ZE4KTKJZ_AvDwFDdXBUn5i-Av4MoUsc8Go,6199
+cinchdb/cli/commands/tenant.py,sha256=snpMc9Jk2uGmEJCKP39zD26BZLYBhiRxP2M5oGyz0rQ,8309
 cinchdb/cli/commands/view.py,sha256=ZmS1IW7idzzHAXmgVyY3C4IQRo7toHb6fHNFY_tQJjI,6385
 cinchdb/cli/handlers/__init__.py,sha256=f2f-Cc96rSBLbVsiIbf-b4pZCKZoHfmhNEvnZ0OurRs,131
 cinchdb/cli/handlers/codegen_handler.py,sha256=i5we_AbiUW3zfO6pIKWxvtO8OvOqz3H__4xPmTLEuQM,6524
 cinchdb/core/__init__.py,sha256=iNlT0iO9cM0HLoYwzBavUBoXRh1Tcnz1l_vfbwVxK_Q,246
-cinchdb/core/connection.py,sha256=x_xMJv1DiZtWjBoSa2rJSGHs_m6pbtk2JYIYTdeWMtE,5491
-cinchdb/core/database.py,sha256=vzVr6Y6iydf9kOU0OO7yVYoHQJ3zlfwAWF2LylJUV0I,27162
+cinchdb/core/connection.py,sha256=_Yt0ki4IbNQJ6lwvloDZ58CCA7SBJwHaB1SU1Yy-rpI,5186
+cinchdb/core/database.py,sha256=4jZwJE4UMpPv77wyQbn0FaTB1MMJv0BHl3umLJzO0q4,33680
 cinchdb/core/initializer.py,sha256=CAzq947plgEF-KXV-PD-ycJ8Zy4zXCQqCrmQ0-pV0i4,14474
-cinchdb/core/maintenance.py,sha256=PAgrSL7Cj9p3rKHV0h_L7gupN6nLD0-5eQpJZNiqyEs,2097
-cinchdb/core/path_utils.py,sha256=OPT5WGx6CPdjZbvNsB5fjJGKsl5RtW8-IFacE4TWSxA,4884
-cinchdb/infrastructure/metadata_connection_pool.py,sha256=oq4z2B43_kEPUA0QVZz6AI_xl4adOuOSJ7VeZ7ecmP4,4899
-cinchdb/infrastructure/metadata_db.py,sha256=QLVHtvto9c2yJw7022JXwfaEilS-k-OICsbHQvA6QSQ,15314
+cinchdb/core/maintenance_utils.py,sha256=FYEZK2FybghuGxo37QeTd1DLsuId0p3rKGIlpPTFJZw,1852
+cinchdb/core/path_utils.py,sha256=xcclmafzETDtivr-Qoi2gP6xZh5C49EoR6duc6YY4gw,4698
+cinchdb/core/tenant_activation.py,sha256=56FaxgZJ2IGYcF6arJfr0gc63wBpyQ4E9ssJDghlPmA,7290
+cinchdb/infrastructure/metadata_connection_pool.py,sha256=PeVsyuZKdI3Y7_InWMOn9HcSNhE0MVcP7I7wAj9esmI,4859
+cinchdb/infrastructure/metadata_db.py,sha256=gP-UORs2Ec33p9_64L2xPTZ51PQDYrmfHlofJfQUM2M,19933
 cinchdb/managers/__init__.py,sha256=ic61ZUdsg-muq0ETYO6fuZRQWF4j7l920PthTkt2QrE,808
-cinchdb/managers/branch.py,sha256=ctX2RpodtQ-fLMpGzHyJMydseb0rK4gLjMz2ix82seU,9455
-cinchdb/managers/change_applier.py,sha256=cCgjUL6SJvrgVCCHAw0mAbGqZqKmMsLa0QbziSiuW68,15576
+cinchdb/managers/branch.py,sha256=bEzl83mN9a9KW8AHC_w50QHtVdVPHUzEY-j9T2EAyR4,9445
+cinchdb/managers/change_applier.py,sha256=JWfK-B42fCc5ANGvIIogzF5SeSCkSO16y67RCNsPu08,15602
 cinchdb/managers/change_comparator.py,sha256=08pwybpSt36cFwhZRSIkHynvFMUaLKEVwa8Ajn_R9yQ,6862
 cinchdb/managers/change_tracker.py,sha256=U93BPnuGv8xSaO5qr_y5Q8ppKrVXygozdp5zUvLUqwg,5054
 cinchdb/managers/codegen.py,sha256=1CfIwjgHnNDdjrq4SzQ9VE7DFgnWfk7RtpupBFUTqxk,21804
-cinchdb/managers/column.py,sha256=i0EzDKavMvZeeaVrY9OVRNHOW60v0rUEkDjMtIs3PaE,20749
-cinchdb/managers/data.py,sha256=zS1HkMGf436m6f8VdFAqQbQFgo4sL5yKJRcRf4A6lIc,16253
-cinchdb/managers/index.py,sha256=n9bCXggZP6muJQZXCpTT46JvuvcbbnYgeV3j6iXtTVM,10371
+cinchdb/managers/column.py,sha256=JyBIu372ExMppvqklhtVAc-eZzikIqedB_8uoJtFu-Y,20755
+cinchdb/managers/data.py,sha256=zAtVLR4GaiY7ijIbWAXC7JN701KtX2zgcg4ZUlGpyts,23176
+cinchdb/managers/index.py,sha256=55_fafWd4lSju4Nw32B_1Fi1c2DPHxOgAhdsqcTR404,10343
 cinchdb/managers/merge_manager.py,sha256=R8S2hLkLJg4hLDpeJTzjVkduZgqPOjXtYgOSJhTXXrE,15690
-cinchdb/managers/query.py,sha256=mBWsWjdAqWDzuvxKsY49onAOP6dsZOMhVKwA7Y1kunE,8617
-cinchdb/managers/table.py,sha256=8w6L4-DJgvsvpTYDW123Y9JuXO95O-SfOs-XMqWSvzA,14028
-cinchdb/managers/tenant.py,sha256=szmgErdqs3KXPi5LugMnUR76PxWARMj6H6y-JvcYd68,33965
-cinchdb/managers/view.py,sha256=v9gYtRufZyxywPKLGvIjvlUXcxYh9CLRArefu9QX6zk,7809
+cinchdb/managers/query.py,sha256=hgNHda20PWMijbVRnjTKFGFBvBthep2fulkJEK1gkqU,8562
+cinchdb/managers/table.py,sha256=mv5p5WCXy1VXKRyaAZquZofdKR0gEth7It82j6p7j0E,15252
+cinchdb/managers/tenant.py,sha256=gk3Nn68n4avl2mcMcPB5HuKOsOPsMhnvgxHyK8Uwuik,31634
+cinchdb/managers/view.py,sha256=uXcRnZxF4TCcycbwH7cTje_QU3NO47fmOzJULQHHeVI,7815
 cinchdb/models/__init__.py,sha256=cZ-ailJ6qu44Iap5Rq555iB-_w9ufXVDBH3rDH-ojk0,622
 cinchdb/models/base.py,sha256=7j4rlFTP5K9ZuF8vxwC7lMFEaL7O90NJ47Ig5i7ubcw,1320
 cinchdb/models/branch.py,sha256=gRgLpRFkMC3fxf9ZigVOkS6wdkBERWqlLk0_gOYjqNk,1180
@@ -48,13 +50,15 @@ cinchdb/models/project.py,sha256=6GMXUZUsEIebqQJgRXIthWzpWKuNNmJ3drgI1vFDrMo,644
 cinchdb/models/table.py,sha256=nxf__C_YvDOW-6-vdOQ4xKmwWPZwgEdYw1I4mO_C44o,2955
 cinchdb/models/tenant.py,sha256=wTvGoO_tQdtueVB0faZFVIhSjh_DNJzywflrUpngWTM,1072
 cinchdb/models/view.py,sha256=q6j-jYzFJuhRJO87rKt6Uv8hOizHQx8xwoPKoH6XnNY,530
-cinchdb/security/__init__.py,sha256=GWV6OIczkPhJazLvMFcT54aDUI6_mU9MTZu09TEGrJ0,45
-cinchdb/security/encryption.py,sha256=nEmjNot2NyJZivrsf4jYB9Ei-LJdb2_O6BfXsO9-pww,4168
+cinchdb/plugins/__init__.py,sha256=jZtwwY0t_dhFKz-uR2V3KWBmAGknWnoLkiDWSzULdc8,293
+cinchdb/plugins/base.py,sha256=Upfgw78eOhTAfQd9FwcgGZLIT0zefPDgD4LlpzXgOBg,2232
+cinchdb/plugins/decorators.py,sha256=vY9Zh5nhGiSM6kO55srGHSP32gnyMq77UtJSO3lULq4,1550
+cinchdb/plugins/manager.py,sha256=vetdsiwTkadp3BrhjUIp2vkmCpqfuXqy-3yQBdlxruQ,8143
 cinchdb/utils/__init__.py,sha256=yQQhEjndDiB2SUJybUmp9dvEOQKiR-GySe-WiCius5E,490
 cinchdb/utils/name_validator.py,sha256=dyGX5bjlTFRA9EGrWRQKp6kR__HSV04hLV5VueJs4IQ,4027
 cinchdb/utils/sql_validator.py,sha256=aWOGlPX0gBkuR6R1EBP2stbP4PHZuI6FUBi2Ljx7JUI,5815
-cinchdb-0.1.14.dist-info/METADATA,sha256=uNJzcdK2TKRlTyob3Kpf9mJQldTrxw-nDJcqOiz9wAo,6116
-cinchdb-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cinchdb-0.1.14.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
-cinchdb-0.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cinchdb-0.1.14.dist-info/RECORD,,
+cinchdb-0.1.17.dist-info/METADATA,sha256=cTeJ-n2bL2mqALrAZt9yPES_Xt6uC_suDB8HJmNTFTo,6155
+cinchdb-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cinchdb-0.1.17.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
+cinchdb-0.1.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cinchdb-0.1.17.dist-info/RECORD,,

cinchdb/core/maintenance.py

@@ -1,73 +0,0 @@
-"""Maintenance mode utilities for CinchDB."""
-
-from pathlib import Path
-import json
-from typing import Dict, Any, Optional
-
-from cinchdb.core.path_utils import get_branch_path
-
-
-class MaintenanceError(Exception):
-    """Exception raised when operation blocked by maintenance mode."""
-
-    pass
-
-
-def is_branch_in_maintenance(project_root: Path, database: str, branch: str) -> bool:
-    """Check if a branch is in maintenance mode.
-
-    Args:
-        project_root: Path to project root
-        database: Database name
-        branch: Branch name
-
-    Returns:
-        True if in maintenance mode, False otherwise
-    """
-    branch_path = get_branch_path(project_root, database, branch)
-    maintenance_file = branch_path / ".maintenance_mode"
-    return maintenance_file.exists()
-
-
-def get_maintenance_info(
-    project_root: Path, database: str, branch: str
-) -> Optional[Dict[str, Any]]:
-    """Get maintenance mode information if active.
-
-    Args:
-        project_root: Path to project root
-        database: Database name
-        branch: Branch name
-
-    Returns:
-        Maintenance info dict or None if not in maintenance
-    """
-    branch_path = get_branch_path(project_root, database, branch)
-    maintenance_file = branch_path / ".maintenance_mode"
-
-    if maintenance_file.exists():
-        with open(maintenance_file, "r") as f:
-            return json.load(f)
-
-    return None
-
-
-def check_maintenance_mode(project_root: Path, database: str, branch: str) -> None:
-    """Check maintenance mode and raise error if active.
-
-    Args:
-        project_root: Path to project root
-        database: Database name
-        branch: Branch name
-
-    Raises:
-        MaintenanceError: If branch is in maintenance mode
-    """
-    if is_branch_in_maintenance(project_root, database, branch):
-        info = get_maintenance_info(project_root, database, branch)
-        reason = (
-            info.get("reason", "Maintenance in progress")
-            if info
-            else "Maintenance in progress"
-        )
-        raise MaintenanceError(f"Branch '{branch}' is in maintenance mode: {reason}")

cinchdb/security/__init__.py

@@ -1 +0,0 @@
-"""Security module for CinchDB encryption."""