compair-core 0.3.9__tar.gz → 0.4.5__tar.gz

{compair_core-0.3.9 → compair_core-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compair-core
-Version: 0.3.9
+Version: 0.4.5
 Summary: Open-source foundation of the Compair collaboration platform.
 Author: RocketResearch, Inc.
 License: MIT
@@ -23,11 +23,15 @@ Requires-Dist: redis>=5.0
 Requires-Dist: psutil>=5.9
 Requires-Dist: python-Levenshtein>=0.23
 Requires-Dist: redmail>=0.6
+Requires-Dist: python-multipart>=0.0.20
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: twine>=5.0; extra == "dev"
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.3; extra == "dev"
+Provides-Extra: ocr
+Requires-Dist: pillow>=10.0; extra == "ocr"
+Requires-Dist: pytesseract>=0.3.10; extra == "ocr"
 Provides-Extra: postgres
 Requires-Dist: psycopg2-binary>=2.9; extra == "postgres"
 Dynamic: license-file
@@ -85,9 +89,19 @@ Container definitions and build pipelines live outside this public package:
 Key environment variables for the core edition:
 
 - `COMPAIR_EDITION` (`core`) – corresponds to this core local implementation.
-- `COMPAIR_SQLITE_DIR` / `COMPAIR_SQLITE_NAME` – override the default local SQLite path (falls back to `./compair_data` if `/data` is not writable).
+- `COMPAIR_DATABASE_URL` – optional explicit SQLAlchemy URL (e.g. `postgresql+psycopg2://user:pass@host/db`). When omitted, Compair falls back to a local SQLite file.
+- `COMPAIR_DB_DIR` / `COMPAIR_DB_NAME` – directory and filename for the bundled SQLite database (default: `~/.compair-core/data/compair.db`). Legacy `COMPAIR_SQLITE_*` variables remain supported.
 - `COMPAIR_LOCAL_MODEL_URL` – endpoint for your local embeddings/feedback service (defaults to `http://local-model:9000`).
 - `COMPAIR_EMAIL_BACKEND` – the core mailer logs emails to stdout; cloud overrides this with transactional delivery.
+- `COMPAIR_REQUIRE_AUTHENTICATION` (`true`) – set to `false` to run the API in single-user mode without login or account management. When disabled, Compair auto-provisions a local user, group, and long-lived session token so you can upload documents immediately.
+- `COMPAIR_SINGLE_USER_USERNAME` / `COMPAIR_SINGLE_USER_NAME` – override the email-style username and display name that are used for the auto-provisioned local user in single-user mode.
+- `COMPAIR_INCLUDE_LEGACY_ROUTES` (`false`) – opt-in to the full legacy API surface (used by the hosted product) when running the core edition. Leave unset to expose only the streamlined single-user endpoints in Swagger.
+- `COMPAIR_EMBEDDING_DIM` – force the embedding vector size stored in the database (defaults to 384 for core, 1536 for cloud). Keep this in sync with whichever embedding model you configure.
+- `COMPAIR_VECTOR_BACKEND` (`auto`) – set to `pgvector` when running against PostgreSQL with the pgvector extension, or `json` to store embeddings as JSON (the default for SQLite deployments).
+- `COMPAIR_GENERATION_PROVIDER` (`local`) – choose how feedback is produced. Options: `local` (call the bundled FastAPI service), `openai` (use ChatGPT-compatible APIs with an API key), `http` (POST the request to a custom endpoint), or `fallback` (skip generation and surface similar references only).
+- `COMPAIR_OPENAI_API_KEY` / `COMPAIR_OPENAI_MODEL` – when using the OpenAI provider, supply your API key and optional model name (defaults to `gpt-5-nano`). The fallback kicks in automatically if the key or SDK is unavailable.
+- `COMPAIR_GENERATION_ENDPOINT` – HTTP endpoint invoked when `COMPAIR_GENERATION_PROVIDER=http`; the service receives a JSON payload (`document`, `references`, `length_instruction`) and should return `{"feedback": ...}`.
+- `COMPAIR_OCR_ENDPOINT` – endpoint the backend calls for OCR uploads (defaults to the bundled Tesseract wrapper at `http://local-ocr:9001/ocr-file`). Provide your own service by overriding this URL.
 
 See `compair_core/server/settings.py` for the full settings surface.
 

{compair_core-0.3.9 → compair_core-0.4.5}/README.md

@@ -51,9 +51,19 @@ Container definitions and build pipelines live outside this public package:
 Key environment variables for the core edition:
 
 - `COMPAIR_EDITION` (`core`) – corresponds to this core local implementation.
-- `COMPAIR_SQLITE_DIR` / `COMPAIR_SQLITE_NAME` – override the default local SQLite path (falls back to `./compair_data` if `/data` is not writable).
+- `COMPAIR_DATABASE_URL` – optional explicit SQLAlchemy URL (e.g. `postgresql+psycopg2://user:pass@host/db`). When omitted, Compair falls back to a local SQLite file.
+- `COMPAIR_DB_DIR` / `COMPAIR_DB_NAME` – directory and filename for the bundled SQLite database (default: `~/.compair-core/data/compair.db`). Legacy `COMPAIR_SQLITE_*` variables remain supported.
 - `COMPAIR_LOCAL_MODEL_URL` – endpoint for your local embeddings/feedback service (defaults to `http://local-model:9000`).
 - `COMPAIR_EMAIL_BACKEND` – the core mailer logs emails to stdout; cloud overrides this with transactional delivery.
+- `COMPAIR_REQUIRE_AUTHENTICATION` (`true`) – set to `false` to run the API in single-user mode without login or account management. When disabled, Compair auto-provisions a local user, group, and long-lived session token so you can upload documents immediately.
+- `COMPAIR_SINGLE_USER_USERNAME` / `COMPAIR_SINGLE_USER_NAME` – override the email-style username and display name that are used for the auto-provisioned local user in single-user mode.
+- `COMPAIR_INCLUDE_LEGACY_ROUTES` (`false`) – opt-in to the full legacy API surface (used by the hosted product) when running the core edition. Leave unset to expose only the streamlined single-user endpoints in Swagger.
+- `COMPAIR_EMBEDDING_DIM` – force the embedding vector size stored in the database (defaults to 384 for core, 1536 for cloud). Keep this in sync with whichever embedding model you configure.
+- `COMPAIR_VECTOR_BACKEND` (`auto`) – set to `pgvector` when running against PostgreSQL with the pgvector extension, or `json` to store embeddings as JSON (the default for SQLite deployments).
+- `COMPAIR_GENERATION_PROVIDER` (`local`) – choose how feedback is produced. Options: `local` (call the bundled FastAPI service), `openai` (use ChatGPT-compatible APIs with an API key), `http` (POST the request to a custom endpoint), or `fallback` (skip generation and surface similar references only).
+- `COMPAIR_OPENAI_API_KEY` / `COMPAIR_OPENAI_MODEL` – when using the OpenAI provider, supply your API key and optional model name (defaults to `gpt-5-nano`). The fallback kicks in automatically if the key or SDK is unavailable.
+- `COMPAIR_GENERATION_ENDPOINT` – HTTP endpoint invoked when `COMPAIR_GENERATION_PROVIDER=http`; the service receives a JSON payload (`document`, `references`, `length_instruction`) and should return `{"feedback": ...}`.
+- `COMPAIR_OCR_ENDPOINT` – endpoint the backend calls for OCR uploads (defaults to the bundled Tesseract wrapper at `http://local-ocr:9001/ocr-file`). Provide your own service by overriding this URL.
 
 See `compair_core/server/settings.py` for the full settings surface.
 

{compair_core-0.3.9 → compair_core-0.4.5}/compair_core/api.py

@@ -13,6 +13,7 @@ import psutil
 from celery.result import AsyncResult
 from fastapi import APIRouter, Body, Depends, File, Form, Header, HTTPException, Query, Request, UploadFile
 from fastapi.responses import HTMLResponse, RedirectResponse, StreamingResponse
+from fastapi.routing import APIRoute
 from sqlalchemy import distinct, func, select, or_
 from sqlalchemy.orm import joinedload, Session
 
@@ -36,13 +37,17 @@ from .compair_email.templates import (
 )
 from .compair.tasks import process_document_task as process_document_celery, send_feature_announcement_task, send_deactivate_request_email, send_help_request_email
 
-import redis
+try:
+    import redis  # type: ignore
+except ImportError:  # pragma: no cover - optional dependency
+    redis = None
 
 redis_url = os.environ.get("REDIS_URL")
-redis_client = redis.Redis.from_url(redis_url)
+redis_client = redis.Redis.from_url(redis_url) if (redis and redis_url) else None
 #from compair.main import process_document
 
 router = APIRouter()
+core_router = APIRouter()
 WEB_URL = os.environ.get("WEB_URL")
 ADMIN_API_KEY = os.environ.get("ADMIN_API_KEY")
 
@@ -56,6 +61,112 @@ GA4_MEASUREMENT_ID = os.getenv("GA4_MEASUREMENT_ID")
 GA4_API_SECRET = os.getenv("GA4_API_SECRET")
 
 IS_CLOUD = os.getenv("COMPAIR_EDITION", "core").lower() == "cloud"
+SINGLE_USER_SESSION_TTL = timedelta(days=365)
+
+
+def _ensure_single_user(session: Session, settings: Settings) -> models.User:
+    """Create or fetch the singleton user used when authentication is disabled."""
+    changed = False
+    user = (
+        session.query(models.User)
+        .options(joinedload(models.User.groups))
+        .filter(models.User.username == settings.single_user_username)
+        .first()
+    )
+    if user is None:
+        now = datetime.now(timezone.utc)
+        user = models.User(
+            username=settings.single_user_username,
+            name=settings.single_user_name,
+            datetime_registered=now,
+            verification_token=None,
+            token_expiration=None,
+        )
+        user.set_password(secrets.token_urlsafe(16))
+        user.status = "active"
+        user.status_change_date = now
+        session.add(user)
+        session.flush()
+        admin = models.Administrator(user_id=user.user_id)
+        group = models.Group(
+            name=user.username,
+            datetime_created=now,
+            group_image=None,
+            category="Private",
+            description=f"Private workspace for {settings.single_user_name}",
+            visibility="private",
+        )
+        group.admins.append(admin)
+        user.groups = [group]
+        session.add_all([group, admin])
+        changed = True
+    else:
+        now = datetime.now(timezone.utc)
+        if user.status != "active":
+            user.status = "active"
+            user.status_change_date = now
+            changed = True
+        group = next((g for g in user.groups if g.name == user.username), None)
+        if group is None:
+            group = session.query(models.Group).filter(models.Group.name == user.username).first()
+            if group is None:
+                group = models.Group(
+                    name=user.username,
+                    datetime_created=now,
+                    group_image=None,
+                    category="Private",
+                    description=f"Private workspace for {user.name}",
+                    visibility="private",
+                )
+                session.add(group)
+                changed = True
+            if group not in user.groups:
+                user.groups.append(group)
+                changed = True
+        admin = session.query(models.Administrator).filter(models.Administrator.user_id == user.user_id).first()
+        if admin is None:
+            admin = models.Administrator(user_id=user.user_id)
+            session.add(admin)
+            changed = True
+        if admin not in group.admins:
+            group.admins.append(admin)
+            changed = True
+
+    if changed:
+        session.commit()
+        user = (
+            session.query(models.User)
+            .options(joinedload(models.User.groups))
+            .filter(models.User.username == settings.single_user_username)
+            .first()
+        )
+    if user is None:
+        raise RuntimeError("Failed to initialize the local Compair user.")
+    user.groups  # ensure relationship is loaded before detaching
+    return user
+
+
+def _ensure_single_user_session(session: Session, user: models.User) -> models.Session:
+    """Return a long-lived session token for the singleton user."""
+    now = datetime.now(timezone.utc)
+    existing = (
+        session.query(models.Session)
+        .filter(models.Session.user_id == user.user_id, models.Session.datetime_valid_until >= now)
+        .order_by(models.Session.datetime_valid_until.desc())
+        .first()
+    )
+    if existing:
+        return existing
+    token = secrets.token_urlsafe()
+    user_session = models.Session(
+        id=token,
+        user_id=user.user_id,
+        datetime_created=now,
+        datetime_valid_until=now + SINGLE_USER_SESSION_TTL,
+    )
+    session.add(user_session)
+    session.commit()
+    return user_session
 
 
 def require_cloud(feature: str) -> None:
@@ -80,13 +191,20 @@ HAS_ACTIVITY = hasattr(models, "Activity")
 HAS_REFERRALS = hasattr(models.User, "referral_code")
 HAS_BILLING = hasattr(models.User, "stripe_customer_id")
 HAS_TRIALS = hasattr(models.User, "trial_expiration_date")
+HAS_REDIS = redis_client is not None
 
 
 def require_feature(flag: bool, feature: str) -> None:
     if not flag:
         raise HTTPException(status_code=501, detail=f"{feature} is only available in the Compair Cloud edition.")
 
-def get_current_user(auth_token: str = Header(...)):
+def get_current_user(auth_token: str | None = Header(None)):
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        with compair.Session() as session:
+            return _ensure_single_user(session, settings)
+    if not auth_token:
+        raise HTTPException(status_code=401, detail="Missing session token")
     with compair.Session() as session:
         user_session = session.query(models.Session).filter(models.Session.id == auth_token).first()
         if not user_session:
@@ -150,9 +268,20 @@ log_service_resource_metrics(service_name="backend")  # or "frontend"
 
 @router.post("/login")
 def login(request: schema.LoginRequest) -> dict:
+    settings = get_settings_dependency()
     with compair.Session() as session:
+        if not settings.require_authentication:
+            user = _ensure_single_user(session, settings)
+            user_session = _ensure_single_user_session(session, user)
+            return {
+                "user_id": user.user_id,
+                "username": user.username,
+                "name": user.name,
+                "status": user.status,
+                "role": user.role,
+                "auth_token": user_session.id,
+            }
         user = session.query(models.User).filter(models.User.username == request.username).first()
-        print("PW yo: {request.password}")
         if not user or not user.check_password(request.password):
             raise HTTPException(status_code=401, detail="Invalid credentials")
         if user.status == 'inactive':
@@ -526,8 +655,16 @@ def create_user(
 
 
 @router.get("/load_session")
-def load_session(auth_token: str) -> schema.Session | None:
+def load_session(auth_token: str | None = None) -> schema.Session | None:
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        with compair.Session() as session:
+            user = _ensure_single_user(session, settings)
+            session_model = _ensure_single_user_session(session, user)
+            return schema.Session.model_validate(session_model, from_attributes=True)
     with compair.Session() as session:
+        if not auth_token:
+            raise HTTPException(status_code=400, detail="auth_token is required when authentication is enabled.")
         user_session = session.query(models.Session).filter(models.Session.id == auth_token).first()
         if not user_session:
             raise HTTPException(status_code=404, detail="Session not found")
@@ -536,7 +673,7 @@ def load_session(auth_token: str) -> schema.Session | None:
             valid_until = valid_until.replace(tzinfo=timezone.utc)
         if valid_until < datetime.now(timezone.utc):
             raise HTTPException(status_code=401, detail="Invalid or expired session token")
-        return user_session
+        return schema.Session.model_validate(user_session, from_attributes=True)
 
 
 @router.post("/update_user")
@@ -592,6 +729,9 @@ def update_session_duration(
 def delete_user(
     current_user: models.User = Depends(get_current_user)
 ):
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        raise HTTPException(status_code=403, detail="Deleting the local user is not supported when authentication is disabled.")
     with compair.Session() as session:
         current_user.delete()
         session.commit()
@@ -1234,22 +1374,35 @@ def create_doc(
             current_user.status_change_date = datetime.now(timezone.utc)
             session.commit()
 
-        # Enforce document limits
+        # Enforce document limits (cloud plans) – core runs are unrestricted unless explicitly configured
         team = _user_team(current_user)
+        document_limit: int | None = None
         if IS_CLOUD and HAS_TEAM and team and current_user.status == "active":
             document_limit = team.total_documents_limit  # type: ignore[union-attr]
+        elif IS_CLOUD and _user_plan(current_user) == "individual" and current_user.status == "active":
+            document_limit = 100
         else:
-            if IS_CLOUD and _user_plan(current_user) == 'individual' and current_user.status == "active":
-                document_limit = 100
-            else:
-                document_limit = int(os.getenv("COMPAIR_CORE_DOCUMENT_LIMIT", "10"))
+            raw_core_limit = os.getenv("COMPAIR_CORE_DOCUMENT_LIMIT")
+            if raw_core_limit:
+                try:
+                    document_limit = int(raw_core_limit)
+                except ValueError:
+                    document_limit = None
+
         document_count = session.query(models.Document).filter(models.Document.user_id == current_user.user_id).count()
 
-        if document_count >= document_limit:
-            raise HTTPException(
-                status_code=403,
-                detail=f"Document limit reached. Individual plan users can have 100, team plans have 100 times the number of users (pooled); other plans can have 10",
-            )
+        if document_limit is not None and document_count >= document_limit:
+            if IS_CLOUD:
+                detail_msg = (
+                    "Document limit reached. Individual plan users can have 100, team plans have 100 times "
+                    "the number of users (pooled); other plans can have 10"
+                )
+            else:
+                detail_msg = (
+                    f"Document limit of {document_limit} reached. Adjust COMPAIR_CORE_DOCUMENT_LIMIT to raise "
+                    "or unset it to remove limits in core deployments."
+                )
+            raise HTTPException(status_code=403, detail=detail_msg)
 
         if not authorid:
             authorid = current_user.user_id
@@ -1264,21 +1417,24 @@ def create_doc(
             datetime_modified=datetime.now(timezone.utc)
         )
         print('About to assign groups!')
-        print(groups.split(','))
-        if groups is not None:
-            group_ids = groups.split(',')
-            q = select(models.Group).filter(
-                models.Group.group_id.in_(group_ids)
-            )
-            groups = session.execute(q).fetchall()[0]
-            for group in groups:
-                document.groups.append(group)
+        target_group_ids = []
+        if groups:
+            target_group_ids = [gid.strip() for gid in groups.split(',') if gid.strip()]
+
+        if target_group_ids:
+            q = select(models.Group).filter(models.Group.group_id.in_(target_group_ids))
+            resolved_groups = session.execute(q).scalars().all()
+            if not resolved_groups:
+                raise HTTPException(status_code=404, detail="No matching groups found for provided IDs.")
+            document.groups = resolved_groups
         else:
-            q = select(models.Group).filter(
-                models.Group.name == current_user.username
-            )
-            group = session.execute(q).fetchone()[0]
-            document.groups = [group]
+            q = select(models.Group).filter(models.Group.name == current_user.username)
+            default_group = session.execute(q).scalars().first()
+            if default_group is None:
+                raise HTTPException(status_code=404, detail="Default group not found for user.")
+            document.groups = [default_group]
+
+        primary_group = document.groups[0]
 
         print(f'doc check!!! {document.content}')
         session.add(document)
@@ -1296,7 +1452,7 @@ def create_doc(
         log_activity(
             session=session, 
             user_id=document.author_id, 
-            group_id=group.group_id,
+            group_id=primary_group.group_id,
             action="create", 
             object_id=document.document_id, 
             object_name=document.title,
@@ -1707,6 +1863,9 @@ def load_references(
 
 @router.get("/verify-email")
 def verify_email(token: str):
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        raise HTTPException(status_code=403, detail="Email verification is disabled when authentication is disabled.")
     with compair.Session() as session:
         print(token)
         user = session.query(models.User).filter(models.User.verification_token == token).first()
@@ -1765,6 +1924,9 @@ def sign_up(
     request: schema.SignUpRequest,
     analytics: Analytics = Depends(get_analytics),
 ) -> dict:
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        raise HTTPException(status_code=403, detail="Sign-up is disabled when authentication is disabled.")
     print('1')
     if not is_valid_email(request.username):
         raise HTTPException(status_code=400, detail="Invalid email address")
@@ -1798,6 +1960,9 @@ def sign_up(
 
 @router.post("/forgot-password")
 def forgot_password(request: schema.ForgotPasswordRequest) -> dict:
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        raise HTTPException(status_code=403, detail="Password resets are disabled when authentication is disabled.")
     print('1')
     with compair.Session() as session:
         print('2')
@@ -1830,6 +1995,9 @@ def forgot_password(request: schema.ForgotPasswordRequest) -> dict:
 
 @router.post("/reset-password")
 def reset_password(request: schema.ResetPasswordRequest) -> dict:
+    settings = get_settings_dependency()
+    if not settings.require_authentication:
+        raise HTTPException(status_code=403, detail="Password resets are disabled when authentication is disabled.")
     with compair.Session() as session:
         print('1')
         print(request.token)
@@ -2216,6 +2384,8 @@ def get_activity_feed(
 ):
     """Retrieve recent activities for a user's groups."""
     require_feature(HAS_ACTIVITY, "Activity feed")
+    if not IS_CLOUD:
+        raise HTTPException(status_code=501, detail="Activity feed is only available in the Compair Cloud edition.")
     with compair.Session() as session:
         # Get user's groups
         
@@ -3228,11 +3398,12 @@ def generate_download_token(
         else:
             raise HTTPException(status_code=403, detail="Not authorized to download this file.")
 
+    if not HAS_REDIS:
+        raise HTTPException(status_code=501, detail="Secure download links require Redis, which is unavailable in the core edition.")
+
     token = secrets.token_urlsafe(32)
     key = f"download_token:{token}"
     redis_client.setex(key, 300, document_id)
-    print('Setting redis kv')
-    print(key, document_id)
     return {"download_url": f"/documents/download/{token}"}
 
 
@@ -3241,10 +3412,12 @@ def download_document_with_token(
     token: str,
     storage: StorageProvider = Depends(get_storage),
 ):
+    if not HAS_REDIS:
+        raise HTTPException(status_code=501, detail="Secure download links require Redis, which is unavailable in the core edition.")
+
     key = f"download_token:{token}"
-    print(f'Retrieving redis kv with key {key}')
-    document_id = redis_client.get(key).decode('utf-8') if redis_client.get(key) else None
-    print(f'Value {document_id}')
+    value = redis_client.get(key) if redis_client else None
+    document_id = value.decode('utf-8') if value else None
     if not document_id:
         raise HTTPException(status_code=403, detail="Invalid or expired token")
     redis_client.delete(key)
@@ -3345,6 +3518,39 @@ def submit_deactivate_request(
         return {"message": f"We’ve received your request and will delete your account and data shortly. If you change your mind, reach out within 24 hours at {EMAIL_USER}."}
 
 
+CORE_PATHS: set[str] = {
+    "/login",
+    "/load_session",
+    "/load_groups",
+    "/load_group",
+    "/create_group",
+    "/join_group",
+    "/load_group_users",
+    "/delete_group",
+    "/load_documents",
+    "/load_document",
+    "/load_document_by_id",
+    "/load_user_files",
+    "/create_doc",
+    "/update_doc",
+    "/delete_doc",
+    "/delete_docs",
+    "/process_doc",
+    "/status/{task_id}",
+    "/upload/ocr-file",
+    "/ocr-file-result/{task_id}",
+    "/load_chunks",
+    "/load_references",
+    "/load_feedback",
+    "/documents/{document_id}/feedback",
+    "/get_activity_feed",
+}
+
+for route in router.routes:
+    if isinstance(route, APIRoute) and route.path in CORE_PATHS:
+        core_router.routes.append(route)
+
+
 def create_fastapi_app():
     """Backwards-compatible app factory for running this module directly."""
     from fastapi import FastAPI

compair_core-0.4.5/compair_core/compair/__init__.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from sqlalchemy import Engine, create_engine
+from sqlalchemy.orm import sessionmaker
+
+from . import embeddings, feedback, logger, main, models, tasks, utils
+from .default_groups import initialize_default_groups
+
+edition = os.getenv("COMPAIR_EDITION", "core").lower()
+
+initialize_database_override = None
+
+if edition == "cloud":
+    try:  # Import cloud overrides if the private package is installed
+        from compair_cloud import (  # type: ignore
+            bootstrap as cloud_bootstrap,
+            embeddings as cloud_embeddings,
+            feedback as cloud_feedback,
+            logger as cloud_logger,
+            main as cloud_main,
+            models as cloud_models,
+            tasks as cloud_tasks,
+            utils as cloud_utils,
+        )
+
+        embeddings = cloud_embeddings
+        feedback = cloud_feedback
+        logger = cloud_logger
+        main = cloud_main
+        models = cloud_models
+        tasks = cloud_tasks
+        utils = cloud_utils
+        initialize_database_override = getattr(cloud_bootstrap, "initialize_database", None)
+    except ImportError:
+        pass
+
+
+def _handle_engine() -> Engine:
+    # Preferred configuration: explicit database URL
+    explicit_url = (
+        os.getenv("COMPAIR_DATABASE_URL")
+        or os.getenv("COMPAIR_DB_URL")
+        or os.getenv("DATABASE_URL")
+    )
+    if explicit_url:
+        if explicit_url.startswith("sqlite:"):
+            return create_engine(explicit_url, connect_args={"check_same_thread": False})
+        return create_engine(explicit_url)
+
+    # Backwards compatibility with legacy Postgres env variables
+    db = os.getenv("DB")
+    db_user = os.getenv("DB_USER")
+    db_passw = os.getenv("DB_PASSW")
+    db_host = os.getenv("DB_URL")
+
+    if all([db, db_user, db_passw, db_host]):
+        return create_engine(
+            f"postgresql+psycopg2://{db_user}:{db_passw}@{db_host}/{db}",
+            pool_size=10,
+            max_overflow=0,
+        )
+
+    # Local default: place an SQLite database inside COMPAIR_DB_DIR
+    db_dir = (
+        os.getenv("COMPAIR_DB_DIR")
+        or os.getenv("COMPAIR_SQLITE_DIR")
+        or os.path.join(Path.home(), ".compair-core", "data")
+    )
+    db_name = os.getenv("COMPAIR_DB_NAME") or os.getenv("COMPAIR_SQLITE_NAME") or "compair.db"
+
+    db_path = Path(db_dir).expanduser()
+    try:
+        db_path.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        fallback_dir = Path(os.getcwd()) / "compair_data"
+        fallback_dir.mkdir(parents=True, exist_ok=True)
+        db_path = fallback_dir
+
+    sqlite_path = db_path / db_name
+    return create_engine(
+        f"sqlite:///{sqlite_path}",
+        connect_args={"check_same_thread": False},
+    )
+
+
+def initialize_database() -> None:
+    models.Base.metadata.create_all(engine)
+    if initialize_database_override:
+        initialize_database_override(engine)
+
+
+def _initialize_defaults() -> None:
+    with Session() as session:
+        initialize_default_groups(session)
+
+
+engine = _handle_engine()
+initialize_database()
+Session = sessionmaker(engine)
+embedder = embeddings.Embedder()
+reviewer = feedback.Reviewer()
+_initialize_defaults()
+
+__all__ = ["embeddings", "feedback", "main", "models", "utils", "Session"]

{compair_core-0.3.9 → compair_core-0.4.5}/compair_core/compair/embeddings.py

@@ -23,7 +23,17 @@ class Embedder:
 
         if self._cloud_impl is None:
             self.model = os.getenv("COMPAIR_LOCAL_EMBED_MODEL", "hash-embedding")
-            self.dimension = int(os.getenv("COMPAIR_LOCAL_EMBED_DIM", "384"))
+            default_dim = 1536 if self.edition == "cloud" else 384
+            dim_env = (
+                os.getenv("COMPAIR_EMBEDDING_DIM")
+                or os.getenv("COMPAIR_EMBEDDING_DIMENSION")
+                or os.getenv("COMPAIR_LOCAL_EMBED_DIM")
+                or str(default_dim)
+            )
+            try:
+                self.dimension = int(dim_env)
+            except ValueError:  # pragma: no cover - invalid configuration
+                self.dimension = default_dim
             base_url = os.getenv("COMPAIR_LOCAL_MODEL_URL", "http://local-model:9000")
             route = os.getenv("COMPAIR_LOCAL_EMBED_ROUTE", "/embed")
             self.endpoint = f"{base_url.rstrip('/')}{route}"