codeframe-ai 0.9.0__py3-none-any.whl

codeframe/platform_store/repositories/workspace_registry_repository.py

@@ -0,0 +1,175 @@
+"""Repository for the workspace registry (issue #601).
+
+The registry lives in the global control-plane DB and stores only project
+metadata + a pointer (``repo_path``) to each per-workspace
+``.codeframe/state.db``. It enables server-side listing of "your projects" so
+the web UI switcher can be backed by the server (with a localStorage fallback)
+instead of living purely in the browser.
+
+It is intentionally NOT a revival of the v1 global ``projects`` table — no
+domain data is stored here, only pointers and metadata.
+"""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+import logging
+
+from codeframe.platform_store.repositories.base import BaseRepository
+
+logger = logging.getLogger(__name__)
+
+
+class WorkspaceRegistryRepository(BaseRepository):
+    """Repository for workspace registry operations."""
+
+    def upsert(
+        self,
+        repo_path: str,
+        name: Optional[str] = None,
+        tech_stack: Optional[str] = None,
+        owner_user_id: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Register (or refresh) a workspace by its repo path.
+
+        Idempotent on ``repo_path``: a second call for the same path updates the
+        existing row (name/tech_stack/owner + ``last_opened_at``) instead of
+        creating a duplicate, preserving the original ``id`` and ``created_at``.
+
+        Args:
+            repo_path: Absolute path to the repository (unique key).
+            name: Human-readable display name (defaults to last path segment).
+            tech_stack: Natural-language tech stack description.
+            owner_user_id: Owning user id (nullable until auth is enforced).
+
+        Returns:
+            The registry entry as a dict.
+        """
+        now = datetime.now(timezone.utc).isoformat()
+        new_id = str(uuid.uuid4())
+
+        # INSERT ... ON CONFLICT(repo_path) DO UPDATE keeps the original id and
+        # created_at while refreshing the mutable metadata and recency stamp.
+        self._execute(
+            """
+            INSERT INTO workspaces_registry (
+                id, repo_path, name, owner_user_id, tech_stack,
+                created_at, last_opened_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(repo_path) DO UPDATE SET
+                -- COALESCE so a refresh that omits name/tech_stack (None) keeps the
+                -- previously-stored value instead of nulling it.
+                name = COALESCE(excluded.name, workspaces_registry.name),
+                owner_user_id = excluded.owner_user_id,
+                tech_stack = COALESCE(excluded.tech_stack, workspaces_registry.tech_stack),
+                last_opened_at = excluded.last_opened_at
+            """,
+            (new_id, repo_path, name, owner_user_id, tech_stack, now, now),
+        )
+        self._commit()
+
+        # Re-read so callers always get the canonical row (stable id on conflict).
+        entry = self.get_by_path(repo_path)
+        if entry is None:
+            # Should be unreachable right after a successful upsert. Raise a real
+            # error (not assert, which `python -O` strips) so the dict-return
+            # contract holds in every execution mode.
+            raise RuntimeError(
+                f"workspaces_registry upsert succeeded but row not found: {repo_path}"
+            )
+        return entry
+
+    def list_all(self, owner_user_id: Optional[int] = None) -> List[Dict[str, Any]]:
+        """List all registered workspaces, optionally filtered by owner.
+
+        Args:
+            owner_user_id: When provided, only entries owned by this user are
+                returned. When ``None``, all entries are returned (the current
+                behaviour until auth is enforced on v2 routers).
+
+        Returns:
+            List of registry entries ordered by ``last_opened_at`` descending.
+        """
+        if owner_user_id is not None:
+            rows = self._fetchall(
+                """
+                SELECT id, repo_path, name, owner_user_id, tech_stack,
+                       created_at, last_opened_at
+                FROM workspaces_registry
+                WHERE owner_user_id = ?
+                ORDER BY last_opened_at DESC
+                """,
+                (owner_user_id,),
+            )
+        else:
+            rows = self._fetchall(
+                """
+                SELECT id, repo_path, name, owner_user_id, tech_stack,
+                       created_at, last_opened_at
+                FROM workspaces_registry
+                ORDER BY last_opened_at DESC
+                """
+            )
+
+        return [self._row_to_workspace_registry(row) for row in rows]
+
+    def get_by_id(self, workspace_id: str) -> Optional[Dict[str, Any]]:
+        """Get a registry entry by its id, or None if not found."""
+        row = self._fetchone(
+            """
+            SELECT id, repo_path, name, owner_user_id, tech_stack,
+                   created_at, last_opened_at
+            FROM workspaces_registry
+            WHERE id = ?
+            """,
+            (workspace_id,),
+        )
+        return self._row_to_workspace_registry(row) if row is not None else None
+
+    def get_by_path(self, repo_path: str) -> Optional[Dict[str, Any]]:
+        """Get a registry entry by its repo path, or None if not found."""
+        row = self._fetchone(
+            """
+            SELECT id, repo_path, name, owner_user_id, tech_stack,
+                   created_at, last_opened_at
+            FROM workspaces_registry
+            WHERE repo_path = ?
+            """,
+            (repo_path,),
+        )
+        return self._row_to_workspace_registry(row) if row is not None else None
+
+    def update_last_opened(self, workspace_id: str) -> None:
+        """Bump ``last_opened_at`` for a registry entry to maintain recency."""
+        now = datetime.now(timezone.utc).isoformat()
+        self._execute(
+            "UPDATE workspaces_registry SET last_opened_at = ? WHERE id = ?",
+            (now, workspace_id),
+        )
+        self._commit()
+
+    def delete(self, workspace_id: str) -> bool:
+        """Deregister a workspace (registry-only — never touches disk files).
+
+        Returns:
+            True if a row was removed, False if the id was not found.
+        """
+        cursor = self._execute(
+            "DELETE FROM workspaces_registry WHERE id = ?",
+            (workspace_id,),
+        )
+        self._commit()
+        return cursor.rowcount > 0
+
+    def _row_to_workspace_registry(self, row) -> Dict[str, Any]:
+        """Convert a database row to a registry dict."""
+        return {
+            "id": row["id"],
+            "repo_path": row["repo_path"],
+            "name": row["name"],
+            "owner_user_id": row["owner_user_id"],
+            "tech_stack": row["tech_stack"],
+            "created_at": self._ensure_rfc3339(row["created_at"]),
+            "last_opened_at": self._ensure_rfc3339(row["last_opened_at"]),
+        }

codeframe/platform_store/schema_manager.py

@@ -0,0 +1,321 @@
+"""Database schema management for CodeFRAME.
+
+Handles schema creation, migrations, and database initialization.
+Extracted from the monolithic Database class for better maintainability.
+"""
+
+import sqlite3
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaManager:
+    """Manages database schema creation and migrations.
+
+    Responsible for creating all database tables, indexes, and ensuring
+    schema consistency across the application.
+    """
+
+    def __init__(self, conn: sqlite3.Connection):
+        """Initialize schema manager with database connection.
+
+        Args:
+            conn: Active sqlite3.Connection
+        """
+        self.conn = conn
+
+    def create_schema(self) -> None:
+        """Create all database tables and indexes.
+
+        Creates the minimal control-plane schema (auth, api keys, audit log,
+        interactive sessions). v2 domain data lives in per-workspace DBs.
+        This method is idempotent - safe to call multiple times.
+        """
+        cursor = self.conn.cursor()
+
+        # Authentication tables (users, accounts, sessions, verification, api_keys)
+        self._create_auth_tables(cursor)
+
+        # Audit log table
+        self._create_audit_log_table(cursor)
+
+        # Interactive session tables
+        self._create_interactive_session_tables(cursor)
+
+        # Workspace registry table (issue #601)
+        self._create_workspaces_registry_table(cursor)
+
+        # Create indexes
+        self._create_indexes(cursor)
+
+        self.conn.commit()
+
+        # Ensure default admin user exists
+        self._ensure_default_admin_user()
+
+    def _create_auth_tables(self, cursor: sqlite3.Cursor) -> None:
+        """Create authentication tables (fastapi-users compatible)."""
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS users (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                email TEXT UNIQUE NOT NULL,
+                name TEXT,
+                hashed_password TEXT NOT NULL,
+                is_active INTEGER DEFAULT 1,
+                is_superuser INTEGER DEFAULT 0,
+                is_verified INTEGER DEFAULT 0,
+                email_verified INTEGER DEFAULT 0,
+                image TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+
+        # Accounts table (BetterAuth compatible - stores passwords and OAuth)
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS accounts (
+                id TEXT PRIMARY KEY,
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                account_id TEXT NOT NULL,
+                provider_id TEXT NOT NULL,
+                password TEXT,
+                access_token TEXT,
+                refresh_token TEXT,
+                id_token TEXT,
+                access_token_expires_at TIMESTAMP,
+                refresh_token_expires_at TIMESTAMP,
+                scope TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                UNIQUE(user_id, provider_id)
+            )
+        """
+        )
+
+        # Create index on user_id for faster login lookups
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_accounts_user_id ON accounts(user_id)
+        """
+        )
+
+        # Sessions table (BetterAuth compatible)
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                token TEXT UNIQUE NOT NULL,
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                expires_at TIMESTAMP NOT NULL,
+                ip_address TEXT,
+                user_agent TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """
+        )
+
+        # Verification table (BetterAuth compatible)
+        # Used for email verification tokens when requireEmailVerification is enabled
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS verification (
+                id TEXT PRIMARY KEY,
+                identifier TEXT NOT NULL,
+                value TEXT NOT NULL,
+                expires_at TIMESTAMP NOT NULL
+            )
+        """
+        )
+
+        # API Keys table for programmatic access
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS api_keys (
+                id TEXT PRIMARY KEY,
+                user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                name TEXT NOT NULL,
+                key_hash TEXT NOT NULL,
+                prefix TEXT NOT NULL,
+                scopes TEXT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_used_at TIMESTAMP,
+                expires_at TIMESTAMP,
+                is_active INTEGER DEFAULT 1
+            )
+        """
+        )
+
+        # Indexes for api_keys table
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_api_keys_prefix ON api_keys(prefix)
+        """
+        )
+        cursor.execute(
+            """
+            CREATE INDEX IF NOT EXISTS idx_api_keys_user_id ON api_keys(user_id)
+        """
+        )
+
+    def _create_interactive_session_tables(self, cursor: sqlite3.Cursor) -> None:
+        """Create interactive_sessions and session_messages tables."""
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS interactive_sessions (
+                id          TEXT PRIMARY KEY,
+                workspace_path TEXT NOT NULL,
+                task_id     TEXT,
+                state       TEXT NOT NULL DEFAULT 'active'
+                    CHECK (state IN ('active', 'paused', 'ended')),
+                agent_type  TEXT NOT NULL DEFAULT 'claude',
+                model       TEXT,
+                cost_usd    REAL DEFAULT 0.0,
+                input_tokens  INTEGER DEFAULT 0,
+                output_tokens INTEGER DEFAULT 0,
+                created_at  TEXT NOT NULL,
+                updated_at  TEXT NOT NULL,
+                ended_at    TEXT
+            )
+            """
+        )
+
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS session_messages (
+                id          TEXT PRIMARY KEY,
+                session_id  TEXT NOT NULL REFERENCES interactive_sessions(id) ON DELETE CASCADE,
+                role        TEXT NOT NULL
+                    CHECK (role IN ('user', 'assistant', 'tool_use', 'tool_result', 'thinking', 'system', 'error')),
+                content     TEXT NOT NULL,
+                metadata    TEXT,
+                created_at  TEXT NOT NULL
+            )
+            """
+        )
+
+    def _create_workspaces_registry_table(self, cursor: sqlite3.Cursor) -> None:
+        """Create the workspaces_registry table (issue #601).
+
+        Stores cross-workspace, cross-device project metadata plus a pointer
+        (``repo_path``) to each per-workspace ``.codeframe/state.db``. It does
+        NOT hold any domain data — per-workspace isolation is unchanged. This is
+        deliberately not a revival of the v1 global ``projects`` table.
+        """
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS workspaces_registry (
+                id TEXT PRIMARY KEY,
+                repo_path TEXT UNIQUE NOT NULL,
+                name TEXT,
+                owner_user_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
+                tech_stack TEXT,
+                created_at TEXT NOT NULL,
+                last_opened_at TEXT NOT NULL
+            )
+            """
+        )
+
+    def _create_audit_log_table(self, cursor: sqlite3.Cursor) -> None:
+        """Create the audit log table."""
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS audit_logs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                event_type TEXT NOT NULL,
+                user_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
+                resource_type TEXT NOT NULL,
+                resource_id INTEGER,
+                ip_address TEXT,
+                metadata TEXT,
+                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+
+    def _create_indexes(self, cursor: sqlite3.Cursor) -> None:
+        """Create indexes for the live platform tables."""
+        # Interactive session indexes
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_interactive_sessions_workspace "
+            "ON interactive_sessions(workspace_path, state)"
+        )
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_interactive_sessions_state "
+            "ON interactive_sessions(state, created_at DESC)"
+        )
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_session_messages_session "
+            "ON session_messages(session_id, created_at)"
+        )
+
+        # Audit log indexes
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_audit_logs_user_id "
+            "ON audit_logs(user_id, timestamp DESC)"
+        )
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_audit_logs_event_type "
+            "ON audit_logs(event_type, timestamp DESC)"
+        )
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_audit_logs_resource "
+            "ON audit_logs(resource_type, resource_id, timestamp DESC)"
+        )
+
+        # Authentication indexes (api_keys/accounts indexes are created inline
+        # with their tables in _create_auth_tables)
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS idx_sessions_user_id ON sessions(user_id)")
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at)"
+        )
+
+        # Workspace registry indexes (issue #601)
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_workspaces_registry_owner "
+            "ON workspaces_registry(owner_user_id)"
+        )
+        cursor.execute(
+            "CREATE INDEX IF NOT EXISTS idx_workspaces_registry_last_opened "
+            "ON workspaces_registry(last_opened_at DESC)"
+        )
+
+    def _ensure_default_admin_user(self) -> None:
+        """Ensure default admin user exists in database for initial setup.
+
+        Creates admin user with id=1 if it doesn't exist. This provides
+        a bootstrap user for test fixtures and initial database setup.
+
+        SECURITY: The admin user has a disabled password placeholder
+        that cannot match any bcrypt hash, so it cannot be used for
+        direct login. Users must register through the auth system.
+
+        Uses INSERT OR IGNORE to avoid conflicts with test fixtures.
+        """
+        cursor = self.conn.cursor()
+
+        # Create user record (FastAPI Users compatible)
+        # hashed_password uses a placeholder that cannot match any bcrypt hash
+        cursor.execute(
+            """
+            INSERT OR IGNORE INTO users (
+                id, email, name, hashed_password,
+                is_active, is_superuser, is_verified, email_verified
+            )
+            VALUES (1, 'admin@localhost', 'Admin User', '!DISABLED!', 1, 1, 1, 1)
+            """
+        )
+        user_created = cursor.rowcount > 0
+
+        if user_created:
+            logger.debug(
+                "Created default admin user (id=1) for test fixtures. "
+                "This account has a disabled password and cannot be used for login."
+            )
+
+        self.conn.commit()

codeframe/templates/AGENTS.md.default

@@ -0,0 +1,94 @@
+# AGENTS.md - Project Instructions for AI Coding Agents
+
+This file provides instructions for AI coding agents working in this repository.
+For more information, see: https://agents.md/
+
+---
+
+## Tooling
+
+- **package_manager**: uv (for Python), npm (for JavaScript)
+- **test_runner**: pytest (Python), jest (JavaScript)
+- **linter**: ruff (Python), eslint (JavaScript)
+- **formatter**: black (Python), prettier (JavaScript)
+
+## Commands
+
+- **install**: `uv sync` or `npm install`
+- **test**: `uv run pytest` or `npm test`
+- **lint**: `uv run ruff check --fix .` or `npm run lint`
+- **build**: `uv run python -m build` or `npm run build`
+
+## Always Do
+
+These actions are safe and the agent should perform autonomously:
+
+- Choose between equivalent implementation approaches
+- Decide file organization and naming conventions
+- Select library versions (prefer latest stable)
+- Handle existing files appropriately (overwrite, merge, or extend)
+- Choose test frameworks and configurations based on project patterns
+- Make code style decisions following existing codebase conventions
+- Install dependencies using the project's package manager
+- Create directories and files as needed
+- Fix linting and formatting errors automatically
+- Run tests after making changes
+- Use type hints in Python code
+- Follow existing import ordering patterns
+
+## Ask First
+
+These decisions require user confirmation before proceeding:
+
+- Delete critical configuration files (.env, package.json, pyproject.toml)
+- Make breaking changes to public APIs
+- Modify security-sensitive code (auth, encryption, access control)
+- Remove or disable existing tests
+- Change database schemas or migrations
+- Upgrade major versions of core dependencies
+- Refactor code outside the immediate scope of the task
+
+## Never Do
+
+These actions are forbidden:
+
+- Commit secrets, API keys, passwords, or credentials to the repository
+- Delete the .git directory or git history
+- Push directly to main/master branch without explicit permission
+- Modify files outside the workspace directory
+- Execute commands that could cause data loss (rm -rf /, DROP DATABASE)
+- Bypass security validation or access controls
+- Install packages from untrusted sources
+- Disable or ignore security warnings
+- Access external services without explicit permission
+- Make network requests to unknown hosts
+
+## Code Style
+
+- **python_imports**: isort with black profile, absolute imports preferred
+- **python_docstrings**: Google style docstrings for public functions
+- **python_type_hints**: Required for function signatures
+- **javascript_modules**: ES modules (import/export)
+- **line_length**: 88 for Python, 100 for JavaScript
+- **indentation**: 4 spaces for Python, 2 spaces for JavaScript
+
+## Project Structure
+
+Describe your project structure here:
+
+```
+project/
+├── src/           # Source code
+├── tests/         # Test files
+├── docs/          # Documentation
+├── scripts/       # Utility scripts
+└── README.md      # Project documentation
+```
+
+## Notes
+
+Add any project-specific notes for the agent here:
+
+- Describe any unusual patterns or conventions
+- Note any known issues or quirks
+- Explain any domain-specific terminology

codeframe/tui/__init__.py

@@ -0,0 +1,5 @@
+"""TUI dashboard for CodeFRAME.
+
+Terminal-based dashboard using Textual for power users.
+Read-only view of workspace state — tasks, events, blockers.
+"""