Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
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.pyindex 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 loggingimport os+import sysfrom collections.abc import AsyncGeneratorfrom contextlib import asynccontextmanager, suppress-from datetime import UTC, datetimefrom fastapi import FastAPI, Requestfrom fastapi.middleware.cors import CORSMiddlewarefrom fastapi.responses import JSONResponse-from sqlalchemy import update as sa_updatefrom repowise.core.persistence.database import (create_engine,create_session_factory,- get_session,init_db,resolve_db_url,)-from repowise.core.persistence.models import GenerationJobfrom repowise.core.persistence.search import FullTextSearchfrom repowise.core.providers.embedding import is_semantic_embedderfrom 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_stateinit_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 appdiff --git a/packages/server/src/repowise/server/workspace_startup.py b/packages/server/src/repowise/server/workspace_startup.pynew file mode 100644index 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.pynew file mode 100644index 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"})