Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

refactor(server): split the HTTP lifespan into named startup and shutdown steps (#2552)

Raghav Chamadiya1ae802eb5255
diff --git a/packages/server/src/repowise/server/app.py b/packages/server/src/repowise/server/app.py
index 53e0b5ada..3f4b9ba7c 100644
--- a/packages/server/src/repowise/server/app.py
+++ b/packages/server/src/repowise/server/app.py
@@ -17,23 +17,20 @@ limit_blas_threads()
# ruff: noqa: E402 — the BLAS pin above is only effective before these run.
import logging
import os
+import sys
from collections.abc import AsyncGenerator
from contextlib import asynccontextmanager, suppress
-from datetime import UTC, datetime
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
-from sqlalchemy import update as sa_update
from repowise.core.persistence.database import (
create_engine,
create_session_factory,
- get_session,
init_db,
resolve_db_url,
)
-from repowise.core.persistence.models import GenerationJob
from repowise.core.persistence.search import FullTextSearch
from repowise.core.providers.embedding import is_semantic_embedder
from repowise.core.providers.embedding.base import KeylessEmbedder
@@ -76,26 +73,40 @@ from repowise.server.routers import (
workspace,
)
from repowise.server.scheduler import setup_scheduler
+from repowise.server.workspace_startup import (
+ attach_workspace,
+ fail_interrupted_jobs,
+ init_workspace_state,
+ reset_workspace_stale_jobs,
+ workspace_primary_db_url,
+)
logger = logging.getLogger(__name__)
-async def reset_workspace_stale_jobs(app_state) -> int:
- """Mark interrupted pending/running jobs failed across workspace repo DBs."""
- reset_count = 0
- for ws_factory in getattr(app_state, "workspace_sessions", {}).values():
- async with get_session(ws_factory) as session:
- stale_result = await session.execute(
- sa_update(GenerationJob)
- .where(GenerationJob.status.in_(["running", "pending"]))
- .values(
- status="failed",
- error_message="Server restarted; job interrupted",
- finished_at=datetime.now(UTC),
- )
+def _gemini_embedder():
+ from repowise.core.providers.embedding.gemini import GeminiEmbedder
+
+ dims_raw = os.environ.get("REPOWISE_EMBEDDING_DIMS")
+ dims = 768
+ if dims_raw:
+ try:
+ parsed = int(dims_raw)
+ except (ValueError, OverflowError):
+ parsed = 0
+ if parsed > 0:
+ dims = parsed
+ else:
+ print(
+ f"REPOWISE_EMBEDDING_DIMS={dims_raw!r} is not a positive integer; using {dims}.",
+ file=sys.stderr,
)
- reset_count += stale_result.rowcount or 0
- return reset_count
+ # Honour the indexed embedding model so serve doesn't silently rebuild
+ # the embedder with a different default than init used (issue #426).
+ model = os.environ.get("REPOWISE_EMBEDDING_MODEL")
+ if model:
+ return GeminiEmbedder(model=model, output_dimensionality=dims)
+ return GeminiEmbedder(output_dimensionality=dims)
def _build_embedder():
@@ -114,31 +125,7 @@ def _build_embedder():
return OllamaEmbedder()
if name == "gemini":
- from repowise.core.providers.embedding.gemini import GeminiEmbedder
-
- dims_raw = os.environ.get("REPOWISE_EMBEDDING_DIMS")
- dims = 768
- if dims_raw:
- try:
- parsed = int(dims_raw)
- except (ValueError, OverflowError):
- parsed = 0
- if parsed > 0:
- dims = parsed
- else:
- import sys
-
- print(
- f"REPOWISE_EMBEDDING_DIMS={dims_raw!r} is not a positive integer;"
- f" using {dims}.",
- file=sys.stderr,
- )
- # Honour the indexed embedding model so serve doesn't silently rebuild
- # the embedder with a different default than init used (issue #426).
- model = os.environ.get("REPOWISE_EMBEDDING_MODEL")
- if model:
- return GeminiEmbedder(model=model, output_dimensionality=dims)
- return GeminiEmbedder(output_dimensionality=dims)
+ return _gemini_embedder()
if name == "openai":
from repowise.core.providers.embedding.openai import OpenAIEmbedder
@@ -171,75 +158,126 @@ def _build_query_embedder():
return CachingEmbedder(embedder) if is_semantic_embedder(embedder) else embedder
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
- """Startup: create DB engine, session factory, FTS, vector store, scheduler.
- Shutdown: dispose engine, stop scheduler, close vector store.
- """
- # Database
+def _resolve_server_db_url() -> str:
# In workspace mode, prefer the primary repo's DB over the global default.
- # This prevents the global ~/.repowise/wiki.db (which may contain stale
- # repos from old test runs) from being used as the main DB.
db_url = resolve_db_url()
if not os.environ.get("REPOWISE_DB_URL") and not os.environ.get("REPOWISE_DATABASE_URL"):
- try:
- from repowise.core.workspace.config import WorkspaceConfig, find_workspace_root
-
- _ws_root = find_workspace_root()
- if _ws_root is not None:
- _ws_cfg = WorkspaceConfig.load(_ws_root)
- _primary = _ws_cfg.get_primary()
- _primary_path = _ws_root / (_primary.path if _primary else ".")
- _primary_db = (_primary_path / ".repowise" / "wiki.db").resolve()
- if _primary_db.exists():
- db_url = f"sqlite+aiosqlite:///{_primary_db.as_posix()}"
- logger.info("workspace_primary_db", extra={"db": str(_primary_db)})
- except Exception:
- pass # Fall back to default
+ db_url = workspace_primary_db_url() or db_url
+ return db_url
- engine = create_engine(db_url)
- await init_db(engine)
- session_factory = create_session_factory(engine)
- # Reset any jobs left in "running" or "pending" state from a previous
- # server instance (crash, restart, or cancellation between row-insert and
- # background-task launch) — they can never complete now and would block
- # new syncs via the active-job guard in the repos router.
- # Note: with multi-worker deployments this is a best-effort race; the
- # try/except prevents a SQLite lock error from crashing startup.
+async def _reset_stale_jobs(session_factory) -> None:
+ # Jobs left running by a previous process can never finish and would block
+ # new syncs. Best effort: a lock error must not crash startup.
try:
- from datetime import UTC as _UTC
- from datetime import datetime
-
- from sqlalchemy import update as sa_update
-
- from repowise.core.persistence.models import GenerationJob
-
- async with get_session(session_factory) as session:
- stale_result = await session.execute(
- sa_update(GenerationJob)
- .where(GenerationJob.status.in_(["running", "pending"]))
- .values(
- status="failed",
- error_message="Server restarted — job interrupted",
- finished_at=datetime.now(_UTC),
- )
- )
- if stale_result.rowcount:
- logger.warning("reset_stale_jobs", extra={"count": stale_result.rowcount})
+ count = await fail_interrupted_jobs(session_factory, "Server restarted — job interrupted")
+ if count:
+ logger.warning("reset_stale_jobs", extra={"count": count})
except Exception as exc:
logger.warning("stale_job_reset_failed", extra={"error": str(exc)})
- # Full-text search. A failure here used to abort startup, so a store whose
- # index could not be upgraded served no documentation at all (issue #1309):
- # the wiki, the graph and the health pages were all unreachable over a
- # search index. Keyword search degrades to whatever shape the index is
- # already in, or to the vector arm alone; everything else keeps working.
+
+async def _open_fts(engine) -> FullTextSearch:
+ # An index that cannot be upgraded degrades keyword search only; it must
+ # not take the rest of the server down with it.
fts = FullTextSearch(engine)
try:
await fts.ensure_index()
except Exception as exc:
logger.warning("fts_ensure_index_failed", extra={"error": str(exc)})
+ return fts
+
+
+def _publish_core_state(
+ app_state,
+ *,
+ engine,
+ session_factory,
+ db_url: str,
+ fts: FullTextSearch,
+ vector_store,
+ primary_vector_repo_id: str | None,
+) -> None:
+ # Store on app state (before scheduler, so scheduler can reference app_state)
+ app_state.engine = engine
+ app_state.session_factory = session_factory
+ app_state.db_url = db_url
+ app_state.fts = fts
+ app_state.vector_store = vector_store
+ app_state.primary_vector_repo_id = primary_vector_repo_id
+ app_state.background_tasks = set() # Strong refs to prevent GC of asyncio tasks
+ app_state.job_tasks = {} # job_id → asyncio.Task (cancel endpoint)
+ app_state.job_cancel_tokens = {} # job_id → CancellationToken
+ app_state.job_events = {} # job_id → JobEventBuffer (SSE message frames)
+
+
+async def _rediscover_repo_dbs(app_state) -> None:
+ # Repos added via the API keep data in their own wiki.db. Runs after
+ # workspace detection so workspace members are skipped.
+ try:
+ from repowise.server.repo_db import rediscover_repo_dbs
+
+ rediscovered = await rediscover_repo_dbs(app_state)
+ if rediscovered:
+ logger.info("repo_dbs_rediscovered", extra={"count": rediscovered})
+ # Jobs interrupted by the restart live in those per-repo DBs; the
+ # earlier resets only covered the primary and workspace DBs.
+ stale = await reset_workspace_stale_jobs(app_state)
+ if stale:
+ logger.warning("reset_stale_jobs", extra={"count": stale})
+ except Exception:
+ logger.debug("repo_db_rediscovery_skipped", exc_info=True)
+
+
+async def _release_workspace_tools(app_state) -> None:
+ # Release the per-repo contexts the chat tools resolved through
+ _repo_registry = getattr(app_state, "repo_registry", None)
+ if _repo_registry is None:
+ return
+ from repowise.server.chat_tools import set_tool_workspace
+
+ with suppress(Exception):
+ await _repo_registry.close()
+ # The enricher is only ever published alongside the registry.
+ set_tool_workspace(registry=None, workspace_root=None, cross_repo_enricher=None)
+ # The test-impact join holds its own session per consumer repo.
+ from repowise.server.mcp_server._test_impact import close_test_impact_indexes
+
+ with suppress(Exception):
+ await close_test_impact_indexes()
+
+
+async def _shutdown(app: FastAPI, *, scheduler, vector_store, engine) -> None:
+ scheduler.shutdown(wait=False)
+ with suppress(Exception):
+ await vector_store.close()
+ # Close cached per-repo vector stores (LanceDB connections).
+ try:
+ from repowise.server.search_helpers import close_workspace_vector_stores
+
+ await close_workspace_vector_stores(app)
+ except Exception:
+ logger.debug("workspace_vector_store_close_failed", exc_info=True)
+ await _release_workspace_tools(app.state)
+ # Dispose workspace repo engines first
+ for ws_engine in getattr(app.state, "workspace_engines", []):
+ with suppress(Exception):
+ await ws_engine.dispose()
+ await engine.dispose()
+ logger.info("repowise_server_stopped")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+ """Startup: create DB engine, session factory, FTS, vector store, scheduler.
+ Shutdown: dispose engine, stop scheduler, close vector store.
+ """
+ db_url = _resolve_server_db_url()
+ engine = create_engine(db_url)
+ await init_db(engine)
+ session_factory = create_session_factory(engine)
+ await _reset_stale_jobs(session_factory)
+ fts = await _open_fts(engine)
# Reuse the repo-local LanceDB index written by CLI init/update. A fresh
# in-memory store is used only when this database cannot be associated with
@@ -252,18 +290,15 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
db_url,
embedder,
)
-
- # Store on app state (before scheduler, so scheduler can reference app_state)
- app.state.engine = engine
- app.state.session_factory = session_factory
- app.state.db_url = db_url
- app.state.fts = fts
- app.state.vector_store = vector_store
- app.state.primary_vector_repo_id = primary_vector_repo_id
- app.state.background_tasks = set() # Strong refs to prevent GC of asyncio tasks
- app.state.job_tasks = {} # job_id → asyncio.Task (cancel endpoint)
- app.state.job_cancel_tokens = {} # job_id → CancellationToken
- app.state.job_events = {} # job_id → JobEventBuffer (SSE message frames)
+ _publish_core_state(
+ app.state,
+ engine=engine,
+ session_factory=session_factory,
+ db_url=db_url,
+ fts=fts,
+ vector_store=vector_store,
+ primary_vector_repo_id=primary_vector_repo_id,
+ )
# Background scheduler (pass app.state so polling can launch jobs)
scheduler = setup_scheduler(session_factory, app_state=app.state)
@@ -271,7 +306,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.scheduler = scheduler
# Initialize chat tool state (bridges FastAPI state to MCP tool globals)
- from repowise.server.chat_tools import init_tool_state, set_tool_workspace
+ from repowise.server.chat_tools import init_tool_state
init_tool_state(
session_factory=session_factory,
@@ -279,242 +314,79 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
vector_store=vector_store,
)
- # Workspace detection — mirrors MCP _server.py:_detect_workspace()
- app.state.workspace_config = None
- app.state.workspace_root = None
- app.state.cross_repo_enricher = None
- app.state.repo_registry = None # RepoRegistry, workspace mode only
- app.state.workspace_sessions = {} # repo_id → session_factory
- app.state.workspace_path_to_repo_id = {} # local_path → repo_id
- app.state.workspace_engines = [] # engines to dispose on shutdown
- # Per-repo FTS instances keyed by repo_id, used by the search router
- # to fan out across every workspace repo (single-repo FTS lives on
- # app.state.fts and stays as the primary).
- app.state.workspace_fts = {} # repo_id → FullTextSearch
- # repo_id → vector store (LanceDB-backed) for per-repo semantic search.
- # Populated lazily by the search router on first use, then cached.
- app.state.workspace_vector_stores = {} # repo_id → VectorStore
- if primary_vector_repo_id is not None:
- app.state.workspace_vector_stores[primary_vector_repo_id] = vector_store
+ init_workspace_state(app.state, vector_store, primary_vector_repo_id)
+ await attach_workspace(
+ app.state,
+ session_factory=session_factory,
+ fts=fts,
+ db_url=db_url,
+ embedder_factory=_build_query_embedder,
+ )
+ await _rediscover_repo_dbs(app.state)
+ logger.info("repowise_server_started", extra={"version": __version__})
try:
- from pathlib import Path as _Path
+ yield
+ finally:
+ # The workspace tool globals outlive the app, so shut down even on error.
+ await _shutdown(app, scheduler=scheduler, vector_store=vector_store, engine=engine)
- from repowise.core.workspace.config import (
- WORKSPACE_DATA_DIR,
- WorkspaceConfig,
- find_workspace_root,
- )
- ws_root = find_workspace_root()
- if ws_root is not None:
- ws_config = WorkspaceConfig.load(ws_root)
- app.state.workspace_config = ws_config
- app.state.workspace_root = str(ws_root)
-
- from repowise.core.persistence.database import get_configured_db_url
-
- configured_db_url = get_configured_db_url()
- if configured_db_url is not None:
- # Shared database mode (e.g. PostgreSQL, REPOWISE_DB_URL).
- # Member repos are registered in the shared database and do not
- # have per-repo .repowise/wiki.db files.
- from repowise.core.persistence.crud import get_repository_by_path
-
- async with get_session(session_factory) as session:
- for repo_entry in ws_config.repos:
- repo_path = (_Path(ws_root) / repo_entry.path).resolve()
- try:
- repo = await get_repository_by_path(session, str(repo_path))
- if repo is not None:
- app.state.workspace_sessions[repo.id] = session_factory
- app.state.workspace_fts[repo.id] = fts
- app.state.workspace_path_to_repo_id[str(repo_path)] = repo.id
- except Exception:
- logger.debug(
- "workspace_shared_db_repo_lookup_failed",
- extra={"path": str(repo_path)},
- exc_info=True,
- )
- else:
- # Create per-repo DB engines so all workspace repos are accessible
- # via the same REST API (sidebar, repo-specific pages, etc.)
- import sqlite3 as _sqlite3
-
- for repo_entry in ws_config.repos:
- repo_path = (_Path(ws_root) / repo_entry.path).resolve()
- repo_db = repo_path / ".repowise" / "wiki.db"
- if not repo_db.exists():
- continue
- # Read repo_id from this DB
- try:
- conn = _sqlite3.connect(str(repo_db))
- row = conn.execute("SELECT id FROM repositories LIMIT 1").fetchone()
- conn.close()
- if not row:
- continue
- repo_id = row[0]
- app.state.workspace_path_to_repo_id[str(repo_path)] = repo_id
- except Exception:
- continue
-
- # Skip if this is the primary DB we already connected to
- # (the main engine already serves this repo) — but still
- # register the primary's FTS under its repo_id so the
- # search fan-out can include it.
- db_url_posix = repo_db.as_posix()
- if db_url and db_url_posix in db_url.replace("\\", "/"):
- app.state.workspace_fts[repo_id] = fts
- continue
-
- repo_engine = create_engine(f"sqlite+aiosqlite:///{db_url_posix}")
- await init_db(repo_engine)
- repo_sf = create_session_factory(repo_engine)
- app.state.workspace_sessions[repo_id] = repo_sf
- app.state.workspace_engines.append(repo_engine)
-
- # Build a per-repo FTS instance so the search router can
- # fan out queries across every workspace repo. Without
- # this, full-text search only ever sees the primary DB.
- try:
- repo_fts = FullTextSearch(repo_engine)
- await repo_fts.ensure_index()
- app.state.workspace_fts[repo_id] = repo_fts
- except Exception:
- logger.debug(
- "workspace_fts_init_failed",
- extra={"repo_id": repo_id},
- exc_info=True,
- )
-
- if app.state.workspace_sessions:
- logger.info(
- "workspace_repo_dbs_loaded",
- extra={"count": len(app.state.workspace_sessions)},
- )
-
- # Give the MCP tool functions a RepoRegistry, the same one the
- # stdio MCP lifespan builds (_server.py). Without it every chat
- # tool call falls into the single-repo branch of
- # _resolve_repo_context() and dies with "Repository not found:
- # <alias>", because the alias is looked up in the primary repo's
- # wiki.db only (issue #970). Contexts load lazily, so the repo
- # the first chat call names pays the engine/FTS open cost inline.
- # The registry holds its own handles on each repo's wiki.db,
- # separate from app.state.workspace_sessions above; collapsing
- # the two onto one set of connections is worth doing but is a
- # bigger change than this fix.
- from repowise.core.workspace.registry import RepoRegistry
-
- repo_registry = RepoRegistry(
- workspace_root=_Path(ws_root),
- ws_config=ws_config,
- embedder_factory=_build_query_embedder,
- )
- app.state.repo_registry = repo_registry
- set_tool_workspace(registry=repo_registry, workspace_root=str(ws_root))
-
- # Reset stale jobs in non-primary workspace DBs too. The primary
- # DB was handled before workspace detection, but each secondary
- # repo has its own generation_jobs table and stale running rows
- # there would keep the UI showing an in-progress sync forever.
- try:
- reset_count = await reset_workspace_stale_jobs(app.state)
- if reset_count:
- logger.warning(
- "reset_workspace_stale_jobs",
- extra={"count": reset_count},
- )
- except Exception as exc:
- logger.warning("workspace_stale_job_reset_failed", extra={"error": str(exc)})
-
- from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME
- from repowise.core.workspace.conformance import CONFORMANCE_FILENAME
- from repowise.core.workspace.contracts import CONTRACTS_FILENAME
- from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
- from repowise.server.mcp_server._enrichment import CrossRepoEnricher
-
- cross_repo_path = _Path(ws_root) / WORKSPACE_DATA_DIR / "cross_repo_edges.json"
- contracts_path = _Path(ws_root) / WORKSPACE_DATA_DIR / CONTRACTS_FILENAME
- system_graph_path = _Path(ws_root) / WORKSPACE_DATA_DIR / SYSTEM_GRAPH_FILENAME
- breaking_changes_path = _Path(ws_root) / WORKSPACE_DATA_DIR / BREAKING_CHANGES_FILENAME
- conformance_path = _Path(ws_root) / WORKSPACE_DATA_DIR / CONFORMANCE_FILENAME
- enricher = CrossRepoEnricher(
- cross_repo_path,
- contracts_path=contracts_path,
- system_graph_path=system_graph_path,
- breaking_changes_path=breaking_changes_path,
- conformance_path=conformance_path,
- )
- if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:
- app.state.cross_repo_enricher = enricher
- set_tool_workspace(cross_repo_enricher=enricher)
- logger.info(
- "repowise_workspace_detected",
- extra={
- "repos": len(ws_config.repos),
- "co_changes": len(getattr(enricher, "_co_changes", [])),
- "contract_links": len(getattr(enricher, "_contract_links", [])),
- },
- )
- else:
- logger.info("repowise_workspace_detected", extra={"repos": len(ws_config.repos)})
- except Exception:
- logger.debug("Workspace detection skipped", exc_info=True)
-
- # Re-register per-repo databases for repos added via the API (their data
- # lives in <repo>/.repowise/wiki.db; the primary DB only holds a registry
- # row). Runs after workspace detection so already-registered workspace
- # repos are skipped.
- try:
- from repowise.server.repo_db import rediscover_repo_dbs
+def _cors_settings() -> tuple[list[str], bool]:
+ """``(allowed origins, allow credentials)`` from the environment."""
+ # Browsers reject a wildcard origin with credentials, so credentials need
+ # explicit REPOWISE_CORS_ORIGINS; unset means any origin, no credentials.
+ cors_origins_env = os.environ.get("REPOWISE_CORS_ORIGINS", "").strip()
+ if cors_origins_env:
+ return [o.strip() for o in cors_origins_env.split(",") if o.strip()], True
+ # Warn when the old wildcard-with-credentials setting is still configured.
+ if os.environ.get("REPOWISE_CORS_ALLOW_CREDENTIALS", "").lower() in ("1", "true", "yes"):
+ logger.warning(
+ "cors.wildcard_with_credentials_rejected: "
+ "REPOWISE_CORS_ORIGINS=* cannot be used with credentials; "
+ "set REPOWISE_CORS_ORIGINS to explicit origins"
+ )
+ return ["*"], False
- rediscovered = await rediscover_repo_dbs(app.state)
- if rediscovered:
- logger.info("repo_dbs_rediscovered", extra={"count": rediscovered})
- # Jobs interrupted by the restart live in those per-repo DBs; the
- # earlier resets only covered the primary and workspace DBs.
- stale = await reset_workspace_stale_jobs(app.state)
- if stale:
- logger.warning("reset_stale_jobs", extra={"count": stale})
- except Exception:
- logger.debug("repo_db_rediscovery_skipped", exc_info=True)
- logger.info("repowise_server_started", extra={"version": __version__})
- try:
- yield
- finally:
- # Shutdown. The finally matters for the workspace globals below: they
- # outlive the app object, so skipping this on a shutdown exception
- # would leave the tool layer pointing at disposed engines.
- scheduler.shutdown(wait=False)
- with suppress(Exception):
- await vector_store.close()
- # Close cached per-repo vector stores (LanceDB connections).
- try:
- from repowise.server.search_helpers import close_workspace_vector_stores
-
- await close_workspace_vector_stores(app)
- except Exception:
- logger.debug("workspace_vector_store_close_failed", exc_info=True)
- # Release the per-repo contexts the chat tools resolved through
- _repo_registry = getattr(app.state, "repo_registry", None)
- if _repo_registry is not None:
- with suppress(Exception):
- await _repo_registry.close()
- # The enricher is only ever published alongside the registry.
- set_tool_workspace(registry=None, workspace_root=None, cross_repo_enricher=None)
- # The test-impact join holds its own session per consumer repo.
- from repowise.server.mcp_server._test_impact import close_test_impact_indexes
-
- with suppress(Exception):
- await close_test_impact_indexes()
- # Dispose workspace repo engines first
- for ws_engine in getattr(app.state, "workspace_engines", []):
- with suppress(Exception):
- await ws_engine.dispose()
- await engine.dispose()
- logger.info("repowise_server_stopped")
+# Registration order is route precedence: a literal path must be registered
+# before a parameterised one that would otherwise match it.
+_ROUTERS = (
+ health,
+ repos,
+ pages,
+ search,
+ jobs,
+ symbols,
+ graph,
+ c4,
+ webhooks,
+ git,
+ dead_code,
+ doc_drift,
+ code_health,
+ coupling,
+ claude_md,
+ decisions,
+ episodes,
+ chat,
+ providers,
+ mcp,
+ meta,
+ costs,
+ security,
+ blast_radius,
+ refactoring,
+ knowledge_map,
+ workspace,
+ owners,
+ modules,
+ overview,
+ stats,
+ files,
+ external_systems,
+ feedback,
+)
def create_app() -> FastAPI:
@@ -526,27 +398,7 @@ def create_app() -> FastAPI:
lifespan=lifespan,
)
- # CORS — configurable; default allows local dev but is browser-spec compliant.
- # Browsers reject `Access-Control-Allow-Origin: *` with `Allow-Credentials: true`
- # (preflight fails). When REPOWISE_CORS_ORIGINS is unset we allow any origin
- # without credentials (safe for local dev); when credentials are needed the
- # operator must set explicit origins via REPOWISE_CORS_ORIGINS.
- cors_origins_env = os.environ.get("REPOWISE_CORS_ORIGINS", "").strip()
- if cors_origins_env:
- cors_origins = [o.strip() for o in cors_origins_env.split(",") if o.strip()]
- cors_allow_credentials = True
- else:
- cors_origins = ["*"]
- cors_allow_credentials = False
- # Wildcard with credentials is rejected by browsers — force False and warn
- # if the old unsafe combination is detected via explicit env.
- if os.environ.get("REPOWISE_CORS_ALLOW_CREDENTIALS", "").lower() in ("1", "true", "yes"):
- logger.warning(
- "cors.wildcard_with_credentials_rejected: "
- "REPOWISE_CORS_ORIGINS=* cannot be used with credentials; "
- "set REPOWISE_CORS_ORIGINS to explicit origins"
- )
-
+ cors_origins, cors_allow_credentials = _cors_settings()
app.add_middleware(
CORSMiddleware,
allow_origins=cors_origins,
@@ -565,39 +417,7 @@ def create_app() -> FastAPI:
return JSONResponse(status_code=400, content={"detail": str(exc)})
# Include routers
- app.include_router(health.router)
- app.include_router(repos.router)
- app.include_router(pages.router)
- app.include_router(search.router)
- app.include_router(jobs.router)
- app.include_router(symbols.router)
- app.include_router(graph.router)
- app.include_router(c4.router)
- app.include_router(webhooks.router)
- app.include_router(git.router)
- app.include_router(dead_code.router)
- app.include_router(doc_drift.router)
- app.include_router(code_health.router)
- app.include_router(coupling.router)
- app.include_router(claude_md.router)
- app.include_router(decisions.router)
- app.include_router(episodes.router)
- app.include_router(chat.router)
- app.include_router(providers.router)
- app.include_router(mcp.router)
- app.include_router(meta.router)
- app.include_router(costs.router)
- app.include_router(security.router)
- app.include_router(blast_radius.router)
- app.include_router(refactoring.router)
- app.include_router(knowledge_map.router)
- app.include_router(workspace.router)
- app.include_router(owners.router)
- app.include_router(modules.router)
- app.include_router(overview.router)
- app.include_router(stats.router)
- app.include_router(files.router)
- app.include_router(external_systems.router)
- app.include_router(feedback.router)
+ for router_module in _ROUTERS:
+ app.include_router(router_module.router)
return app
diff --git a/packages/server/src/repowise/server/workspace_startup.py b/packages/server/src/repowise/server/workspace_startup.py
new file mode 100644
index 000000000..bec55af38
--- /dev/null
+++ b/packages/server/src/repowise/server/workspace_startup.py
@@ -0,0 +1,270 @@
+"""Server-startup wiring for a detected workspace: member databases, the chat
+tools' registry and cross-repo enricher, and interrupted-job cleanup.
+``app.lifespan`` sequences these steps.
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import update as sa_update
+
+from repowise.core.persistence.database import (
+ create_engine,
+ create_session_factory,
+ get_session,
+ init_db,
+)
+from repowise.core.persistence.models import GenerationJob
+from repowise.core.persistence.search import FullTextSearch
+
+# Startup events keep the app logger's name, so log filters written against
+# ``repowise.server.app`` still see them.
+logger = logging.getLogger("repowise.server.app")
+
+
+async def fail_interrupted_jobs(session_factory: Any, message: str) -> int:
+ """Mark every pending/running job in one database failed; return how many."""
+ async with get_session(session_factory) as session:
+ stale_result = await session.execute(
+ sa_update(GenerationJob)
+ .where(GenerationJob.status.in_(["running", "pending"]))
+ .values(
+ status="failed",
+ error_message=message,
+ finished_at=datetime.now(UTC),
+ )
+ )
+ return stale_result.rowcount or 0
+
+
+async def reset_workspace_stale_jobs(app_state) -> int:
+ """Mark interrupted pending/running jobs failed across workspace repo DBs."""
+ reset_count = 0
+ for ws_factory in getattr(app_state, "workspace_sessions", {}).values():
+ reset_count += await fail_interrupted_jobs(
+ ws_factory, "Server restarted; job interrupted"
+ )
+ return reset_count
+
+
+def workspace_primary_db_url() -> str | None:
+ """The primary workspace member's ``wiki.db`` URL, when there is one on disk."""
+ try:
+ from repowise.core.workspace.config import WorkspaceConfig, find_workspace_root
+
+ _ws_root = find_workspace_root()
+ if _ws_root is not None:
+ _ws_cfg = WorkspaceConfig.load(_ws_root)
+ _primary = _ws_cfg.get_primary()
+ _primary_path = _ws_root / (_primary.path if _primary else ".")
+ _primary_db = (_primary_path / ".repowise" / "wiki.db").resolve()
+ if _primary_db.exists():
+ logger.info("workspace_primary_db", extra={"db": str(_primary_db)})
+ return f"sqlite+aiosqlite:///{_primary_db.as_posix()}"
+ except Exception:
+ pass # Fall back to default
+ return None
+
+
+def init_workspace_state(app_state, vector_store, primary_vector_repo_id: str | None) -> None:
+ """Workspace slots on app state, empty until a workspace is detected."""
+ # Mirrors the MCP server's ``_detect_workspace``.
+ app_state.workspace_config = None
+ app_state.workspace_root = None
+ app_state.cross_repo_enricher = None
+ app_state.repo_registry = None # RepoRegistry, workspace mode only
+ app_state.workspace_sessions = {} # repo_id → session_factory
+ app_state.workspace_path_to_repo_id = {} # local_path → repo_id
+ app_state.workspace_engines = [] # engines to dispose on shutdown
+ # Search fans out across these; the primary stays on app.state.fts.
+ app_state.workspace_fts = {} # repo_id → FullTextSearch
+ # Filled lazily by the search router.
+ app_state.workspace_vector_stores = {} # repo_id → VectorStore
+ if primary_vector_repo_id is not None:
+ app_state.workspace_vector_stores[primary_vector_repo_id] = vector_store
+
+
+async def _map_shared_db_members(app_state, ws_config, ws_root: Path, session_factory, fts) -> None:
+ # Shared database (e.g. PostgreSQL): members have no per-repo wiki.db.
+ from repowise.core.persistence.crud import get_repository_by_path
+
+ async with get_session(session_factory) as session:
+ for repo_entry in ws_config.repos:
+ repo_path = (ws_root / repo_entry.path).resolve()
+ try:
+ repo = await get_repository_by_path(session, str(repo_path))
+ if repo is not None:
+ app_state.workspace_sessions[repo.id] = session_factory
+ app_state.workspace_fts[repo.id] = fts
+ app_state.workspace_path_to_repo_id[str(repo_path)] = repo.id
+ except Exception:
+ logger.debug(
+ "workspace_shared_db_repo_lookup_failed",
+ extra={"path": str(repo_path)},
+ exc_info=True,
+ )
+
+
+def _read_repo_row(repo_db: Path) -> tuple | None:
+ """The ``(id,)`` row a member's ``wiki.db`` holds, or None when there is none."""
+ # Read repo_id from this DB
+ try:
+ conn = sqlite3.connect(str(repo_db))
+ row = conn.execute("SELECT id FROM repositories LIMIT 1").fetchone()
+ conn.close()
+ except Exception:
+ return None
+ return row or None
+
+
+async def _open_member_db(app_state, repo_id: str, repo_db: Path) -> None:
+ repo_engine = create_engine(f"sqlite+aiosqlite:///{repo_db.as_posix()}")
+ await init_db(repo_engine)
+ repo_sf = create_session_factory(repo_engine)
+ app_state.workspace_sessions[repo_id] = repo_sf
+ app_state.workspace_engines.append(repo_engine)
+
+ # Per-repo FTS, or full-text search only ever sees the primary DB.
+ try:
+ repo_fts = FullTextSearch(repo_engine)
+ await repo_fts.ensure_index()
+ app_state.workspace_fts[repo_id] = repo_fts
+ except Exception:
+ logger.debug(
+ "workspace_fts_init_failed",
+ extra={"repo_id": repo_id},
+ exc_info=True,
+ )
+
+
+async def _open_member_dbs(app_state, ws_config, ws_root: Path, fts, db_url: str) -> None:
+ for repo_entry in ws_config.repos:
+ repo_path = (ws_root / repo_entry.path).resolve()
+ repo_db = repo_path / ".repowise" / "wiki.db"
+ if not repo_db.exists():
+ continue
+ row = _read_repo_row(repo_db)
+ if row is None:
+ continue
+ repo_id = row[0]
+ app_state.workspace_path_to_repo_id[str(repo_path)] = repo_id
+
+ # The main engine already serves the primary; only register its FTS.
+ if db_url and repo_db.as_posix() in db_url.replace("\\", "/"):
+ app_state.workspace_fts[repo_id] = fts
+ continue
+
+ await _open_member_db(app_state, repo_id, repo_db)
+
+
+def _publish_registry(
+ app_state, ws_config, ws_root: Path, embedder_factory: Callable[[], Any]
+) -> None:
+ # Without a registry, chat tools resolve every alias against the primary
+ # wiki.db and fail. It holds its own lazily opened per-repo handles,
+ # separate from workspace_sessions (merging the two is a known TODO).
+ from repowise.core.workspace.registry import RepoRegistry
+ from repowise.server.chat_tools import set_tool_workspace
+
+ repo_registry = RepoRegistry(
+ workspace_root=ws_root,
+ ws_config=ws_config,
+ embedder_factory=embedder_factory,
+ )
+ app_state.repo_registry = repo_registry
+ set_tool_workspace(registry=repo_registry, workspace_root=str(ws_root))
+
+
+async def _reset_member_stale_jobs(app_state) -> None:
+ # Each member has its own generation_jobs table; the primary was reset earlier.
+ try:
+ reset_count = await reset_workspace_stale_jobs(app_state)
+ if reset_count:
+ logger.warning(
+ "reset_workspace_stale_jobs",
+ extra={"count": reset_count},
+ )
+ except Exception as exc:
+ logger.warning("workspace_stale_job_reset_failed", extra={"error": str(exc)})
+
+
+def _publish_cross_repo_enricher(app_state, ws_config, ws_root: Path) -> None:
+ from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME
+ from repowise.core.workspace.config import WORKSPACE_DATA_DIR
+ from repowise.core.workspace.conformance import CONFORMANCE_FILENAME
+ from repowise.core.workspace.contracts import CONTRACTS_FILENAME
+ from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
+ from repowise.server.chat_tools import set_tool_workspace
+ from repowise.server.mcp_server._enrichment import CrossRepoEnricher
+
+ data_dir = ws_root / WORKSPACE_DATA_DIR
+ enricher = CrossRepoEnricher(
+ data_dir / "cross_repo_edges.json",
+ contracts_path=data_dir / CONTRACTS_FILENAME,
+ system_graph_path=data_dir / SYSTEM_GRAPH_FILENAME,
+ breaking_changes_path=data_dir / BREAKING_CHANGES_FILENAME,
+ conformance_path=data_dir / CONFORMANCE_FILENAME,
+ )
+ if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:
+ app_state.cross_repo_enricher = enricher
+ set_tool_workspace(cross_repo_enricher=enricher)
+ logger.info(
+ "repowise_workspace_detected",
+ extra={
+ "repos": len(ws_config.repos),
+ "co_changes": len(getattr(enricher, "_co_changes", [])),
+ "contract_links": len(getattr(enricher, "_contract_links", [])),
+ },
+ )
+ else:
+ logger.info("repowise_workspace_detected", extra={"repos": len(ws_config.repos)})
+
+
+async def attach_workspace(
+ app_state,
+ *,
+ session_factory,
+ fts,
+ db_url: str,
+ embedder_factory: Callable[[], Any],
+) -> None:
+ """Detect a workspace around the cwd and wire its members into app state.
+
+ Outside a workspace this does nothing. Any failure leaves the server in
+ single-repo mode rather than failing startup.
+ """
+ try:
+ from repowise.core.workspace.config import WorkspaceConfig, find_workspace_root
+
+ ws_root = find_workspace_root()
+ if ws_root is None:
+ return
+ ws_config = WorkspaceConfig.load(ws_root)
+ app_state.workspace_config = ws_config
+ app_state.workspace_root = str(ws_root)
+ ws_root_path = Path(ws_root)
+
+ from repowise.core.persistence.database import get_configured_db_url
+
+ if get_configured_db_url() is not None:
+ await _map_shared_db_members(app_state, ws_config, ws_root_path, session_factory, fts)
+ else:
+ await _open_member_dbs(app_state, ws_config, ws_root_path, fts, db_url)
+
+ if app_state.workspace_sessions:
+ logger.info(
+ "workspace_repo_dbs_loaded",
+ extra={"count": len(app_state.workspace_sessions)},
+ )
+
+ _publish_registry(app_state, ws_config, ws_root_path, embedder_factory)
+ await _reset_member_stale_jobs(app_state)
+ _publish_cross_repo_enricher(app_state, ws_config, ws_root_path)
+ except Exception:
+ logger.debug("Workspace detection skipped", exc_info=True)
diff --git a/tests/unit/server/test_app_lifespan.py b/tests/unit/server/test_app_lifespan.py
new file mode 100644
index 000000000..0bc6149f4
--- /dev/null
+++ b/tests/unit/server/test_app_lifespan.py
@@ -0,0 +1,696 @@
+"""Startup and shutdown of the HTTP server, step by step.
+
+Real SQLite files, with only the scheduler and primary vector store stubbed.
+Failures come through data or a step's one collaborator, not its location.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import FastAPI
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+import repowise.server.mcp_server as mcp_mod
+from repowise.core.persistence.database import init_db
+from repowise.core.persistence.models import GenerationJob, Repository
+from repowise.core.persistence.search import FullTextSearch
+from repowise.core.workspace.config import WORKSPACE_DATA_DIR
+from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
+from repowise.server.app import create_app, lifespan
+
+_NOW = datetime(2026, 7, 21, 10, 0, 0, tzinfo=UTC)
+_PRIMARY_RESET = "Server restarted — job interrupted"
+_MEMBER_RESET = "Server restarted; job interrupted"
+
+
[email protected](autouse=True)
+def restore_tool_globals():
+ """The real lifespan writes process-global MCP tool state; put it back."""
+ saved = (
+ mcp_mod._registry,
+ mcp_mod._workspace_root,
+ mcp_mod._cross_repo_enricher,
+ mcp_mod._session_factory,
+ mcp_mod._fts,
+ mcp_mod._vector_store,
+ )
+ yield
+ (
+ mcp_mod._registry,
+ mcp_mod._workspace_root,
+ mcp_mod._cross_repo_enricher,
+ mcp_mod._session_factory,
+ mcp_mod._fts,
+ mcp_mod._vector_store,
+ ) = saved
+
+
[email protected](autouse=True)
+def live_server_loggers():
+ """Other tests leave ``repowise.*`` loggers disabled (Alembic's ``fileConfig``)
+ or raised to ERROR (CLI log silencing); undo both for the test's duration."""
+ saved = []
+ for name, logger in list(logging.root.manager.loggerDict.items()):
+ if name.startswith("repowise") and isinstance(logger, logging.Logger):
+ saved.append((logger, logger.disabled, logger.level))
+ logger.disabled = False
+ logger.setLevel(logging.NOTSET)
+ yield
+ for logger, disabled, level in saved:
+ logger.disabled = disabled
+ logger.setLevel(level)
+
+
+def env(tmp_path, monkeypatch):
+ """No configured DB, no embedder, a private home, and cwd inside tmp_path."""
+ for key in ("REPOWISE_DB_URL", "REPOWISE_DATABASE_URL", "REPOWISE_EMBEDDER"):
+ monkeypatch.delenv(key, raising=False)
+ monkeypatch.setenv("HOME", str(tmp_path / "home"))
+ monkeypatch.setenv("USERPROFILE", str(tmp_path / "home"))
+ monkeypatch.chdir(tmp_path)
+ return tmp_path
+
+
+def stubs():
+ """The scheduler and the primary vector store, the two heavy collaborators."""
+ scheduler = MagicMock()
+ vector_store = SimpleNamespace(close=AsyncMock())
+ with (
+ patch("repowise.server.app.setup_scheduler", return_value=scheduler) as setup,
+ patch(
+ "repowise.server.search_helpers.build_primary_vector_store",
+ new=AsyncMock(return_value=(vector_store, None)),
+ ) as build_store,
+ ):
+ yield SimpleNamespace(
+ scheduler=scheduler,
+ setup=setup,
+ vector_store=vector_store,
+ build_store=build_store,
+ )
+
+
+async def _make_db(
+ db: Path, repo_id: str, local_path: Path, job_statuses: tuple[str, ...] = ()
+) -> None:
+ """A wiki.db holding one repository row and the given generation jobs."""
+ db.parent.mkdir(parents=True, exist_ok=True)
+ engine = create_async_engine(f"sqlite+aiosqlite:///{db.as_posix()}")
+ await init_db(engine)
+ factory = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
+ async with factory() as session:
+ session.add(
+ Repository(
+ id=repo_id,
+ name=local_path.name,
+ url="",
+ local_path=str(local_path.resolve()),
+ default_branch="main",
+ settings_json="{}",
+ created_at=_NOW,
+ updated_at=_NOW,
+ )
+ )
+ for i, status in enumerate(job_statuses):
+ session.add(
+ GenerationJob(id=f"{repo_id}-job{i}", repository_id=repo_id, status=status)
+ )
+ await session.commit()
+ await engine.dispose()
+
+
+def _jobs(db: Path) -> list[tuple[str, str | None]]:
+ with sqlite3.connect(str(db)) as conn:
+ return conn.execute(
+ "SELECT status, error_message FROM generation_jobs ORDER BY id"
+ ).fetchall()
+
+
+def _refuse_job_updates(db: Path) -> None:
+ with sqlite3.connect(str(db)) as conn:
+ conn.execute(
+ "CREATE TRIGGER no_job_updates BEFORE UPDATE ON generation_jobs "
+ "BEGIN SELECT RAISE(ABORT, 'read only'); END;"
+ )
+
+
+def _write_workspace(root: Path, members: list[tuple[str, bool]]) -> None:
+ lines = ["version: 1", f"default_repo: {members[0][0]}", "repos:"]
+ for alias, primary in members:
+ lines.append(f"- path: {alias}")
+ lines.append(f" alias: {alias}")
+ if primary:
+ lines.append(" is_primary: true")
+ (root / ".repowise-workspace.yaml").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Single-repo mode
+# ---------------------------------------------------------------------------
+
+
+async def test_single_repo_startup_publishes_state_and_resets_jobs(env, stubs, monkeypatch):
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p", ("completed", "pending", "running"))
+ db_url = f"sqlite+aiosqlite:///{db.as_posix()}"
+ monkeypatch.setenv("REPOWISE_DB_URL", db_url)
+
+ app = FastAPI()
+ async with lifespan(app):
+ state = app.state
+ assert state.db_url == db_url
+ assert state.session_factory is not None
+ assert isinstance(state.fts, FullTextSearch)
+ assert state.vector_store is stubs.vector_store
+ assert state.primary_vector_repo_id is None
+ assert state.background_tasks == set()
+ assert state.job_tasks == {}
+ assert state.job_cancel_tokens == {}
+ assert state.job_events == {}
+ assert state.scheduler is stubs.scheduler
+ stubs.setup.assert_called_once_with(state.session_factory, app_state=state)
+ stubs.scheduler.start.assert_called_once_with()
+ # Workspace slots exist and are empty outside a workspace.
+ assert state.workspace_config is None
+ assert state.workspace_root is None
+ assert state.cross_repo_enricher is None
+ assert state.repo_registry is None
+ assert state.workspace_sessions == {}
+ assert state.workspace_path_to_repo_id == {}
+ assert state.workspace_engines == []
+ assert state.workspace_fts == {}
+ assert state.workspace_vector_stores == {}
+ # The chat tools see the same stores.
+ assert mcp_mod._session_factory is state.session_factory
+ assert mcp_mod._fts is state.fts
+ assert mcp_mod._vector_store is stubs.vector_store
+ # Interrupted jobs are failed before the first request.
+ assert _jobs(db) == [
+ ("completed", None),
+ ("failed", _PRIMARY_RESET),
+ ("failed", _PRIMARY_RESET),
+ ]
+ stubs.scheduler.shutdown.assert_not_called()
+
+ stubs.scheduler.shutdown.assert_called_once_with(wait=False)
+ stubs.vector_store.close.assert_awaited_once()
+
+
+async def test_primary_vector_store_is_cached_under_its_repo(env, stubs, monkeypatch):
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p")
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+ stubs.build_store.return_value = (stubs.vector_store, "p-id")
+
+ app = FastAPI()
+ async with lifespan(app):
+ assert app.state.primary_vector_repo_id == "p-id"
+ assert app.state.workspace_vector_stores == {"p-id": stubs.vector_store}
+
+
+async def test_optional_steps_fail_without_stopping_startup(env, stubs, monkeypatch, caplog):
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p", ("running",))
+ _refuse_job_updates(db)
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+ stubs.vector_store.close.side_effect = RuntimeError("already closed")
+
+ app = FastAPI()
+ with (
+ caplog.at_level(logging.DEBUG),
+ patch.object(
+ FullTextSearch, "ensure_index", new=AsyncMock(side_effect=RuntimeError("fts5"))
+ ),
+ patch(
+ "repowise.server.search_helpers.close_workspace_vector_stores",
+ new=AsyncMock(side_effect=RuntimeError("lance")),
+ ),
+ ):
+ async with lifespan(app):
+ assert isinstance(app.state.fts, FullTextSearch)
+ assert _jobs(db) == [("running", None)]
+
+ events = {r.getMessage() for r in caplog.records}
+ assert {"stale_job_reset_failed", "fts_ensure_index_failed"} <= events
+ assert "workspace_vector_store_close_failed" in events
+ assert "repowise_server_stopped" in events
+
+
+async def test_shutdown_runs_when_the_app_body_raises(env, stubs, monkeypatch):
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p")
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+
+ app = FastAPI()
+ with pytest.raises(RuntimeError, match="request crashed"):
+ async with lifespan(app):
+ raise RuntimeError("request crashed")
+
+ stubs.scheduler.shutdown.assert_called_once_with(wait=False)
+ stubs.vector_store.close.assert_awaited_once()
+
+
+# ---------------------------------------------------------------------------
+# Workspace mode, repo-local databases
+# ---------------------------------------------------------------------------
+
+
+async def test_workspace_startup_opens_member_databases(env, stubs, caplog):
+ _write_workspace(
+ env,
+ [("boot", True), ("api", False), ("nodb", False), ("empty", False), ("junk", False)],
+ )
+ boot_db = env / "boot" / ".repowise" / "wiki.db"
+ api_db = env / "api" / ".repowise" / "wiki.db"
+ await _make_db(boot_db, "boot-id", env / "boot", ("running",))
+ await _make_db(api_db, "api-id", env / "api", ("pending", "completed"))
+ (env / "nodb").mkdir()
+ # A member whose wiki.db has no repository row, and one that is not SQLite.
+ empty_db = env / "empty" / ".repowise" / "wiki.db"
+ empty_db.parent.mkdir(parents=True)
+ with sqlite3.connect(str(empty_db)) as conn:
+ conn.execute("CREATE TABLE repositories (id TEXT)")
+ junk_db = env / "junk" / ".repowise" / "wiki.db"
+ junk_db.parent.mkdir(parents=True)
+ junk_db.write_bytes(b"not a database at all")
+ (env / WORKSPACE_DATA_DIR).mkdir()
+ (env / WORKSPACE_DATA_DIR / SYSTEM_GRAPH_FILENAME).write_text(
+ json.dumps({"nodes": [], "edges": []}), encoding="utf-8"
+ )
+
+ app = FastAPI()
+ with caplog.at_level(logging.INFO):
+ async with lifespan(app):
+ state = app.state
+ # The primary member's wiki.db becomes the server database.
+ assert state.db_url == f"sqlite+aiosqlite:///{boot_db.resolve().as_posix()}"
+ assert state.workspace_config is not None
+ assert state.workspace_root == str(env.resolve())
+ # The primary is served by the main engine: FTS registered, no session.
+ assert set(state.workspace_sessions) == {"api-id"}
+ assert state.workspace_fts["boot-id"] is state.fts
+ assert isinstance(state.workspace_fts["api-id"], FullTextSearch)
+ assert state.workspace_fts["api-id"] is not state.fts
+ assert len(state.workspace_engines) == 1
+ assert state.workspace_path_to_repo_id == {
+ str((env / "boot").resolve()): "boot-id",
+ str((env / "api").resolve()): "api-id",
+ }
+ assert state.repo_registry is not None
+ assert mcp_mod._registry is state.repo_registry
+ assert mcp_mod._workspace_root == str(env.resolve())
+ # A system graph alone is enough to publish the enricher.
+ assert state.cross_repo_enricher is not None
+ assert mcp_mod._cross_repo_enricher is state.cross_repo_enricher
+ assert _jobs(boot_db) == [("failed", _PRIMARY_RESET)]
+ assert _jobs(api_db) == [("failed", _MEMBER_RESET), ("completed", None)]
+
+ events = [r.getMessage() for r in caplog.records]
+ assert "workspace_primary_db" in events
+ assert "workspace_repo_dbs_loaded" in events
+ assert "repowise_workspace_detected" in events
+ # Shutdown unpublishes the workspace from the tool layer.
+ assert mcp_mod._registry is None
+ assert mcp_mod._workspace_root is None
+ assert mcp_mod._cross_repo_enricher is None
+
+
+async def test_workspace_without_cross_repo_artifacts_publishes_no_enricher(env, stubs):
+ _write_workspace(env, [("boot", True)])
+ await _make_db(env / "boot" / ".repowise" / "wiki.db", "boot-id", env / "boot")
+
+ app = FastAPI()
+ async with lifespan(app):
+ assert app.state.workspace_config is not None
+ assert app.state.cross_repo_enricher is None
+ assert app.state.workspace_sessions == {}
+
+
+async def test_member_job_reset_and_fts_failures_are_contained(env, stubs, caplog):
+ _write_workspace(env, [("boot", True), ("api", False)])
+ await _make_db(env / "boot" / ".repowise" / "wiki.db", "boot-id", env / "boot")
+ api_db = env / "api" / ".repowise" / "wiki.db"
+ await _make_db(api_db, "api-id", env / "api", ("running",))
+ _refuse_job_updates(api_db)
+
+ real_ensure = FullTextSearch.ensure_index
+ primary_fts: list[FullTextSearch] = []
+
+ async def member_fts_fails(self):
+ if not primary_fts:
+ primary_fts.append(self)
+ return await real_ensure(self)
+ raise RuntimeError("member fts")
+
+ app = FastAPI()
+ with (
+ caplog.at_level(logging.DEBUG),
+ patch.object(FullTextSearch, "ensure_index", new=member_fts_fails),
+ ):
+ async with lifespan(app):
+ # The member's engine still routes; only its keyword index is absent.
+ assert "api-id" in app.state.workspace_sessions
+ assert "api-id" not in app.state.workspace_fts
+ assert _jobs(api_db) == [("running", None)]
+
+ events = {r.getMessage() for r in caplog.records}
+ assert {"workspace_fts_init_failed", "workspace_stale_job_reset_failed"} <= events
+
+
+async def test_malformed_workspace_file_falls_back_to_single_repo(env, stubs, caplog, monkeypatch):
+ (env / ".repowise-workspace.yaml").write_text("repos: [unclosed\n", encoding="utf-8")
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p")
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+
+ app = FastAPI()
+ with caplog.at_level(logging.DEBUG):
+ async with lifespan(app):
+ assert app.state.workspace_config is None
+ assert app.state.repo_registry is None
+ assert app.state.workspace_sessions == {}
+
+ assert "Workspace detection skipped" in {r.getMessage() for r in caplog.records}
+
+
+async def test_malformed_workspace_file_keeps_the_default_database(env, stubs):
+ (env / ".repowise-workspace.yaml").write_text("repos: [unclosed\n", encoding="utf-8")
+
+ app = FastAPI()
+ async with lifespan(app):
+ expected = (env / "home" / ".repowise" / "wiki.db").as_posix()
+ assert app.state.db_url == f"sqlite+aiosqlite:///{expected}"
+
+
+# ---------------------------------------------------------------------------
+# Workspace mode, one shared database
+# ---------------------------------------------------------------------------
+
+
+async def test_shared_database_registers_members_and_skips_failed_lookups(
+ env, stubs, monkeypatch, caplog
+):
+ _write_workspace(env, [("a", True), ("b", False), ("c", False)])
+ for alias in ("a", "b", "c"):
+ (env / alias).mkdir()
+ db = env / "shared.db"
+ await _make_db(db, "a-id", env / "a")
+ engine = create_async_engine(f"sqlite+aiosqlite:///{db.as_posix()}")
+ factory = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
+ async with factory() as session:
+ session.add(
+ Repository(
+ id="c-id",
+ name="c",
+ url="",
+ local_path=str((env / "c").resolve()),
+ default_branch="main",
+ settings_json="{}",
+ created_at=_NOW,
+ updated_at=_NOW,
+ )
+ )
+ await session.commit()
+ await engine.dispose()
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+
+ from repowise.core.persistence import crud
+
+ real_lookup = crud.get_repository_by_path
+
+ async def flaky_lookup(session, path):
+ if path.endswith("c"):
+ raise RuntimeError("lookup failed")
+ return await real_lookup(session, path)
+
+ app = FastAPI()
+ with (
+ caplog.at_level(logging.DEBUG),
+ patch("repowise.core.persistence.crud.get_repository_by_path", new=flaky_lookup),
+ ):
+ async with lifespan(app):
+ state = app.state
+ assert state.workspace_sessions == {"a-id": state.session_factory}
+ assert state.workspace_fts == {"a-id": state.fts}
+ assert state.workspace_path_to_repo_id == {str((env / "a").resolve()): "a-id"}
+ assert state.workspace_engines == []
+
+ assert "workspace_shared_db_repo_lookup_failed" in {r.getMessage() for r in caplog.records}
+
+
+# ---------------------------------------------------------------------------
+# API-registered repositories outside any workspace
+# ---------------------------------------------------------------------------
+
+
+async def test_registered_repo_databases_are_rediscovered_and_reset(env, stubs, caplog):
+ _write_workspace(env, [("boot", True)])
+ boot_db = env / "boot" / ".repowise" / "wiki.db"
+ await _make_db(boot_db, "boot-id", env / "boot")
+ added = env / "added"
+ added_db = added / ".repowise" / "wiki.db"
+ await _make_db(added_db, "added-id", added, ("pending",))
+ # The primary database's registry row for the repo added over the API.
+ engine = create_async_engine(f"sqlite+aiosqlite:///{boot_db.as_posix()}")
+ factory = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
+ async with factory() as session:
+ session.add(
+ Repository(
+ id="added-id",
+ name="added",
+ url="",
+ local_path=str(added.resolve()),
+ default_branch="main",
+ settings_json="{}",
+ created_at=_NOW,
+ updated_at=_NOW,
+ )
+ )
+ await session.commit()
+ await engine.dispose()
+
+ app = FastAPI()
+ with caplog.at_level(logging.INFO):
+ async with lifespan(app):
+ assert "added-id" in app.state.workspace_sessions
+ assert _jobs(added_db) == [("failed", _MEMBER_RESET)]
+
+ events = [r.getMessage() for r in caplog.records]
+ assert "repo_dbs_rediscovered" in events
+ assert "reset_stale_jobs" in events
+
+
+async def test_rediscovery_failure_is_contained(env, stubs, monkeypatch, caplog):
+ db = env / "primary.db"
+ await _make_db(db, "p-id", env / "p")
+ monkeypatch.setenv("REPOWISE_DB_URL", f"sqlite+aiosqlite:///{db.as_posix()}")
+
+ app = FastAPI()
+ with (
+ caplog.at_level(logging.DEBUG),
+ patch(
+ "repowise.server.repo_db.rediscover_repo_dbs",
+ new=AsyncMock(side_effect=RuntimeError("registry unreadable")),
+ ),
+ ):
+ async with lifespan(app):
+ pass
+
+ assert "repo_db_rediscovery_skipped" in {r.getMessage() for r in caplog.records}
+
+
+async def test_shutdown_closes_the_registry_and_member_engines(env, stubs):
+ _write_workspace(env, [("boot", True), ("api", False)])
+ await _make_db(env / "boot" / ".repowise" / "wiki.db", "boot-id", env / "boot")
+ await _make_db(env / "api" / ".repowise" / "wiki.db", "api-id", env / "api")
+
+ from sqlalchemy.ext.asyncio import AsyncEngine
+
+ disposed: list[AsyncEngine] = []
+ real_dispose = AsyncEngine.dispose
+
+ async def recording_dispose(self, close: bool = True) -> None:
+ disposed.append(self)
+ await real_dispose(self, close)
+
+ app = FastAPI()
+ with (
+ patch(
+ "repowise.server.mcp_server._test_impact.close_test_impact_indexes", new=AsyncMock()
+ ) as close_impact,
+ patch.object(AsyncEngine, "dispose", new=recording_dispose),
+ ):
+ async with lifespan(app):
+ registry = app.state.repo_registry
+ registry.close = AsyncMock(side_effect=RuntimeError("already closed"))
+ member_engine = app.state.workspace_engines[0]
+ primary_engine = app.state.engine
+ disposed.clear()
+
+ registry.close.assert_awaited_once()
+ close_impact.assert_awaited_once()
+ # Member engines go first; the primary engine is the last thing released.
+ assert disposed[-2:] == [member_engine, primary_engine]
+
+
+# ---------------------------------------------------------------------------
+# _build_embedder
+# ---------------------------------------------------------------------------
+
+
+def embedder_env(monkeypatch):
+ for key in ("REPOWISE_EMBEDDER", "REPOWISE_EMBEDDING_MODEL", "REPOWISE_EMBEDDING_DIMS"):
+ monkeypatch.delenv(key, raising=False)
+ return monkeypatch
+
+
+ ("backend", "target", "model_env", "expected_kwargs"),
+ [
+ ("ollama", "ollama.OllamaEmbedder", None, {}),
+ ("OpenAI", "openai.OpenAIEmbedder", None, {"model": "text-embedding-3-small"}),
+ ("openai", "openai.OpenAIEmbedder", "text-embedding-3-large", {"model": "text-embedding-3-large"}),
+ (
+ "openrouter",
+ "openrouter.OpenRouterEmbedder",
+ None,
+ {"model": "google/gemini-embedding-001"},
+ ),
+ (
+ "edenai",
+ "edenai.EdenAIEmbedder",
+ None,
+ {"model": "amazon/amazon.titan-embed-text-v2:0"},
+ ),
+ ("gemini", "gemini.GeminiEmbedder", None, {"output_dimensionality": 768}),
+ (
+ "gemini",
+ "gemini.GeminiEmbedder",
+ "text-embedding-004",
+ {"model": "text-embedding-004", "output_dimensionality": 768},
+ ),
+ ],
+)
+def test_build_embedder_backends(embedder_env, backend, target, model_env, expected_kwargs):
+ from repowise.server.app import _build_embedder
+
+ embedder_env.setenv("REPOWISE_EMBEDDER", backend)
+ if model_env:
+ embedder_env.setenv("REPOWISE_EMBEDDING_MODEL", model_env)
+ with patch(f"repowise.core.providers.embedding.{target}") as cls:
+ assert _build_embedder() is cls.return_value
+ cls.assert_called_once_with(**expected_kwargs)
+
+
+ ("raw", "dims", "warned"),
+ [("1536", 1536, False), ("0", 768, True), ("-3", 768, True), ("wide", 768, True), ("", 768, False)],
+)
+def test_build_embedder_gemini_dims(embedder_env, capsys, raw, dims, warned):
+ from repowise.server.app import _build_embedder
+
+ embedder_env.setenv("REPOWISE_EMBEDDER", "gemini")
+ embedder_env.setenv("REPOWISE_EMBEDDING_DIMS", raw)
+ with patch("repowise.core.providers.embedding.gemini.GeminiEmbedder") as cls:
+ _build_embedder()
+ cls.assert_called_once_with(output_dimensionality=dims)
+ err = capsys.readouterr().err
+ if warned:
+ assert err == f"REPOWISE_EMBEDDING_DIMS={raw!r} is not a positive integer; using 768.\n"
+ else:
+ assert err == ""
+
+
+def test_build_embedder_defaults_to_keyless_with_a_warning(embedder_env, caplog):
+ from repowise.core.providers.embedding.base import KeylessEmbedder
+ from repowise.server.app import _build_embedder
+
+ with caplog.at_level(logging.WARNING):
+ assert isinstance(_build_embedder(), KeylessEmbedder)
+ assert any(r.getMessage().startswith("embedder.mock_active") for r in caplog.records)
+
+
+# ---------------------------------------------------------------------------
+# create_app
+# ---------------------------------------------------------------------------
+
+
+def _cors(app: FastAPI) -> dict:
+ (mw,) = [m for m in app.user_middleware if m.cls.__name__ == "CORSMiddleware"]
+ return mw.kwargs
+
+
+def test_create_app_cors_defaults_to_any_origin_without_credentials(monkeypatch, caplog):
+ monkeypatch.delenv("REPOWISE_CORS_ORIGINS", raising=False)
+ monkeypatch.setenv("REPOWISE_CORS_ALLOW_CREDENTIALS", "true")
+ with caplog.at_level(logging.WARNING):
+ app = create_app()
+ assert _cors(app) == {
+ "allow_origins": ["*"],
+ "allow_credentials": False,
+ "allow_methods": ["*"],
+ "allow_headers": ["*"],
+ }
+ assert any("cors.wildcard_with_credentials_rejected" in r.getMessage() for r in caplog.records)
+
+
+def test_create_app_cors_explicit_origins_allow_credentials(monkeypatch, caplog):
+ monkeypatch.setenv("REPOWISE_CORS_ORIGINS", " https://a.example , ,https://b.example")
+ with caplog.at_level(logging.WARNING):
+ app = create_app()
+ assert _cors(app)["allow_origins"] == ["https://a.example", "https://b.example"]
+ assert _cors(app)["allow_credentials"] is True
+ assert not any("cors." in r.getMessage() for r in caplog.records)
+
+
+def test_create_app_metadata_and_routes(monkeypatch):
+ from repowise.server import __version__
+
+ monkeypatch.delenv("REPOWISE_CORS_ORIGINS", raising=False)
+ app = create_app()
+ assert app.title == "repowise API"
+ assert app.version == __version__
+ paths = {getattr(r, "path", None) for r in app.routes}
+ assert {"/api/repos", "/api/repos/summary", "/health"} <= paths
+
+
+async def test_create_app_maps_lookup_and_value_errors(monkeypatch):
+ monkeypatch.delenv("REPOWISE_CORS_ORIGINS", raising=False)
+ app = create_app()
+
+ @app.get("/_raise/{kind}")
+ async def _raise(kind: str):
+ raise (LookupError if kind == "lookup" else ValueError)(f"{kind} failed")
+
+ async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
+ missing = await client.get("/_raise/lookup")
+ invalid = await client.get("/_raise/value")
+
+ assert (missing.status_code, missing.json()) == (404, {"detail": "lookup failed"})
+ assert (invalid.status_code, invalid.json()) == (400, {"detail": "value failed"})