Skip to content
Repos

blackcat

Python 9.7 KB235 lines Opens in site

Directory Raw Download

"""Committed tests for subagent orchestration and spill overflow (offline).

Covers the critic-fixed contract: spill threshold precedence over the
inline cap, preview shape with sibling truncated/nudge fields, delegate
approval (explore skips, plan/general ask), background handles with
task_output polling and cancel, session resume re-attaching spills and
interrupting live turns, and TUI generic cards for the new tools.
"""

# retoor <retoor@molodetz.nl>
import asyncio
import json
import os
import tempfile
import unittest

from blackcat.agent import BlackCatBot
from blackcat.fstate import FileState
from blackcat.orchestrate import SubagentManager, SubagentSpec
from blackcat.spill import SPILL_HEAD_CHARS, SPILL_THRESHOLD, SpillStore
from blackcat.tools import FileTools


def _bot(tmp, **kwargs):
    kwargs.setdefault("provider", "echo")
    kwargs.setdefault("system", "t")
    kwargs.setdefault("tools", FileTools(FileState(tmp)))
    return BlackCatBot(**kwargs)


class TestSpillStore(unittest.IsolatedAsyncioTestCase):
    async def test_write_preview_shape(self):
        with tempfile.TemporaryDirectory() as tmp:
            store = SpillStore(tmp)
            blob = "L\n" * 9000
            preview = await store.write("read", blob)
            self.assertTrue(preview["ok"])
            self.assertTrue(preview["spilled"])
            self.assertTrue(preview["truncated"])
            self.assertIn("read_spill", preview["nudge"])
            self.assertIn("handle", preview)
            self.assertEqual(preview["shape"]["lines"], 9001)
            self.assertLess(len(preview["preview_head"]), len(blob))

    async def test_read_pages_and_filters(self):
        with tempfile.TemporaryDirectory() as tmp:
            store = SpillStore(tmp)
            blob = "\n".join("line %d needle" % i if i % 2 else
                             "line %d plain" % i for i in range(500))
            handle = (await store.write("grep", blob))["handle"]
            page = await store.read(handle, offset=1, limit=10)
            self.assertTrue(page["ok"])
            self.assertEqual(page["shown"], 10)
            self.assertTrue(page["truncated"])
            self.assertIn("read_spill", page["nudge"])
            hit = await store.read(handle, pattern="needle", limit=2000)
            self.assertTrue(all("needle" in line for line in hit["lines"]))
            self.assertGreater(hit["total_lines"], 200)
            tail = await store.read(handle, limit=5, from_end=True)
            self.assertIn("line 499 needle", tail["lines"][-1])

    async def test_unknown_handle_carries_code(self):
        with tempfile.TemporaryDirectory() as tmp:
            store = SpillStore(tmp)
            result = await store.read("spill-9999")
            self.assertFalse(result["ok"])
            self.assertEqual(result["code"], "unknown_handle")

    async def test_index_roundtrip(self):
        with tempfile.TemporaryDirectory() as tmp:
            store = SpillStore(tmp)
            handle = (await store.write("bash", "x" * (SPILL_THRESHOLD + 1))
                      )["handle"]
            index = store.to_index()
            fresh = SpillStore(tmp)
            self.assertEqual(fresh.from_index(index), 1)
            page = await fresh.read(handle)
            self.assertTrue(page["ok"])


class TestEmitSpill(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.bot = _bot(self.tmp.name)
        self.addAsyncCleanup(self.bot.aclose)

    async def test_large_result_spills_with_handle_not_payload(self):
        big = {"ok": True, "data": "y" * (SPILL_THRESHOLD + 5000)}
        result = await self.bot.run_tool("todo", action="list")
        self.assertTrue(result["ok"])
        await self.bot._emit_tool_result("todo", big, None, {})
        wire = self.bot.messages[-1]["content"]
        payload = json.loads(wire)
        self.assertTrue(payload["spilled"])
        self.assertIn("handle", payload)
        self.assertNotIn("y" * (SPILL_HEAD_CHARS + 1), wire)
        self.assertLess(len(wire), len(json.dumps(big)))
        full = [f for f in self.bot.transcript
                if f.get("kind") == "tool" and f.get("out") == big]
        self.assertEqual(len(full), 1)
        page = await self.bot.run_tool(
            "read_spill", handle=payload["handle"], limit=5)
        self.assertTrue(page["ok"])

    async def test_mid_size_keeps_legacy_truncation(self):
        mid = {"ok": True, "data": "z" * 9000}
        blob = json.dumps(mid)
        self.assertGreater(len(blob), 8000)
        self.assertLess(len(blob), SPILL_THRESHOLD)
        await self.bot._emit_tool_result("todo", mid, None, {})
        wire = self.bot.messages[-1]["content"]
        self.assertIn("truncated", wire)
        self.assertNotIn("spill", wire)


class TestDelegate(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.tmp = tempfile.TemporaryDirectory()
        self.addCleanup(self.tmp.cleanup)
        self.bot = _bot(self.tmp.name)
        self.addAsyncCleanup(self.bot.aclose)

    async def test_foreground_echo_returns_answer(self):
        result = await self.bot.run_tool("delegate", task="scout the repo",
                                         kind="explore")
        self.assertTrue(result["ok"])
        self.assertEqual(result["status"], "done")
        self.assertIn("handle", result)
        self.assertIn("scout the repo", result["answer"])
        todos = self.bot.todo_list()
        self.assertTrue(any("delegate(explore)" in t["text"] for t in todos))
        self.assertTrue(all(t["status"] == "done" for t in todos
                            if "delegate(explore)" in t["text"]))

    async def test_bad_kind_rejected(self):
        result = await self.bot.run_tool("delegate", task="x", kind="nope")
        self.assertFalse(result["ok"])
        self.assertEqual(result["code"], "bad_args")

    async def test_background_poll_to_done(self):
        started = await self.bot.run_tool("delegate", task="bg work",
                                          kind="general", background=True)
        self.assertTrue(started["ok"])
        self.assertEqual(started["status"], "running")
        hid = started["handle"]
        final = None
        for _ in range(100):
            poll = await self.bot.run_tool("task_output", handle=hid)
            if poll.get("status") != "running":
                final = poll
                break
            await asyncio.sleep(0.05)
        self.assertIsNotNone(final)
        self.assertTrue(final["ok"])
        self.assertEqual(final["status"], "done")
        self.assertIn("bg work", final["answer"])

    async def test_resume_id_rereads_handle(self):
        first = await self.bot.run_tool("delegate", task="again",
                                        kind="plan")
        reread = await self.bot.run_tool("delegate", task="ignored",
                                         resume_id=first["handle"])
        self.assertTrue(reread["ok"])
        self.assertEqual(reread["handle"], first["handle"])

    async def test_unknown_handle_carries_code(self):
        result = await self.bot.run_tool("task_output", handle="sub-9999")
        self.assertFalse(result["ok"])
        self.assertEqual(result["code"], "unknown_handle")

    async def test_explore_skips_confirm_general_asks(self):
        denied = _bot(self.tmp.name,
                      tool_confirm=lambda name, args: False)
        self.addAsyncCleanup(denied.aclose)
        explore = await denied.run_tool("delegate", task="look",
                                        kind="explore")
        self.assertTrue(explore["ok"])
        general = await denied.run_tool("delegate", task="do",
                                        kind="general")
        self.assertFalse(general["ok"])
        self.assertEqual(general["code"], "rejected")

    async def test_manager_cancel_running(self):
        manager = SubagentManager()
        spec = SubagentSpec(task="slow", kind="general", background=True)
        handle = manager.new_handle(spec)
        started = asyncio.Event()

        async def _slow():
            started.set()
            await asyncio.sleep(30)
            return {"ok": True}

        manager.start_background(handle, _slow())
        await started.wait()
        outcome = manager.cancel(handle.hid)
        self.assertTrue(outcome["ok"])
        for _ in range(100):
            if handle.status != "running":
                break
            await asyncio.sleep(0.05)
        self.assertEqual(handle.status, "cancelled")

    async def test_session_resume_interrupts_live_turns(self):
        with tempfile.TemporaryDirectory() as tmp:
            path = os.path.join(tmp, "s.json")
            first = await self.bot.run_tool("delegate", task="done work",
                                            kind="general")
            await self.bot.save_session(path)
            other = _bot(self.tmp.name, system="t")
            self.addAsyncCleanup(other.aclose)
            info = await other.load_session(path)
            self.assertTrue(info["ok"])
            self.assertEqual(info["subagents"], 1)
            reread = await other.run_tool("task_output",
                                          handle=first["handle"])
            self.assertTrue(reread["ok"])
            self.assertEqual(reread["status"], "done")


class TestNewCards(unittest.TestCase):
    def test_factory_returns_generic_cards(self):
        try:
            from blackcat.tui import cards as tools_cards
        except ImportError:
            self.skipTest("tui extra unavailable")
        for name in ("delegate", "task_output", "read_spill"):
            card = tools_cards.CardFactory.create(name, 1, {})
            self.assertIsInstance(card, tools_cards.GenericCard)
            self.assertTrue(card.header_text())


if __name__ == "__main__":
    unittest.main()
28.0ms