@mc1global/opencode-jarvis 0.13.1 → 0.14.1

package/src/application/kanban/migration_runner.py

@@ -1,278 +0,0 @@
-"""
-Kanban Migration Runner - Automatic schema migration on repository connect.
-
-Application layer service that uses SchemaProvider to ensure database
-consistency. Called automatically by KanbanRepository.connect().
-
-Following DDD: Application layer handles HOW to apply migrations,
-Domain layer (SchemaProvider) defines WHAT the schema should be.
-"""
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional, List
-import sqlite3
-import logging
-
-from src.domain.kanban.schema_provider import SchemaProvider, SchemaVersion, Migration
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class MigrationResult:
-    """Result of a migration operation."""
-
-    success: bool
-    from_version: Optional[SchemaVersion] = None
-    to_version: Optional[SchemaVersion] = None
-    migrations_applied: int = 0
-    error: Optional[str] = None
-
-
-class MigrationRunner:
-    """
-    Handles automatic schema migrations for Kanban databases.
-
-    Usage:
-        # Automatic (called by repository)
-        MigrationRunner.ensure_schema(db_path)
-
-        # Manual
-        runner = MigrationRunner(db_path)
-        result = runner.migrate()
-    """
-
-    def __init__(self, db_path: Path):
-        self.db_path = Path(db_path)
-        self._conn: Optional[sqlite3.Connection] = None
-
-    def _connect(self) -> sqlite3.Connection:
-        """Get or create database connection."""
-        if not self._conn:
-            self._conn = sqlite3.connect(str(self.db_path))
-        return self._conn
-
-    def _close(self) -> None:
-        """Close database connection."""
-        if self._conn:
-            self._conn.close()
-            self._conn = None
-
-    @classmethod
-    def ensure_schema(cls, db_path: Path) -> MigrationResult:
-        """
-        Ensure database has current schema version.
-
-        This is the main entry point, called by KanbanRepository.connect().
-        Automatically detects current version and applies necessary migrations.
-
-        For new databases (no tables), returns success without migrating,
-        as the full schema.sql will be applied by the repository.
-
-        Args:
-            db_path: Path to SQLite database
-
-        Returns:
-            MigrationResult with operation details
-        """
-        # For new databases, skip migration - schema.sql will handle it
-        if not db_path.exists():
-            return MigrationResult(
-                success=True,
-                from_version=None,
-                to_version=SchemaProvider.get_current_version(),
-                migrations_applied=0,
-            )
-
-        # Check if database has any tables (completely new)
-        runner = cls(db_path)
-        try:
-            conn = runner._connect()
-            cursor = conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table' AND name='cards'"
-            )
-            if not cursor.fetchone():
-                # New database - schema.sql will create tables first
-                # But we'll still run migrations after repository applies schema.sql
-                # by returning a special result that indicates "needs migration after init"
-                logger.info(f"New database {db_path.name}, schema.sql will initialize")
-                return MigrationResult(
-                    success=True,
-                    from_version=None,
-                    to_version=SchemaProvider.get_current_version(),
-                    migrations_applied=0,
-                )
-            runner._close()
-
-            # Existing database - run migrations
-            return runner.migrate()
-        finally:
-            runner._close()
-
-    def migrate(
-        self, target_version: Optional[SchemaVersion] = None
-    ) -> MigrationResult:
-        """
-        Migrate database to target version (default: current).
-
-        Args:
-            target_version: Target schema version (default: SchemaProvider.CURRENT_VERSION)
-
-        Returns:
-            MigrationResult with operation details
-        """
-        target = target_version or SchemaProvider.get_current_version()
-
-        # Detect current version
-        current = SchemaProvider.detect_version(self.db_path)
-        logger.info(
-            f"Database {self.db_path.name}: current={current.value}, target={target.value}"
-        )
-
-        if current >= target:
-            logger.info(
-                f"Database {self.db_path.name} already at {current.value}, no migration needed"
-            )
-            # Ensure schema_meta exists and has version recorded
-            try:
-                conn = self._connect()
-                self._ensure_schema_meta(conn)
-                self._record_version(conn, current)
-                conn.commit()
-            except Exception as e:
-                logger.warning(f"Could not update schema_meta: {e}")
-            finally:
-                self._close()
-            return MigrationResult(
-                success=True,
-                from_version=current,
-                to_version=current,
-                migrations_applied=0,
-            )
-
-        # Get migrations to apply
-        migrations = SchemaProvider.get_migrations(current, target)
-        if not migrations:
-            logger.warning(f"No migration path from {current.value} to {target.value}")
-            return MigrationResult(
-                success=False,
-                from_version=current,
-                to_version=target,
-                error=f"No migration path from {current.value} to {target.value}",
-            )
-
-        # Apply migrations
-        try:
-            conn = self._connect()
-            applied = 0
-
-            for migration in migrations:
-                logger.info(
-                    f"Applying migration: {migration.from_version.value} → {migration.to_version.value}"
-                )
-                self._apply_migration(conn, migration)
-                applied += 1
-
-            # Ensure schema_meta table exists and record version
-            self._ensure_schema_meta(conn)
-            self._record_version(conn, target)
-
-            conn.commit()
-            logger.info(f"Successfully migrated {self.db_path.name} to {target.value}")
-
-            return MigrationResult(
-                success=True,
-                from_version=current,
-                to_version=target,
-                migrations_applied=applied,
-            )
-
-        except Exception as e:
-            logger.error(f"Migration failed: {e}")
-            return MigrationResult(
-                success=False, from_version=current, to_version=target, error=str(e)
-            )
-
-    def _apply_migration(self, conn: sqlite3.Connection, migration: Migration) -> None:
-        """Apply a single migration, handling errors gracefully."""
-        sql = migration.sql.strip()
-
-        # If migration contains triggers (BEGIN...END blocks), use executescript
-        # executescript handles multi-statement SQL correctly
-        if "BEGIN" in sql and "END;" in sql:
-            try:
-                conn.executescript(sql)
-            except sqlite3.OperationalError as e:
-                error_msg = str(e).lower()
-                if (
-                    "duplicate column" in error_msg
-                    or "already exists" in error_msg
-                    or "already has a column" in error_msg
-                ):
-                    logger.debug(f"Skipping (already exists): {error_msg}")
-                else:
-                    raise
-            return
-
-        # For simple migrations without triggers, execute statement by statement
-        statements = sql.split(";")
-
-        for stmt in statements:
-            stmt = stmt.strip()
-            if not stmt:
-                continue
-
-            try:
-                conn.execute(stmt)
-            except sqlite3.OperationalError as e:
-                # Handle "column already exists" and similar errors gracefully
-                error_msg = str(e).lower()
-                if "duplicate column" in error_msg or "already exists" in error_msg:
-                    logger.debug(f"Skipping (already exists): {stmt[:50]}...")
-                else:
-                    raise
-
-    def _ensure_schema_meta(self, conn: sqlite3.Connection) -> None:
-        """Ensure schema_meta table exists."""
-        conn.execute("""
-            CREATE TABLE IF NOT EXISTS schema_meta (
-                version TEXT PRIMARY KEY,
-                applied_at TEXT DEFAULT (datetime('now', 'utc') || 'Z'),
-                description TEXT
-            )
-        """)
-
-    def _record_version(self, conn: sqlite3.Connection, version: SchemaVersion) -> None:
-        """Record schema version in schema_meta table."""
-        description = SchemaProvider.get_version_description(version)
-        conn.execute(
-            "INSERT OR REPLACE INTO schema_meta (version, description) VALUES (?, ?)",
-            (version.value, description),
-        )
-
-    def validate(self) -> MigrationResult:
-        """
-        Validate database schema matches expected version.
-
-        Returns:
-            MigrationResult indicating if schema is valid
-        """
-        current = SchemaProvider.detect_version(self.db_path)
-        target = SchemaProvider.get_current_version()
-
-        if current == target:
-            return MigrationResult(
-                success=True, from_version=current, to_version=current
-            )
-        else:
-            return MigrationResult(
-                success=False,
-                from_version=current,
-                to_version=target,
-                error=f"Schema mismatch: expected {target.value}, found {current.value}",
-            )
-
-    def get_version(self) -> SchemaVersion:
-        """Get current database schema version."""
-        return SchemaProvider.detect_version(self.db_path)

package/src/application/kanban/session_integration.py

@@ -1,135 +0,0 @@
-"""
-Session-Kanban Integration Service.
-
-Manages the lifecycle binding between Context Memory sessions and Kanban DBs.
-"""
-
-from typing import Optional, Dict, List
-from pathlib import Path
-from dataclasses import dataclass
-
-from src.shared.paths import PathRegistry
-from src.domain.governance.path_keys import PathKey
-
-
-@dataclass
-class IntegrationResult:
-    """Result of integration operation."""
-    success: bool
-    data: Optional[Dict] = None
-    error: Optional[str] = None
-
-
-class SessionKanbanIntegration:
-    """Service for session-kanban lifecycle management."""
-
-    def __init__(self):
-        from src.infrastructure.context_memory.sqlite_session_repository import (
-            SQLiteSessionRepository
-        )
-        self.session_repo = SQLiteSessionRepository()
-
-    def get_kanban_db_path(self, workspace: str) -> Path:
-        """Get Kanban DB path for workspace."""
-        kanban_dir = PathRegistry.ensure_dir(PathKey.KANBAN_DATA)
-        return kanban_dir / f"{workspace}_kanban.db"
-
-    def attach_kanban_db(self, workspace: str, session_id: str) -> IntegrationResult:
-        """Attach Kanban DB to session."""
-        db_path = self.get_kanban_db_path(workspace)
-
-        if not db_path.exists():
-            return IntegrationResult(
-                success=False,
-                error=f"no_kanban_db:workspace:{workspace}"
-            )
-
-        session = self.session_repo.find_by_id(session_id)
-        if not session:
-            return IntegrationResult(
-                success=False,
-                error=f"session_not_found:{session_id}"
-            )
-
-        if session.ended_at:
-            return IntegrationResult(
-                success=False,
-                error=f"session_ended:{session_id}"
-            )
-
-        if session.has_kanban_db():
-            return IntegrationResult(
-                success=False,
-                error=f"already_attached:{session.get_kanban_db()}"
-            )
-
-        session.link_kanban_db(str(db_path))
-        self.session_repo.update(session)
-
-        return IntegrationResult(
-            success=True,
-            data={'db_path': str(db_path), 'session_id': session_id}
-        )
-
-    def detach_kanban_db(self, session_id: str) -> IntegrationResult:
-        """Detach Kanban DB from session."""
-        session = self.session_repo.find_by_id(session_id)
-
-        if not session:
-            return IntegrationResult(
-                success=False,
-                error=f"session_not_found:{session_id}"
-            )
-
-        if not session.has_kanban_db():
-            return IntegrationResult(
-                success=False,
-                error="no_kanban_db_attached"
-            )
-
-        old_path = session.unlink_resource("kanban_db")
-        self.session_repo.update(session)
-
-        return IntegrationResult(
-            success=True,
-            data={'detached_path': old_path}
-        )
-
-    def get_status(self, workspace: str) -> IntegrationResult:
-        """Get session-kanban linkage status for workspace."""
-        db_path = self.get_kanban_db_path(workspace)
-        db_exists = db_path.exists()
-
-        active_session = self.session_repo.find_active_by_workspace(workspace)
-
-        status = {
-            'workspace': workspace,
-            'kanban_db_exists': db_exists,
-            'kanban_db_path': str(db_path) if db_exists else None,
-            'active_session_id': active_session.id if active_session else None,
-            'session_state': active_session.state.value if active_session else None,
-            'linked_kanban_db': (
-                active_session.get_kanban_db()
-                if active_session and active_session.has_kanban_db()
-                else None
-            )
-        }
-
-        return IntegrationResult(success=True, data=status)
-
-    def list_all_dbs(self) -> List[Dict]:
-        """List all Kanban databases."""
-        kanban_dir = PathRegistry.ensure_dir(PathKey.KANBAN_DATA)
-        dbs = list(kanban_dir.glob("*_kanban.db"))
-
-        result = []
-        for db in sorted(dbs):
-            workspace = db.stem.replace('_kanban', '')
-            size_kb = db.stat().st_size / 1024
-            result.append({
-                'workspace': workspace,
-                'size_kb': round(size_kb, 1),
-                'path': str(db)
-            })
-
-        return result