eljay-ai 1.1.0

package/tests/test_agent_core.py

@@ -0,0 +1,385 @@
+"""Deterministic tests for AgentCore — no model, no network.
+
+Run from the project root:
+    python tests/test_agent_core.py
+
+These verify the *architecture* (tool detection, execution, fallback parsing,
+and the unknown-tool guard) independent of how a particular model behaves.
+"""
+
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from agent.agent import AgentCore  # noqa: E402
+from agent.permissions import (  # noqa: E402
+    DECISION_ALWAYS,
+    DECISION_YES,
+    PermissionPolicy,
+)
+from agent.tools import (  # noqa: E402
+    RISK_ASK,
+    RISK_HIGH,
+    RISK_SAFE,
+    Tool,
+    ToolRegistry,
+)
+
+
+class FakeClient:
+    """Returns queued responses in order, recording the messages it was sent."""
+
+    def __init__(self, responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def chat_full(self, model, messages, tools=None, options=None):
+        self.calls.append([dict(m) for m in messages])
+        if not self._responses:
+            raise AssertionError("FakeClient ran out of queued responses")
+        return self._responses.pop(0)
+
+
+def msg(content="", tool_calls=None):
+    message = {"role": "assistant", "content": content}
+    if tool_calls is not None:
+        message["tool_calls"] = tool_calls
+    return {"message": message}
+
+
+def make_registry():
+    registry = ToolRegistry()
+    registry.register(
+        Tool(
+            name="add",
+            description="Add two integers.",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "a": {"type": "integer"},
+                    "b": {"type": "integer"},
+                },
+                "required": ["a", "b"],
+            },
+            func=lambda a, b: a + b,
+            risk=RISK_SAFE,
+        )
+    )
+    return registry
+
+
+def make_ask_registry(log, risk=RISK_ASK, name="danger"):
+    """A registry with one non-safe tool that records the calls it receives."""
+    registry = ToolRegistry()
+
+    def danger(target=""):
+        log.append(target)
+        return "did the dangerous thing"
+
+    registry.register(
+        Tool(
+            name=name,
+            description="A non-safe action.",
+            parameters={
+                "type": "object",
+                "properties": {"target": {"type": "string"}},
+                "required": [],
+            },
+            func=danger,
+            risk=risk,
+            preview=lambda target="": f"Do danger on {target}",
+        )
+    )
+    return registry
+
+
+def make_core(responses, registry=None, **kwargs):
+    client = FakeClient(responses)
+    registry = registry or make_registry()
+    core = AgentCore(client, "fake-model", registry, "system", **kwargs)
+    return core, client
+
+
+class AgentCoreTests(unittest.TestCase):
+    def test_plain_answer_passes_through(self):
+        core, _ = make_core([msg("Hello there.")])
+        out = core.run([{"role": "user", "content": "hi"}])
+        self.assertEqual(out, "Hello there.")
+
+    def test_text_json_tool_call_is_executed(self):
+        core, client = make_core(
+            [
+                msg('{"name": "add", "arguments": {"a": 2, "b": 3}}'),
+                msg("The answer is 5."),
+            ]
+        )
+        out = core.run([{"role": "user", "content": "add 2 and 3"}])
+        self.assertEqual(out, "The answer is 5.")
+        # The tool result must have been fed back as a user turn.
+        second_call = client.calls[1]
+        self.assertTrue(
+            any(
+                m["role"] == "user" and "TOOL RESULT (add)" in m["content"]
+                for m in second_call
+            )
+        )
+
+    def test_native_tool_call_is_executed(self):
+        core, _ = make_core(
+            [
+                msg(
+                    "",
+                    tool_calls=[
+                        {"function": {"name": "add", "arguments": {"a": 10, "b": 5}}}
+                    ],
+                ),
+                msg("15"),
+            ]
+        )
+        out = core.run([{"role": "user", "content": "10+5"}])
+        self.assertEqual(out, "15")
+
+    def test_fenced_json_tool_call_is_parsed(self):
+        core, _ = make_core(
+            [msg('```json\n{"name": "add", "arguments": {"a": 1, "b": 1}}\n```'),
+             msg("2")],
+        )
+        out = core.run([{"role": "user", "content": "1+1"}])
+        self.assertEqual(out, "2")
+
+    def test_unknown_tool_is_not_leaked_to_user(self):
+        # Model first emits a bogus tool name, then answers normally after the nudge.
+        core, client = make_core(
+            [
+                msg('{"name": "await", "arguments": {}}'),
+                msg("await pauses an async function."),
+            ]
+        )
+        out = core.run([{"role": "user", "content": "what does await do?"}])
+        self.assertEqual(out, "await pauses an async function.")
+        # A nudge must have been sent telling the model the tool is unknown.
+        self.assertTrue(
+            any(
+                "not a valid tool call" in m["content"]
+                for m in client.calls[1]
+                if m["role"] == "user"
+            )
+        )
+
+    def test_repeated_unknown_tool_gives_up_gracefully(self):
+        core, _ = make_core(
+            [
+                msg('{"name": "await", "arguments": {}}'),
+                msg('{"name": "await", "arguments": {}}'),
+            ]
+        )
+        out = core.run([{"role": "user", "content": "what does await do?"}])
+        self.assertIn("unavailable tool", out)
+
+    def test_bad_arguments_produce_error_result_not_crash(self):
+        core, _ = make_core(
+            [
+                msg('{"name": "add", "arguments": {"a": 1}}'),  # missing "b"
+                msg("Could not add."),
+            ]
+        )
+        out = core.run([{"role": "user", "content": "add"}])
+        self.assertEqual(out, "Could not add.")
+
+    # -- permissions -------------------------------------------------------
+
+    def test_non_safe_tool_denied_when_no_confirmer(self):
+        log = []
+        core, client = make_core(
+            [msg('{"name": "danger", "arguments": {"target": "x"}}'), msg("ok")],
+            registry=make_ask_registry(log),
+        )
+        out = core.run([{"role": "user", "content": "do it"}])
+        self.assertEqual(log, [])  # the tool never ran
+        self.assertEqual(out, "ok")
+        self.assertTrue(
+            any(
+                "PERMISSION DENIED" in m["content"]
+                for m in client.calls[1]
+                if m["role"] == "user"
+            )
+        )
+
+    def test_non_safe_tool_denied_by_user(self):
+        log = []
+        policy = PermissionPolicy(ask=lambda *_a: "no")
+        core, _ = make_core(
+            [msg('{"name": "danger", "arguments": {}}'), msg("fine")],
+            registry=make_ask_registry(log),
+            policy=policy,
+        )
+        core.run([{"role": "user", "content": "do it"}])
+        self.assertEqual(log, [])
+
+    def test_non_safe_tool_runs_when_approved(self):
+        log = []
+        previews = []
+
+        def ask(tool, preview, risk):
+            previews.append(preview)
+            return DECISION_YES
+
+        core, _ = make_core(
+            [msg('{"name": "danger", "arguments": {"target": "x"}}'), msg("done")],
+            registry=make_ask_registry(log),
+            policy=PermissionPolicy(ask=ask),
+        )
+        out = core.run([{"role": "user", "content": "do it"}])
+        self.assertEqual(log, ["x"])  # ran exactly once
+        self.assertTrue(any("Do danger on x" in p for p in previews))
+        self.assertEqual(out, "done")
+
+    def test_safe_tool_is_never_confirmed(self):
+        asked = []
+        policy = PermissionPolicy(
+            ask=lambda tool, preview, risk: asked.append(tool.name) or DECISION_YES
+        )
+        core, _ = make_core(
+            [msg('{"name": "add", "arguments": {"a": 1, "b": 1}}'), msg("2")],
+            policy=policy,
+        )
+        out = core.run([{"role": "user", "content": "1+1"}])
+        self.assertEqual(asked, [])  # safe tool -> no prompt
+        self.assertEqual(out, "2")
+
+    # -- tiers: always / auto-approve / high --------------------------------
+
+    def test_always_decision_is_remembered_for_the_session(self):
+        log = []
+        asked = []
+
+        def ask(tool, preview, risk):
+            asked.append(tool.name)
+            return DECISION_ALWAYS
+
+        policy = PermissionPolicy(ask=ask)
+        core, _ = make_core(
+            [
+                msg('{"name": "danger", "arguments": {"target": "1"}}'),
+                msg("ok1"),
+                msg('{"name": "danger", "arguments": {"target": "2"}}'),
+                msg("ok2"),
+            ],
+            registry=make_ask_registry(log),
+            policy=policy,
+        )
+        messages = [{"role": "user", "content": "go"}]
+        core.run(messages)
+        core.run(messages)
+        self.assertEqual(log, ["1", "2"])  # ran both times
+        self.assertEqual(asked, ["danger"])  # asked only once
+
+    def test_always_is_not_remembered_for_high_risk(self):
+        log = []
+        policy = PermissionPolicy(ask=lambda *_a: DECISION_ALWAYS)
+        core, _ = make_core(
+            [
+                msg('{"name": "danger", "arguments": {}}'),
+                msg("a"),
+                msg('{"name": "danger", "arguments": {}}'),
+                msg("b"),
+            ],
+            registry=make_ask_registry(log, risk=RISK_HIGH),
+            policy=policy,
+        )
+        messages = [{"role": "user", "content": "go"}]
+        core.run(messages)
+        core.run(messages)
+        self.assertEqual(len(log), 2)  # ran each time, permission re-asked
+        self.assertFalse(policy.is_always_allowed("danger"))
+
+    def test_auto_approve_never_bypasses_high_risk(self):
+        log = []
+        asked = []
+        policy = PermissionPolicy(
+            ask=lambda tool, preview, risk: asked.append(tool.name) or DECISION_YES,
+            auto_approve=True,
+        )
+        core, _ = make_core(
+            [msg('{"name": "danger", "arguments": {}}'), msg("x")],
+            registry=make_ask_registry(log, risk=RISK_HIGH),
+            policy=policy,
+        )
+        core.run([{"role": "user", "content": "go"}])
+        # Despite auto-approve, a high-risk action must still be confirmed.
+        self.assertEqual(asked, ["danger"])
+
+    def test_session_allowance_never_bypasses_a_high_risk_call(self):
+        # One tool whose risk depends on its arguments (like run_command).
+        log = []
+        registry = ToolRegistry()
+
+        def dyn(target=""):
+            log.append(target)
+            return "done"
+
+        registry.register(
+            Tool(
+                name="dyn",
+                description="dynamic risk",
+                parameters={
+                    "type": "object",
+                    "properties": {"target": {"type": "string"}},
+                    "required": [],
+                },
+                func=dyn,
+                risk=RISK_ASK,
+                risk_func=lambda target="": (
+                    RISK_HIGH if target == "danger" else RISK_ASK
+                ),
+                preview=lambda target="": f"dyn {target}",
+            )
+        )
+        asked = []
+        policy = PermissionPolicy(ask=lambda t, p, r: asked.append(r) or "always")
+        core, _ = make_core(
+            [
+                msg('{"name": "dyn", "arguments": {"target": "ok"}}'),
+                msg("a"),
+                msg('{"name": "dyn", "arguments": {"target": "danger"}}'),
+                msg("b"),
+            ],
+            registry=registry,
+            policy=policy,
+        )
+        messages = [{"role": "user", "content": "go"}]
+        core.run(messages)  # ask tier -> 'always' remembered
+        core.run(messages)  # high tier -> must ask again despite 'always'
+        self.assertEqual(log, ["ok", "danger"])
+        self.assertEqual(asked, [RISK_ASK, RISK_HIGH])
+
+    def test_auto_approve_skips_the_ask_tier(self):
+        log = []
+        asked = []
+        policy = PermissionPolicy(
+            ask=lambda tool, preview, risk: asked.append(tool.name) or "no",
+            auto_approve=True,
+        )
+        core, _ = make_core(
+            [msg('{"name": "danger", "arguments": {"target": "x"}}'), msg("done")],
+            registry=make_ask_registry(log),
+            policy=policy,
+        )
+        core.run([{"role": "user", "content": "go"}])
+        self.assertEqual(log, ["x"])  # ran without asking
+        self.assertEqual(asked, [])
+
+    def test_max_steps_is_enforced(self):
+        # Always returns a tool call -> must stop rather than loop forever.
+        core, _ = make_core(
+            [msg('{"name": "add", "arguments": {"a": 1, "b": 1}}')] * 3,
+            max_steps=3,
+        )
+        out = core.run([{"role": "user", "content": "add"}])
+        self.assertIn("maximum number of tool steps", out)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/tests/test_capabilities.py

@@ -0,0 +1,169 @@
+"""Tests for Phases 10-14: verification, rules, context, memory, git.
+
+Run from the project root:
+    python tests/test_capabilities.py
+"""
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from agent.context import message_size, trim_messages  # noqa: E402
+from agent.gitaware import changed_files, is_git_repo  # noqa: E402
+from agent.gitaware import status as git_status  # noqa: E402
+from agent.memory import Memory  # noqa: E402
+from agent.rules import build_system_prompt, find_rules_file, load_rules  # noqa: E402
+from agent.verification import detect_checks, format_checks  # noqa: E402
+from agent.workspace import Workspace  # noqa: E402
+
+
+class Base(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        self.ws = Workspace(self.root)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+
+# -- Phase 11: rules -------------------------------------------------------
+
+
+class RulesTests(Base):
+    def test_loads_agents_md(self):
+        (self.root / "AGENTS.md").write_text("# Rules\nBe careful.\n", encoding="utf-8")
+        text, source = load_rules(self.ws)
+        self.assertIn("Be careful", text)
+        self.assertEqual(source, "AGENTS.md")
+
+    def test_no_rules_returns_empty(self):
+        self.assertEqual(load_rules(self.ws), ("", None))
+        self.assertIsNone(find_rules_file(self.ws))
+
+    def test_build_system_prompt_injects_rules(self):
+        out = build_system_prompt("BASE", "Do not refactor.", "AGENTS.md")
+        self.assertIn("BASE", out)
+        self.assertIn("PROJECT RULES", out)
+        self.assertIn("Do not refactor.", out)
+
+    def test_build_system_prompt_without_rules_is_unchanged(self):
+        self.assertEqual(build_system_prompt("BASE", "", None), "BASE")
+
+
+# -- Phase 12: context -----------------------------------------------------
+
+
+class ContextTests(unittest.TestCase):
+    def test_no_trim_when_under_budget(self):
+        messages = [{"role": "system", "content": "s"}, {"role": "user", "content": "hi"}]
+        self.assertEqual(trim_messages(messages, 10_000), messages)
+
+    def test_trims_oldest_and_notes_it(self):
+        messages = [{"role": "system", "content": "sys"}]
+        for i in range(20):
+            messages.append({"role": "user", "content": f"message-{i}-" + "x" * 100})
+        out = trim_messages(messages, 500)
+        self.assertLess(message_size(out), 500 + 200)
+        # newest kept, oldest dropped, and a note explaining it
+        self.assertTrue(any("message-19" in str(m.get("content")) for m in out))
+        self.assertTrue(any("omitted" in str(m.get("content")) for m in out))
+        # the system prompt is preserved
+        self.assertEqual(out[0]["role"], "system")
+        self.assertIn("sys", out[0]["content"])
+
+
+# -- Phase 13: memory ------------------------------------------------------
+
+
+class MemoryTests(Base):
+    def test_history_roundtrip(self):
+        mem = Memory(self.ws)
+        mem.save_history([{"role": "user", "content": "hello"}])
+        self.assertEqual(mem.load_history(), [{"role": "user", "content": "hello"}])
+        self.assertTrue((self.root / ".agent" / "history.json").exists())
+
+    def test_notes_roundtrip(self):
+        mem = Memory(self.ws)
+        mem.add_note("Uses Laravel 11")
+        self.assertEqual(mem.load_notes(), ["Uses Laravel 11"])
+
+    def test_clear_removes_files(self):
+        mem = Memory(self.ws)
+        mem.save_history([{"role": "user", "content": "x"}])
+        mem.add_note("y")
+        mem.clear()
+        self.assertEqual(mem.load_history(), [])
+        self.assertEqual(mem.load_notes(), [])
+
+    def test_summary_mentions_paths(self):
+        mem = Memory(self.ws)
+        self.assertIn("history", mem.summary())
+
+
+# -- Phase 10: verification ------------------------------------------------
+
+
+class VerificationTests(Base):
+    def test_detects_npm_scripts_smallest_first(self):
+        (self.root / "package.json").write_text(
+            json.dumps({"scripts": {"build": "vite build", "test": "jest", "lint": "eslint"}}),
+            encoding="utf-8",
+        )
+        checks = detect_checks(self.ws)
+        commands = [c.command for c in checks]
+        self.assertIn("npm run lint", commands)
+        self.assertIn("npm run test", commands)
+        self.assertIn("npm run build", commands)
+        self.assertEqual(commands[0], "npm run lint")  # smallest/fastest first
+
+    def test_detects_python_tests(self):
+        (self.root / "tests").mkdir()
+        self.assertIn("python -m pytest -q", [c.command for c in detect_checks(self.ws)])
+
+    def test_detects_laravel(self):
+        (self.root / "composer.json").write_text("{}", encoding="utf-8")
+        (self.root / "artisan").write_text("", encoding="utf-8")
+        self.assertIn("php artisan test", [c.command for c in detect_checks(self.ws)])
+
+    def test_no_checks_message(self):
+        self.assertIn("No standard", format_checks(self.ws))
+
+
+# -- Phase 14: git ---------------------------------------------------------
+
+
+class GitTests(Base):
+    def test_non_repo(self):
+        self.assertFalse(is_git_repo(self.ws))
+        self.assertIn("not a git repository", git_status(self.ws).lower())
+        self.assertEqual(changed_files(self.ws), [])
+
+    def test_real_repo_status(self):
+        try:
+            subprocess.run(
+                ["git", "init"],
+                cwd=str(self.root),
+                capture_output=True,
+                timeout=20,
+                check=False,
+            )
+        except (OSError, subprocess.TimeoutExpired):
+            self.skipTest("git not available")
+        if not is_git_repo(self.ws):
+            self.skipTest("git init did not create a repo")
+
+        (self.root / "new_file.txt").write_text("hi", encoding="utf-8")
+        report = git_status(self.ws)
+        self.assertIn("new_file.txt", report)
+        self.assertIn("new_file.txt", changed_files(self.ws))
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/tests/test_edits.py

@@ -0,0 +1,117 @@
+"""Deterministic tests for the file-modification module — no model, no network.
+
+Run from the project root:
+    python tests/test_edits.py
+"""
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from agent.edits import (  # noqa: E402
+    create_file,
+    edit_file,
+    preview_create,
+    preview_edit,
+)
+from agent.workspace import Workspace  # noqa: E402
+
+
+class EditTests(unittest.TestCase):
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self._tmp.name)
+        (self.root / "existing.txt").write_text("hello world\n", encoding="utf-8")
+        (self.root / "dup.txt").write_text("cat\ncat\n", encoding="utf-8")
+        self.ws = Workspace(self.root)
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    # -- create ------------------------------------------------------------
+
+    def test_create_new_file(self):
+        out = create_file(self.ws, "new.txt", "content here\n")
+        self.assertIn("Created", out)
+        self.assertEqual((self.root / "new.txt").read_text(encoding="utf-8"), "content here\n")
+
+    def test_create_refuses_to_overwrite(self):
+        out = create_file(self.ws, "existing.txt", "CLOBBERED")
+        self.assertIn("already exists", out)
+        # original file untouched
+        self.assertEqual((self.root / "existing.txt").read_text(encoding="utf-8"), "hello world\n")
+
+    def test_create_can_make_parent_dirs(self):
+        out = create_file(self.ws, "pkg/sub/new.txt", "x")
+        self.assertIn("Created", out)
+        self.assertTrue((self.root / "pkg" / "sub" / "new.txt").exists())
+
+    def test_create_outside_root_rejected(self):
+        out = create_file(self.ws, "../evil.txt", "x")
+        self.assertIn("ERROR", out)
+        self.assertFalse((self.root.parent / "evil.txt").exists())
+
+    def test_create_requires_path(self):
+        self.assertIn("ERROR", create_file(self.ws, "", "x"))
+
+    def test_create_rejects_non_string_content(self):
+        self.assertIn("ERROR", create_file(self.ws, "n.txt", None))  # type: ignore[arg-type]
+
+    # -- edit --------------------------------------------------------------
+
+    def test_edit_replaces_unique_text(self):
+        out = edit_file(self.ws, "existing.txt", "hello", "goodbye")
+        self.assertIn("Updated", out)
+        self.assertEqual((self.root / "existing.txt").read_text(encoding="utf-8"), "goodbye world\n")
+
+    def test_edit_reports_when_text_missing(self):
+        out = edit_file(self.ws, "existing.txt", "not-there", "x")
+        self.assertIn("was not found", out)
+        self.assertEqual((self.root / "existing.txt").read_text(encoding="utf-8"), "hello world\n")
+
+    def test_edit_ambiguous_requires_replace_all(self):
+        out = edit_file(self.ws, "dup.txt", "cat", "dog")
+        self.assertIn("occurrences", out)
+        # nothing changed
+        self.assertEqual((self.root / "dup.txt").read_text(encoding="utf-8"), "cat\ncat\n")
+
+    def test_edit_replace_all(self):
+        out = edit_file(self.ws, "dup.txt", "cat", "dog", replace_all=True)
+        self.assertIn("2 occurrence", out)
+        self.assertEqual((self.root / "dup.txt").read_text(encoding="utf-8"), "dog\ndog\n")
+
+    def test_edit_missing_file(self):
+        out = edit_file(self.ws, "nope.txt", "a", "b")
+        self.assertIn("does not exist", out)
+
+    def test_edit_rejects_empty_old_text(self):
+        self.assertIn("ERROR", edit_file(self.ws, "existing.txt", "", "x"))
+
+    def test_edit_binary_file_refused(self):
+        (self.root / "blob.bin").write_bytes(b"\x00\x01hello")
+        out = edit_file(self.ws, "blob.bin", "hello", "bye")
+        self.assertIn("binary", out.lower())
+
+    def test_edit_outside_root_rejected(self):
+        out = edit_file(self.ws, "../evil.txt", "a", "b")
+        self.assertIn("ERROR", out)
+
+    # -- previews ----------------------------------------------------------
+
+    def test_preview_create_shows_additions(self):
+        out = preview_create("new.txt", "line one\nline two")
+        self.assertIn("CREATE new.txt", out)
+        self.assertIn("+ line one", out)
+
+    def test_preview_edit_shows_both_sides(self):
+        out = preview_edit("existing.txt", "hello", "goodbye")
+        self.assertIn("- hello", out)
+        self.assertIn("+ goodbye", out)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)