Skip to content

Agent Zero AI framework

16.8 KB
Raw Blame
import threading
from pathlib import Path
from types import SimpleNamespace

import pytest

import initialize
from agent import AgentConfig, AgentContext
from helpers import dirty_json, files, persist_chat, projects, subagents
from helpers import state_monitor_integration


def _prepare_project_tree(monkeypatch, tmp_path: Path) -> None:
    monkeypatch.setattr(files, "_base_dir", str(tmp_path))
    (tmp_path / "usr" / "projects").mkdir(parents=True, exist_ok=True)
    (tmp_path / "usr" / "plugins").mkdir(parents=True, exist_ok=True)
    (tmp_path / "plugins").mkdir(parents=True, exist_ok=True)


@pytest.mark.parametrize(
    "destination_project", ["project-y", None], ids=["project", "global"]
)
def test_project_switch_resets_only_profiles_missing_from_the_new_scope(
    monkeypatch, destination_project
):
    context_id = "ctx-project-profile-switch"
    AgentContext.remove(context_id)
    context = AgentContext(
        config=AgentConfig(mcp_servers="", profile="project-only"),
        id=context_id,
        set_current=False,
    )
    monkeypatch.setattr(
        projects,
        "load_edit_project_data",
        lambda name: {"title": name.title(), "color": ""},
    )
    monkeypatch.setattr(persist_chat, "save_tmp_chat", lambda _context: None)
    monkeypatch.setattr(
        subagents,
        "get_agents_dict",
        lambda project_name=None: {
            "agent0": subagents.SubAgentListItem(name="agent0"),
            **(
                {
                    "project-only": subagents.SubAgentListItem(
                        name="project-only"
                    )
                }
                if project_name == "project-x"
                else {}
            ),
        },
    )
    monkeypatch.setattr(
        initialize,
        "initialize_agent",
        lambda override_settings=None: AgentConfig(
            mcp_servers="",
            profile=(override_settings or {}).get("agent_profile", "agent0"),
        ),
    )

    try:
        projects.activate_project(context_id, "project-x", mark_dirty=False)
        assert context.config.profile == "project-only"

        if destination_project:
            projects.activate_project(
                context_id, destination_project, mark_dirty=False
            )
        else:
            projects.deactivate_project(context_id, mark_dirty=False)
        assert context.config.profile == "agent0"
        assert context.agent0.config.profile == "agent0"
    finally:
        AgentContext.remove(context_id)


def test_project_agent_availability_retains_project_only_profiles(
    monkeypatch,
) -> None:
    monkeypatch.setattr(
        subagents,
        "get_agents_dict",
        lambda project_name=None: {
            "global": subagents.SubAgentListItem(name="global", enabled=True),
            **(
                {
                    "project-only": subagents.SubAgentListItem(
                        name="project-only", enabled=True
                    )
                }
                if project_name == "demo"
                else {}
            ),
        },
    )

    assert projects._normalize_subagents(
        {
            "global": {"enabled": True},
            "project-only": {"enabled": False},
            "missing": {"enabled": False},
        },
        "demo",
    ) == {"project-only": {"enabled": False}}


def test_project_profile_toggle_preserves_other_entries_and_refuses_bad_json(
    monkeypatch,
    tmp_path: Path,
) -> None:
    _prepare_project_tree(monkeypatch, tmp_path)
    meta = tmp_path / "usr" / "projects" / "demo" / ".a0proj"
    meta.mkdir(parents=True)
    availability = meta / "agents.json"
    monkeypatch.setattr(
        subagents,
        "get_agents_dict",
        lambda _project=None: {
            "default": subagents.SubAgentListItem(name="default", enabled=True),
            "researcher": subagents.SubAgentListItem(
                name="researcher", enabled=True
            ),
        },
    )
    availability.write_text(
        '{"default":{"enabled":false}}',
        encoding="utf-8",
    )

    projects.set_project_subagent_enabled("demo", "researcher", False)

    assert dirty_json.parse(availability.read_text(encoding="utf-8")) == {
        "default": {"enabled": False},
        "researcher": {"enabled": False},
    }
    broken = b'{"default":'
    availability.write_bytes(broken)

    with pytest.raises(ValueError, match="Project agent availability"):
        projects.set_project_subagent_enabled("demo", "researcher", True)

    assert availability.read_bytes() == broken


def test_project_edit_ignores_stale_agent_availability(
    monkeypatch,
    tmp_path: Path,
) -> None:
    _prepare_project_tree(monkeypatch, tmp_path)
    meta = tmp_path / "usr" / "projects" / "demo" / ".a0proj"
    meta.mkdir(parents=True)
    (meta / "project.json").write_text('{"title":"Demo"}', encoding="utf-8")
    availability = meta / "agents.json"
    original = b'{"default":{"enabled":false}}'
    availability.write_bytes(original)
    monkeypatch.setattr("helpers.git.get_repo_status", lambda _path: {})
    monkeypatch.setattr(projects, "reactivate_project_in_chats", lambda _name: None)
    extended: list[dict] = []
    monkeypatch.setattr(
        projects,
        "save_project_extended_data",
        lambda _name, data: extended.append(data),
    )

    loaded = projects.load_edit_project_data("demo")
    projects.update_project(
        "demo",
        {
            **loaded,
            "title": "Renamed",
            "subagents": {"default": {"enabled": True}},
        },
    )

    assert "subagents" not in loaded
    assert availability.read_bytes() == original
    assert extended and all("subagents" not in data for data in extended)


def test_profile_reconciliation_uses_an_available_fallback(monkeypatch) -> None:
    context_id = "ctx-profile-availability-fallback"
    AgentContext.remove(context_id)
    context = AgentContext(
        config=AgentConfig(mcp_servers="", profile="disabled"),
        id=context_id,
        set_current=False,
    )
    monkeypatch.setattr(
        subagents,
        "get_available_agents_dict",
        lambda _project_name: {
            "researcher": subagents.SubAgentListItem(name="researcher")
        },
    )
    monkeypatch.setattr(
        initialize,
        "initialize_agent",
        lambda override_settings=None: AgentConfig(
            mcp_servers="",
            profile=(override_settings or {}).get("agent_profile", "default"),
        ),
    )

    try:
        assert projects.reconcile_agent_profile(context, None) is True
        assert context.config.profile == "researcher"
        assert context.agent0.config.profile == "researcher"
    finally:
        AgentContext.remove(context_id)


def test_context_lookup_reconciles_only_new_contexts(monkeypatch) -> None:
    from helpers.context_utils import use_context

    existing_id = "ctx-existing-profile"
    created_id = "ctx-new-profile"
    AgentContext.remove(existing_id)
    AgentContext.remove(created_id)
    existing = AgentContext(
        config=AgentConfig(mcp_servers="", profile="default"),
        id=existing_id,
        set_current=False,
    )
    reconciled: list[str] = []
    monkeypatch.setattr(
        initialize,
        "initialize_agent",
        lambda: AgentConfig(mcp_servers="", profile="default"),
    )
    monkeypatch.setattr(
        projects,
        "reconcile_agent_profile",
        lambda context, _project: reconciled.append(context.id),
    )

    try:
        assert use_context(threading.RLock(), existing_id) is existing
        assert reconciled == []

        assert use_context(threading.RLock(), created_id).id == created_id
        assert reconciled == [created_id]
    finally:
        AgentContext.remove(existing_id)
        AgentContext.remove(created_id)


@pytest.mark.parametrize(
    ("all_scopes", "expected"),
    [
        (False, ["global-changed"]),
        (True, ["global-changed", "project-changed"]),
    ],
)
def test_bulk_profile_reconciliation_persists_only_changed_chats(
    monkeypatch, all_scopes: bool, expected: list[str]
) -> None:
    unchanged = SimpleNamespace(id="global-unchanged", project=None)
    global_changed = SimpleNamespace(id="global-changed", project=None)
    project_changed = SimpleNamespace(id="project-changed", project="demo")
    saved: list[str] = []
    dirty: list[str] = []
    catalog_lookups: list[str | None] = []
    monkeypatch.setattr(
        AgentContext,
        "all",
        classmethod(
            lambda _cls: [unchanged, global_changed, project_changed]
        ),
    )
    monkeypatch.setattr(
        projects, "get_context_project_name", lambda context: context.project
    )
    monkeypatch.setattr(
        projects,
        "reconcile_agent_profile",
        lambda context, _project, _available: context is not unchanged,
    )
    monkeypatch.setattr(
        subagents,
        "get_available_agents_dict",
        lambda project: catalog_lookups.append(project) or {},
    )
    monkeypatch.setattr(
        persist_chat, "save_tmp_chat", lambda context: saved.append(context.id)
    )
    monkeypatch.setattr(
        state_monitor_integration,
        "mark_dirty_for_context",
        lambda context_id, **_kwargs: dirty.append(context_id),
    )

    projects.reconcile_agent_profiles(None, all_scopes=all_scopes)

    assert saved == expected
    assert dirty == expected
    assert catalog_lookups == ([None, "demo"] if all_scopes else [None])


def test_project_refresh_touches_only_matching_chats(monkeypatch) -> None:
    contexts = [
        SimpleNamespace(id="matching", get_data=lambda _key: "demo"),
        SimpleNamespace(id="unrelated", get_data=lambda _key: "other"),
    ]
    calls: list[tuple] = []
    monkeypatch.setattr(
        AgentContext, "all", staticmethod(lambda: contexts)
    )
    monkeypatch.setattr(
        projects,
        "activate_project",
        lambda context_id, name, *, mark_dirty: calls.append(
            ("activate", context_id, name, mark_dirty)
        ),
    )
    monkeypatch.setattr(
        projects,
        "deactivate_project",
        lambda context_id, *, mark_dirty: calls.append(
            ("deactivate", context_id, mark_dirty)
        ),
    )
    monkeypatch.setattr(state_monitor_integration, "mark_dirty_all", lambda **_kwargs: None)

    projects.reactivate_project_in_chats("demo")
    projects.deactivate_project_in_chats("demo")

    assert calls == [
        ("activate", "matching", "demo", False),
        ("deactivate", "matching", False),
    ]


def test_project_include_agents_md_defaults_true_and_saves(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    meta = tmp_path / "usr" / "projects" / "demo" / ".a0proj"
    meta.mkdir(parents=True)
    (meta / "project.json").write_text('{"title": "Demo"}', encoding="utf-8")

    data = projects.load_basic_project_data("demo")

    assert data["include_agents_md"] is True

    projects.save_project_header("demo", data)
    saved = dirty_json.parse((meta / "project.json").read_text(encoding="utf-8"))

    assert saved["include_agents_md"] is True


def test_project_mcp_servers_persist_in_project_meta(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    config = '{"mcpServers":{"demo":{"url":"https://example.com/mcp"}}}'

    projects.create_project(
        "demo",
        {
            "title": "Demo",
            "mcp_servers": config,
        },
    )

    assert projects.load_project_mcp_servers("demo") == config
    assert projects.load_edit_project_data("demo")["mcp_servers"] == config

    updated = '{"mcpServers":{"other":{"command":"uvx","args":["pkg"]}}}'
    projects.save_project_mcp_servers("demo", updated)

    assert projects.load_project_mcp_servers("demo") == updated


def test_project_mcp_servers_reject_path_names(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)

    for name in ("../escape", "nested/project", ".", "..", ""):
        try:
            projects.save_project_mcp_servers(name, '{"mcpServers":{}}')
        except ValueError:
            pass
        else:
            raise AssertionError(f"Expected invalid project name: {name!r}")


def test_project_creation_creates_skills_folder(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)

    projects.create_project("demo", {"title": "Demo"})

    assert (tmp_path / "usr" / "projects" / "demo" / ".a0proj" / "skills").is_dir()


def test_project_load_repairs_missing_skills_folder(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    meta = tmp_path / "usr" / "projects" / "demo" / ".a0proj"
    meta.mkdir(parents=True)
    (meta / "project.json").write_text('{"title": "Demo"}', encoding="utf-8")

    assert not (meta / "skills").exists()

    projects.load_edit_project_data("demo")

    assert (meta / "skills").is_dir()


def test_project_system_prompt_includes_root_agents_md_with_path(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    projects.create_project(
        "demo",
        {
            "title": "Demo",
            "instructions": "Main project rule.",
        },
    )
    project_root = tmp_path / "usr" / "projects" / "demo"
    (project_root / "AGENTS.md").write_text("Root AGENTS rule.", encoding="utf-8")
    (
        project_root / ".a0proj" / "instructions" / "extra.md"
    ).write_text("Folder instruction rule.", encoding="utf-8")

    prompt_vars = projects.build_system_prompt_vars("demo")
    instructions = prompt_vars["project_instructions"]

    assert "Main project rule." in instructions
    assert instructions.count("## project instruction files") == 1
    assert "## project instruction file\n" not in instructions
    assert "### path: /a0/usr/projects/demo/AGENTS.md" in instructions
    assert "Root AGENTS rule." in instructions
    assert "### path: /a0/usr/projects/demo/.a0proj/instructions/extra.md" in instructions
    assert "Folder instruction rule." in instructions


def test_project_system_prompt_prefers_agents_override_md(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    projects.create_project("demo", {"title": "Demo"})
    project_root = tmp_path / "usr" / "projects" / "demo"
    (project_root / "AGENTS.md").write_text("Standard rule.", encoding="utf-8")
    (project_root / "AGENTS.override.md").write_text("Override rule.", encoding="utf-8")

    instructions = projects.build_system_prompt_vars("demo")["project_instructions"]

    assert "### path: /a0/usr/projects/demo/AGENTS.override.md" in instructions
    assert "Override rule." in instructions
    assert "Standard rule." not in instructions


def test_project_system_prompt_respects_disabled_agents_md(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    projects.create_project(
        "demo",
        {
            "title": "Demo",
            "include_agents_md": False,
        },
    )
    project_root = tmp_path / "usr" / "projects" / "demo"
    (project_root / "AGENTS.md").write_text("Root AGENTS rule.", encoding="utf-8")

    prompt_vars = projects.build_system_prompt_vars("demo")

    assert "Root AGENTS rule." not in prompt_vars["project_instructions"]
    assert "AGENTS.md" not in prompt_vars["project_instructions"]


def test_agents_md_chain_walks_direct_path_only(monkeypatch, tmp_path):
    _prepare_project_tree(monkeypatch, tmp_path)
    root = tmp_path
    (root / "AGENTS.md").write_text("root doc", encoding="utf-8")
    target = root / "services" / "payments"
    sibling = root / "services" / "auth"
    target.mkdir(parents=True)
    sibling.mkdir(parents=True)
    (root / "services" / "AGENTS.md").write_text("services doc", encoding="utf-8")
    (target / "AGENTS.md").write_text("payments doc", encoding="utf-8")
    (sibling / "AGENTS.md").write_text("auth doc", encoding="utf-8")

    chain = projects.get_agents_md_chain(str(root), str(target / "handler.py"))
    contents = [content for _, content in chain]

    assert contents == ["root doc", "services doc", "payments doc"]


def test_agents_md_protocol_excludes_project_root_and_keeps_subdir(
    monkeypatch, tmp_path
):
    _prepare_project_tree(monkeypatch, tmp_path)
    prompt_name = "agent.protocol.projects.agents_md.md"
    prompt_source = Path(__file__).resolve().parents[1] / "prompts" / prompt_name
    prompt_dir = tmp_path / "prompts"
    prompt_dir.mkdir()
    (prompt_dir / prompt_name).write_text(
        prompt_source.read_text(encoding="utf-8"),
        encoding="utf-8",
    )
    projects.create_project("demo", {"title": "Demo"})
    (tmp_path / "AGENTS.md").write_text("framework doc", encoding="utf-8")
    project_root = tmp_path / "usr" / "projects" / "demo"
    (project_root / "AGENTS.md").write_text("project root doc", encoding="utf-8")
    api_dir = project_root / "api"
    api_dir.mkdir()
    (api_dir / "AGENTS.md").write_text("api doc", encoding="utf-8")

    protocol = projects.build_agents_md_protocol(
        "demo",
        target=str(api_dir / "handler.py"),
    )

    assert "framework doc" in protocol
    assert "api doc" in protocol
    assert "project root doc" not in protocol