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.

38.1 KB
Raw Blame
"""Tests for the background job executor's exclude-pattern handling.

Server-triggered jobs (web sync, full-resync, workspace sync, webhooks,
scheduler) all route through ``execute_job``. These tests prove that the
repository's ``exclude_patterns`` reach ``run_pipeline`` so excluded paths
are not re-indexed.
"""

from __future__ import annotations

from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch

import pytest

from repowise.core.persistence.crud import (
    get_generation_job,
    update_job_status,
    upsert_generation_job,
    upsert_repository,
)
from repowise.server.job_executor import (
    JobProgressCallback,
    _build_generation_config,
    _incremental_page_regen,
    _plan_incremental_page_regen,
    _repo_exclude_patterns,
    execute_job,
)


def _fake_result() -> SimpleNamespace:
    """Minimal stand-in for a PipelineResult (persist is mocked out)."""
    return SimpleNamespace(
        generated_pages=[],
        parsed_files=[],
        file_count=1,
        symbol_count=2,
    )


async def _seed_repo_and_job(
    session_factory,
    repo_path,
    *,
    settings: dict | None = None,
) -> str:
    """Insert a repo (with settings) + a pending full_resync job; return job_id."""
    async with session_factory() as session:
        repo = await upsert_repository(
            session,
            name="test-repo",
            local_path=str(repo_path),
            settings=settings or {},
        )
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={"mode": "full_resync"},
        )
        await session.commit()
        return job.id


@pytest.mark.asyncio
async def test_execute_job_passes_exclude_patterns_from_settings(session_factory, tmp_path):
    """settings_json exclude_patterns must reach run_pipeline."""
    job_id = await _seed_repo_and_job(
        session_factory,
        tmp_path,
        settings={"exclude_patterns": ["tools/", "node_modules/"]},
    )

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
    ):
        await execute_job(job_id, app_state)

    run_pipeline_mock.assert_awaited_once()
    assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] == [
        "tools/",
        "node_modules/",
    ]


@pytest.mark.asyncio
async def test_execute_job_no_excludes_passes_none(session_factory, tmp_path):
    """With no configured excludes, run_pipeline receives None (not [])."""
    job_id = await _seed_repo_and_job(session_factory, tmp_path, settings={})

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
    ):
        await execute_job(job_id, app_state)

    run_pipeline_mock.assert_awaited_once()
    assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] is None


def test_repo_exclude_patterns_config_yaml_wins_over_stored(tmp_path):
    """config.yaml is the one source; a legacy DB copy cannot re-add a removed pattern."""
    import json

    config_dir = tmp_path / ".repowise"
    config_dir.mkdir()
    (config_dir / "config.yaml").write_text(
        "exclude_patterns:\n  - node_modules/\n  - vendor/\n  - vendor/\n", encoding="utf-8"
    )

    repo = SimpleNamespace(
        settings_json=json.dumps({"exclude_patterns": ["tools/", "node_modules/"]})
    )

    assert _repo_exclude_patterns(repo, str(tmp_path)) == ["node_modules/", "vendor/"]


def test_repo_exclude_patterns_legacy_stored_value_applies_without_config(tmp_path):
    """A repo whose patterns predate config.yaml keeps them until a save moves them."""
    import json

    repo = SimpleNamespace(settings_json=json.dumps({"exclude_patterns": ["tools/"]}))
    assert _repo_exclude_patterns(repo, str(tmp_path)) == ["tools/"]


def test_repo_exclude_patterns_ignores_malformed_sources(tmp_path):
    """Malformed settings_json / missing config are ignored, not fatal."""
    repo = SimpleNamespace(settings_json="{not valid json")
    assert _repo_exclude_patterns(repo, str(tmp_path)) == []


@pytest.mark.asyncio
async def test_execute_job_passes_wiki_style_from_settings(session_factory, tmp_path):
    """The repo's settings wiki_style must reach run_pipeline."""
    job_id = await _seed_repo_and_job(
        session_factory,
        tmp_path,
        settings={"wiki_style": "caveman"},
    )

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
    ):
        await execute_job(job_id, app_state)

    run_pipeline_mock.assert_awaited_once()
    assert run_pipeline_mock.await_args.kwargs["wiki_style"] == "caveman"


def test_repo_wiki_style_config_yaml_precedence(tmp_path):
    """.repowise/config.yaml wins over a legacy DB copy for wiki_style."""
    import json

    from repowise.server.job_executor import _repo_wiki_style

    config_dir = tmp_path / ".repowise"
    config_dir.mkdir()
    (config_dir / "config.yaml").write_text("wiki_style: reference\n", encoding="utf-8")

    repo = SimpleNamespace(settings_json=json.dumps({"wiki_style": "caveman"}))
    assert _repo_wiki_style(repo, str(tmp_path)) == "reference"


def test_repo_wiki_style_falls_back_to_config(tmp_path):
    """With no DB setting, the config.yaml style is used."""
    from repowise.server.job_executor import _repo_wiki_style

    config_dir = tmp_path / ".repowise"
    config_dir.mkdir()
    (config_dir / "config.yaml").write_text("wiki_style: tutorial\n", encoding="utf-8")

    repo = SimpleNamespace(settings_json="{}")
    assert _repo_wiki_style(repo, str(tmp_path)) == "tutorial"


def test_repo_wiki_style_defaults_and_tolerates_bad_input(tmp_path):
    """Unknown / missing / malformed style resolves to the comprehensive default."""
    from repowise.server.job_executor import _repo_wiki_style

    assert _repo_wiki_style(SimpleNamespace(settings_json="{}"), str(tmp_path)) == "comprehensive"
    assert (
        _repo_wiki_style(SimpleNamespace(settings_json='{"wiki_style": "nope"}'), str(tmp_path))
        == "comprehensive"
    )
    assert (
        _repo_wiki_style(SimpleNamespace(settings_json="{bad json"), str(tmp_path))
        == "comprehensive"
    )


def test_server_generation_config_reads_repo_output_limit(tmp_path):
    config_dir = tmp_path / ".repowise"
    config_dir.mkdir()
    (config_dir / "config.yaml").write_text("max_tokens: 2468\n", encoding="utf-8")

    config = _build_generation_config(tmp_path, {}, "comprehensive")

    assert config.max_tokens == 2468


@pytest.mark.asyncio
async def test_execute_job_merges_config_yaml_excludes(session_factory, tmp_path):
    """End-to-end regression: the real user case (tools/ excluded).

    Repo settings carry ``exclude_patterns: ["tools/"]``; the job path must
    forward exactly that to run_pipeline so ``tools/`` is never re-indexed.
    """
    job_id = await _seed_repo_and_job(
        session_factory,
        tmp_path,
        settings={"exclude_patterns": ["tools/"]},
    )

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
    ):
        await execute_job(job_id, app_state)

    run_pipeline_mock.assert_awaited_once()
    assert run_pipeline_mock.await_args.kwargs["exclude_patterns"] == ["tools/"]


@pytest.mark.asyncio
async def test_execute_job_uses_repository_vector_store(session_factory, tmp_path):
    """A workspace job must not write vectors to the global primary store."""
    job_id = await _seed_repo_and_job(session_factory, tmp_path)
    primary_store = object()
    repo_store = MagicMock()
    app_state = SimpleNamespace(
        session_factory=session_factory,
        fts=None,
        vector_store=primary_store,
    )
    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    resolve_store = AsyncMock(return_value=repo_store)

    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.search_helpers.resolve_repo_vector_store",
            resolve_store,
        ),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            side_effect=RuntimeError("no provider"),
        ),
    ):
        await execute_job(job_id, app_state)

    resolve_store.assert_awaited_once()
    assert resolve_store.await_args.args[0] is app_state
    assert resolve_store.await_args.kwargs == {
        "repo_path": str(tmp_path),
        "create": True,
    }
    assert run_pipeline_mock.await_args.kwargs["vector_store"] is repo_store


@pytest.mark.asyncio
async def test_incremental_page_regen_passes_repo_path(tmp_path):
    """Incremental regen must forward repo_path to generate_all.

    Without it, generate_all can't load the curated knowledge-graph.json
    artifact and silently falls back to community module grouping, which
    overwrites curated module pages with the wrong ids.
    """
    repo_path = tmp_path
    repowise_dir = repo_path / ".repowise"
    repowise_dir.mkdir()
    (repowise_dir / "state.json").write_text('{"last_sync_commit": "base-sha"}', encoding="utf-8")

    result = SimpleNamespace(
        file_count=10,
        parsed_files=[],
        source_map={},
        graph_builder=SimpleNamespace(graph=lambda: object(), pagerank=lambda: {}),
        repo_structure=object(),
        repo_name="test-repo",
        git_meta_map={},
    )

    # Stub git HEAD lookup to a sha != base so regen proceeds.
    head_proc = SimpleNamespace(returncode=0, stdout="head-sha\n")

    # Detector reports one changed/affected file so generation runs.
    detector = MagicMock()
    detector.get_changed_files.return_value = [object()]
    affected = SimpleNamespace(regenerate=["foo.py"])
    detector.get_affected_pages.return_value = affected

    generator = MagicMock()
    generator.generate_all = AsyncMock(return_value=[])

    with (
        patch("subprocess.run", return_value=head_proc),
        patch(
            "repowise.core.ingestion.ChangeDetector",
            return_value=detector,
        ),
        patch(
            "repowise.core.ingestion.change_detector.compute_adaptive_budget",
            return_value=5,
        ),
        patch("repowise.core.generation.PageGenerator", return_value=generator),
        patch("repowise.core.generation.ContextAssembler"),
        patch("repowise.core.generation.GenerationConfig"),
        patch("repowise.core.reasoning.resolve_reasoning", return_value="low"),
        patch("repowise.core.repo_config.load_repo_config", return_value={}),
    ):
        await _incremental_page_regen(
            Path(repo_path),
            result,
            llm_client=object(),
            job_config={},
            progress=None,
        )

    generator.generate_all.assert_awaited_once()
    assert generator.generate_all.await_args.kwargs["repo_path"] == Path(repo_path)


@pytest.mark.asyncio
async def test_incremental_page_regen_offloads_change_detection(session_factory, tmp_path):
    """Async stale lookup feeds the offloaded Git and graph planning unit."""
    result = SimpleNamespace()
    to_thread = AsyncMock(return_value=None)
    stale_pages = {"foo.py": 123.0}

    with (
        patch("repowise.server.job_executor.asyncio.to_thread", to_thread),
        patch(
            "repowise.core.persistence.get_stale_file_page_ages",
            AsyncMock(return_value=stale_pages),
        ),
    ):
        pages = await _incremental_page_regen(
            tmp_path,
            result,
            llm_client=object(),
            job_config={"before": "base-sha"},
            progress=None,
            session_factory=session_factory,
            repo_id="repo-id",
        )

    assert pages == []
    to_thread.assert_awaited_once_with(
        _plan_incremental_page_regen,
        tmp_path,
        result,
        {"before": "base-sha"},
        stale_pages,
    )


@pytest.mark.asyncio
async def test_incremental_page_regen_sets_file_pages_only(tmp_path):
    """A server sync must scope generation to file pages (the D4 fix).

    ``_incremental_page_regen`` feeds generate_all a parsed_files filtered to
    the changed files. Without ``file_pages_only=True`` on the GenerationConfig,
    levels 3+ would rewrite the codebase map, module and overview pages from a
    one-commit view. This asserts the config the PageGenerator receives carries
    the flag, so repo-wide pages are left untouched on a partial sync.
    """
    repo_path = tmp_path
    repowise_dir = repo_path / ".repowise"
    repowise_dir.mkdir()
    (repowise_dir / "state.json").write_text('{"last_sync_commit": "base-sha"}', encoding="utf-8")

    result = SimpleNamespace(
        file_count=10,
        parsed_files=[],
        source_map={},
        graph_builder=SimpleNamespace(graph=lambda: object(), pagerank=lambda: {}),
        repo_structure=object(),
        repo_name="test-repo",
        git_meta_map={},
    )

    head_proc = SimpleNamespace(returncode=0, stdout="head-sha\n")

    detector = MagicMock()
    detector.get_changed_files.return_value = [object()]
    detector.get_affected_pages.return_value = SimpleNamespace(regenerate=["foo.py"])

    generator = MagicMock()
    generator.generate_all = AsyncMock(return_value=[])
    page_generator_cls = MagicMock(return_value=generator)

    # GenerationConfig is left unpatched so we inspect the real one.
    with (
        patch("subprocess.run", return_value=head_proc),
        patch("repowise.core.ingestion.ChangeDetector", return_value=detector),
        patch(
            "repowise.core.ingestion.change_detector.compute_adaptive_budget",
            return_value=5,
        ),
        patch("repowise.core.generation.PageGenerator", page_generator_cls),
        patch("repowise.core.generation.ContextAssembler"),
        patch("repowise.core.reasoning.resolve_reasoning", return_value="low"),
        patch("repowise.core.repo_config.load_repo_config", return_value={}),
    ):
        await _incremental_page_regen(
            Path(repo_path),
            result,
            llm_client=object(),
            job_config={},
            progress=None,
        )

    # PageGenerator(llm_client, assembler, generation_config, ...)
    generation_config = page_generator_cls.call_args.args[2]
    assert generation_config.file_pages_only is True


# ---------------------------------------------------------------------------
# Deterministic template wiki on a keyless initial index (Part B)
# ---------------------------------------------------------------------------


async def _seed_job_with_config(session_factory, repo_path, config: dict) -> str:
    """Insert a repo + a pending job carrying ``config``; return the job id."""
    async with session_factory() as session:
        repo = await upsert_repository(
            session, name="test-repo", local_path=str(repo_path), settings={}
        )
        job = await upsert_generation_job(session, repository_id=repo.id, config=config)
        await session.commit()
        return job.id


def _no_provider():
    return patch(
        "repowise.server.provider_config.get_chat_provider_instance",
        side_effect=RuntimeError("no provider"),
    )


@pytest.mark.asyncio
async def test_initial_index_without_provider_renders_deterministic_wiki(session_factory, tmp_path):
    """A keyless first index renders a template wiki instead of nothing.

    Without a provider, the pipeline runs in DETERMINISTIC mode (it supplies its
    own null TemplateProvider), so the repo gets a complete, upgradable template
    wiki rather than an empty index that reads as blank in the web UI.
    """
    from repowise.core.pipeline.modes import OrchestratorMode

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_executor._persist_initial_index_state"),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    kwargs = run_pipeline_mock.await_args.kwargs
    assert kwargs["mode"] == OrchestratorMode.DETERMINISTIC
    assert kwargs["generate_docs"] is True
    assert kwargs["llm_client"] is None


@pytest.mark.asyncio
async def test_initial_index_without_provider_writes_deterministic_docs_mode(
    session_factory, tmp_path
):
    """The persisted docs mode is 'deterministic' on a keyless first index."""
    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    persist_state = MagicMock()
    with (
        patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    persist_state.assert_called_once()
    assert persist_state.call_args.kwargs["docs_mode"] == "deterministic"
    assert persist_state.call_args.kwargs["llm_client"] is None


@pytest.mark.asyncio
async def test_initial_index_with_provider_uses_llm_mode(session_factory, tmp_path):
    """With a provider, a first index writes model docs ('llm'), STANDARD mode."""
    from repowise.core.pipeline.modes import OrchestratorMode

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "initial_index"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    provider = SimpleNamespace(provider_name="openai", model_name="gpt-x")
    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    persist_state = MagicMock()
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            return_value=provider,
        ),
    ):
        await execute_job(job_id, app_state)

    assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
    assert run_pipeline_mock.await_args.kwargs["generate_docs"] is True
    assert persist_state.call_args.kwargs["docs_mode"] == "llm"


@pytest.mark.asyncio
async def test_initial_index_no_provider_generate_docs_false_writes_none(session_factory, tmp_path):
    """An explicit generate_docs=False keyless index generates nothing ('none')."""
    from repowise.core.pipeline.modes import OrchestratorMode

    job_id = await _seed_job_with_config(
        session_factory, tmp_path, {"mode": "initial_index", "generate_docs": False}
    )
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    persist_state = MagicMock()
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_executor._persist_initial_index_state", persist_state),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
    assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD
    assert persist_state.call_args.kwargs["docs_mode"] == "none"


@pytest.mark.asyncio
async def test_full_resync_without_provider_stays_index_only(session_factory, tmp_path):
    """A keyless full_resync must NOT template-overwrite an existing wiki.

    The deterministic fallback is scoped to initial_index; a keyless full_resync
    keeps its index-only behaviour so it can never replace a model-written wiki
    with templates.
    """
    from repowise.core.pipeline.modes import OrchestratorMode

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "full_resync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
    assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD


@pytest.mark.asyncio
async def test_index_only_job_does_not_generate_docs(session_factory, tmp_path):
    """The cheap index_only analysis refresh never renders a wiki."""
    from repowise.core.pipeline.modes import OrchestratorMode

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "index_only"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    assert run_pipeline_mock.await_args.kwargs["generate_docs"] is False
    assert run_pipeline_mock.await_args.kwargs["mode"] == OrchestratorMode.STANDARD


@pytest.mark.asyncio
async def test_execute_job_fails_on_unknown_mode(session_factory, tmp_path):
    """An unrecognized job mode explicitly fails the job rather than running partial work."""
    from repowise.core.persistence.crud import get_generation_job

    async with session_factory() as session:
        repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={"mode": "incremental"},
        )
        await session.commit()
        job_id = job.id

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
    ):
        await execute_job(job_id, app_state)

    # Pipeline should not run when mode is invalid
    run_pipeline_mock.assert_not_called()

    # Job status should be recorded as failed in the DB with clear error message
    async with session_factory() as session:
        updated_job = await get_generation_job(session, job_id)
        assert updated_job is not None
        assert updated_job.status == "failed"
        assert "Invalid job mode 'incremental'" in (updated_job.error_message or "")


@pytest.mark.asyncio
async def test_execute_job_defaults_to_sync_when_mode_absent(session_factory, tmp_path):
    """A missing mode key (config={}) defaults to 'sync' and proceeds without failing."""
    async with session_factory() as session:
        repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={},
        )
        await session.commit()
        job_id = job.id

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            get_provider_mock,
        ),
    ):
        await execute_job(job_id, app_state)

    # Pipeline must have run
    run_pipeline_mock.assert_awaited_once()
    # Provider lookup was attempted — proves fallback is "sync", not "index_only"
    get_provider_mock.assert_called_once()


@pytest.mark.asyncio
async def test_execute_job_defaults_to_sync_when_mode_empty_string(session_factory, tmp_path):
    """An explicit empty-string mode also defaults to 'sync' via the `or` fallback."""
    async with session_factory() as session:
        repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={"mode": ""},
        )
        await session.commit()
        job_id = job.id

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            get_provider_mock,
        ),
    ):
        await execute_job(job_id, app_state)

    # Pipeline must have run
    run_pipeline_mock.assert_awaited_once()
    get_provider_mock.assert_called_once()


@pytest.mark.asyncio
async def test_execute_job_resolves_the_provider_the_ui_picked_for_this_repo(
    session_factory, tmp_path
):
    """The dashboard's provider picker persists its choice per repo, keyed by
    repo id. Resolving on path alone skipped that entry -- the most specific
    step in the resolver, and the only one carrying a deliberate user decision
    -- so a repo whose settings named a provider still indexed with whatever
    auto-detection guessed from the server's own environment.
    """
    async with session_factory() as session:
        repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={"mode": "sync"},
        )
        await session.commit()
        job_id, repo_id = job.id, repo.id

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    get_provider_mock = MagicMock(side_effect=RuntimeError("no provider"))
    with (
        patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            get_provider_mock,
        ),
    ):
        await execute_job(job_id, app_state)

    get_provider_mock.assert_called_once()
    assert get_provider_mock.call_args.kwargs.get("repo_id") == repo_id


@pytest.mark.asyncio
async def test_execute_job_dispatches_generate_mode(session_factory, tmp_path):
    """A job with mode='generate' passes validation and dispatches to _run_generate_job."""
    async with session_factory() as session:
        repo = await upsert_repository(session, name="test-repo", local_path=str(tmp_path))
        job = await upsert_generation_job(
            session,
            repository_id=repo.id,
            config={"mode": "generate"},
        )
        await session.commit()
        job_id = job.id

    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    run_generate_mock = AsyncMock()
    with (
        patch("repowise.server.job_executor._run_generate_job", run_generate_mock),
        patch(
            "repowise.server.provider_config.get_chat_provider_instance",
            MagicMock(return_value=MagicMock()),
        ),
    ):
        await execute_job(job_id, app_state)

    run_generate_mock.assert_awaited_once()


@pytest.mark.asyncio
async def test_phase_start_with_unknown_total_clears_stale_denominator(session_factory, tmp_path):
    """A phase that starts with total=None must zero out a previous phase's
    total_pages, not leave the record pairing a fresh numerator with a
    denominator that describes different work (issue #2175)."""
    job_id = await _seed_repo_and_job(session_factory, tmp_path)

    async with session_factory() as session:
        await update_job_status(session, job_id, "running", completed_pages=241, total_pages=5)
        await session.commit()

    callback = JobProgressCallback(job_id, session_factory)
    callback.on_phase_start("generation", None)
    await callback.drain_and_stop()

    async with session_factory() as session:
        job = await get_generation_job(session, job_id)
        assert job.total_pages == 0
        assert job.completed_pages == 0


@pytest.mark.asyncio
async def test_update_job_status_without_total_pages_preserves_existing_value(
    session_factory, tmp_path
):
    """Callers that omit total_pages (None) must keep the record's existing
    total unchanged, distinct from JobProgressCallback explicitly zeroing it
    for an unknown-total phase."""
    job_id = await _seed_repo_and_job(session_factory, tmp_path)

    async with session_factory() as session:
        await update_job_status(session, job_id, "running", completed_pages=241, total_pages=5)
        await session.commit()

    async with session_factory() as session:
        await update_job_status(session, job_id, "running", completed_pages=250)
        await session.commit()

    async with session_factory() as session:
        job = await get_generation_job(session, job_id)
        assert job.total_pages == 5
        assert job.completed_pages == 250


# ---------------------------------------------------------------------------
# Update lock and analyzer stamp: a server job never overwrites newer health
# ---------------------------------------------------------------------------


def _write_state(repo_path: Path, state: dict) -> None:
    import json

    path = repo_path / ".repowise" / "state.json"
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(state), encoding="utf-8")


async def _job_row(session_factory, job_id: str):
    async with session_factory() as session:
        return await get_generation_job(session, job_id)


@pytest.mark.asyncio
async def test_sync_job_holds_the_update_lock_and_stamps_its_analyzer(session_factory, tmp_path):
    import json

    from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION
    from repowise.core.update_lock import read_update_lock

    _write_state(tmp_path, {"last_sync_commit": "old", "health_analyzer_version": 1})
    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    held_during_run: list = []

    async def pipeline(*_a, **_k):
        held_during_run.append(read_update_lock(tmp_path))
        return SimpleNamespace(**vars(_fake_result()), health_report=object())

    with (
        patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_state._read_head_sha", return_value="new"),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    assert (await _job_row(session_factory, job_id)).status == "completed"
    assert held_during_run[0] is not None
    assert read_update_lock(tmp_path) is None
    state = json.loads((tmp_path / ".repowise" / "state.json").read_text(encoding="utf-8"))
    assert state["health_analyzer_version"] == HEALTH_ANALYZER_VERSION
    assert state["last_sync_commit"] == "new"


@pytest.mark.asyncio
async def test_sync_job_does_not_run_while_a_cli_update_holds_the_lock(session_factory, tmp_path):
    from repowise.core.update_lock import (
        read_update_lock,
        release_update_lock,
        try_acquire_update_lock,
    )

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
    assert try_acquire_update_lock(tmp_path, "cli-target") is None
    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    try:
        with (
            patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
            patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
            _no_provider(),
        ):
            await execute_job(job_id, app_state)
        # The CLI's lock is left in place for its owner.
        assert read_update_lock(tmp_path)["target_commit"] == "cli-target"
    finally:
        release_update_lock(tmp_path)

    run_pipeline_mock.assert_not_called()
    job = await _job_row(session_factory, job_id)
    assert job.status == "cancelled"
    assert "Another repowise update" in job.error_message


@pytest.mark.asyncio
async def test_older_server_never_overwrites_newer_health_rows(session_factory, tmp_path):
    from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION
    from repowise.core.update_lock import read_update_lock

    _write_state(tmp_path, {"health_analyzer_version": HEALTH_ANALYZER_VERSION + 1})
    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
    run_pipeline_mock = AsyncMock(return_value=_fake_result())
    persist = AsyncMock()
    with (
        patch("repowise.server.job_executor.run_pipeline", run_pipeline_mock),
        patch("repowise.server.job_executor.persist_pipeline_result", persist),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    run_pipeline_mock.assert_not_called()
    persist.assert_not_called()
    job = await _job_row(session_factory, job_id)
    assert job.status == "failed"
    assert f"analyzer version {HEALTH_ANALYZER_VERSION + 1}" in job.error_message
    assert read_update_lock(tmp_path) is None


@pytest.mark.asyncio
async def test_newer_stamp_written_during_the_run_blocks_the_persist(session_factory, tmp_path):
    from repowise.core.analysis.health import HEALTH_ANALYZER_VERSION

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "full_resync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)

    async def pipeline(*_a, **_k):
        _write_state(tmp_path, {"health_analyzer_version": HEALTH_ANALYZER_VERSION + 1})
        return _fake_result()

    persist = AsyncMock()
    with (
        patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
        patch("repowise.server.job_executor.persist_pipeline_result", persist),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    persist.assert_not_called()
    assert (await _job_row(session_factory, job_id)).status == "failed"


@pytest.mark.asyncio
async def test_cancelled_sync_job_releases_the_update_lock(session_factory, tmp_path):
    import asyncio

    from repowise.core.update_lock import read_update_lock

    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
    started = asyncio.Event()

    async def pipeline(*_a, **_k):
        started.set()
        await asyncio.sleep(60)

    with (
        patch("repowise.server.job_executor.run_pipeline", side_effect=pipeline),
        _no_provider(),
    ):
        task = asyncio.create_task(execute_job(job_id, app_state))
        await asyncio.wait_for(started.wait(), 30)
        assert read_update_lock(tmp_path) is not None
        task.cancel()
        await task

    assert read_update_lock(tmp_path) is None
    assert (await _job_row(session_factory, job_id)).status == "cancelled"


@pytest.mark.asyncio
async def test_sync_job_without_a_health_report_keeps_the_stored_stamp(session_factory, tmp_path):
    import json

    _write_state(tmp_path, {"health_analyzer_version": 1})
    job_id = await _seed_job_with_config(session_factory, tmp_path, {"mode": "sync"})
    app_state = SimpleNamespace(session_factory=session_factory, fts=None, vector_store=None)
    with (
        patch("repowise.server.job_executor.run_pipeline", AsyncMock(return_value=_fake_result())),
        patch("repowise.server.job_executor.persist_pipeline_result", AsyncMock()),
        patch("repowise.server.job_state._read_head_sha", return_value="new"),
        _no_provider(),
    ):
        await execute_job(job_id, app_state)

    state = json.loads((tmp_path / ".repowise" / "state.json").read_text(encoding="utf-8"))
    assert state["health_analyzer_version"] == 1