Function clear_database

agent/src/opentrace_agent/cli/serve.py:580–660

POST /api/clear — drop every node and relationship. Used by the UI's Settings → "Clear Database" button in server mode (Fix #11). Closes the live store, removes the underlying LadybugDB files, then opens a fresh empty store and swaps it back in. The atomic file-repla

(request: Request)

            return JSONResponse(dict(active[0]))

    async def clear_database(request: Request) -> JSONResponse:
        """POST /api/clear — drop every node and relationship.

        Used by the UI's Settings → "Clear Database" button in server
        mode (Fix #11). Closes the live store, removes the underlying
        LadybugDB files, then opens a fresh empty store and swaps it
        back in. The atomic file-replace is simpler and safer than
        iterating every repo through `delete_repo()` — and matches
        the spirit of what the user clicked ("delete everything").

        Refuses while an `/api/index-url` job is running because that
        worker also writes to the on-disk DB; clearing under its feet
        would corrupt the staging swap.
        """
        if db_path is None:
            return _error(503, "Server was started without --db; clear is unavailable")

        # Atomically reserve exclusivity against index-url: check that no job
        # is active AND register a sentinel under the SAME lock acquisition.
        # Without this, a concurrent index-url could pass its own guard
        # between our check and our unlink, then have its pipeline swap a
        # staging DB over the files we're deleting (clear-vs-index TOCTOU).
        # The index-vs-index hole is already closed by index_url's atomic
        # check-and-insert; this extends the same guard to clear.
        clear_job_id = uuid.uuid4().hex
        with index_jobs_lock:
            active = [jid for jid, st in index_jobs.items() if not st.get("done")]
            if active:
                return _error(
                    409,
                    "An index job is currently running — wait for it to finish before clearing the database.",
                )
            index_jobs[clear_job_id] = {
                "jobId": clear_job_id,
                "kind": "clear",
                "phase": "clearing",
                "message": "Clearing database",
                "done": False,
                "error": None,
                "result": None,
                "startedAt": time.time(),
            }

        from pathlib import Path as _Path

        try:
            with store_lock:
                cur = store_ref["store"]
                if cur is not None:
                    try:
                        cur.close()
                    except Exception:
                        logger.warning("Failed to close store cleanly before clear", exc_info=True)
                store_ref["store"] = None

                # Drop the on-disk artifacts. Mirrors what `opentraceai
                # index` does when it swaps staging into place — same set
                # of files to remove. Cleared in this order so a partial