Skip to content

Your lightweight open-source personal agent.

12.5 KB
Raw Blame
from nanobot.providers.base import ToolCallRequest
from nanobot.utils.tool_hints import format_tool_hints


def _tc(name: str, args) -> ToolCallRequest:
    return ToolCallRequest(id="c1", name=name, arguments=args)


def _hint(calls, max_length=40):
    """Shortcut for format_tool_hints."""
    return format_tool_hints(calls, max_length=max_length)


class TestToolHintKnownTools:

    def test_rg_shows_argument_boundaries(self):
        assert _hint([_tc("rg", {"args": ["-n", "hello world", "src"]})]) == 'rg -n "hello world" src'

    def test_rg_shows_regex_and_empty_argument(self):
        assert _hint([_tc("rg", {"args": [r"resolve\(", ""]})]) == 'rg resolve\\( ""'

    def test_rg_truncates_long_arguments(self):
        result = _hint([_tc("rg", {"args": ["x" * 100]})])
        assert result.endswith("…")
        assert len(result) == 43

    def test_read_file_short_path(self):
        result = _hint([_tc("read_file", {"path": "foo.txt"})])
        assert result == 'read foo.txt'

    def test_read_file_long_path(self):
        result = _hint([_tc("read_file", {"path": "/home/user/.local/share/uv/tools/nanobot/agent/loop.py"})])
        assert "loop.py" in result
        assert "read " in result

    def test_write_file_shows_path_not_content(self):
        result = _hint([_tc("write_file", {"path": "docs/api.md", "content": "# API Reference\n\nLong content..."})])
        assert result == "write docs/api.md"

    def test_edit_shows_path(self):
        result = _hint([_tc("edit", {"file_path": "src/main.py", "old_string": "x", "new_string": "y"})])
        assert "main.py" in result
        assert "edit " in result

    def test_grep_shows_pattern(self):
        result = _hint([_tc("grep", {"pattern": "TODO|FIXME", "path": "src"})])
        assert result == 'grep "TODO|FIXME"'

    def test_exec_shows_command(self):
        result = _hint([_tc("exec", {"command": "npm install typescript"})])
        assert result == "$ npm install typescript"

    def test_exec_truncates_long_command(self):
        cmd = "cd /very/long/path && cat file && echo done && sleep 1 && ls -la"
        result = _hint([_tc("exec", {"command": cmd})])
        assert result.startswith("$ ")
        assert len(result) <= 50

    def test_exec_abbreviates_paths_in_command(self):
        cmd = "cd D:\\Documents\\GitHub\\nanobot\\.worktree\\tomain\\nanobot && git diff origin/main...pr-2706 --name-only 2>&1"
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result
        assert "worktree" not in result

    def test_exec_abbreviates_linux_paths(self):
        cmd = "cd /home/user/projects/nanobot/.worktree/tomain && make build"
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result
        assert "projects" not in result

    def test_exec_abbreviates_home_paths(self):
        cmd = "cd ~/projects/nanobot/workspace && pytest tests/"
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result

    def test_exec_abbreviates_quoted_linux_paths_with_spaces(self):
        cmd = 'cd "/home/user/My Documents/project" && pytest tests/'
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result
        assert '"/home/user/My Documents/project"' not in result
        assert '"' in result

    def test_exec_abbreviates_quoted_windows_paths_with_spaces(self):
        cmd = 'cd "C:/Program Files/Git/project" && git status'
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result
        assert '"C:/Program Files/Git/project"' not in result
        assert '"' in result

    def test_exec_chained_commands_truncated_not_mid_path(self):
        cmd = "cd D:\\Documents\\GitHub\\project && npm run build && npm test"
        result = _hint([_tc("exec", {"command": cmd})])
        assert "\u2026/" in result
        assert "npm" in result

    def test_web_search(self):
        result = _hint([_tc("web_search", {"query": "Claude 4 vs GPT-4"})])
        assert result == 'search "Claude 4 vs GPT-4"'

    def test_web_fetch(self):
        result = _hint([_tc("web_fetch", {"url": "https://example.com/page"})])
        assert result == "fetch https://example.com/page"


class TestToolHintMCP:

    def test_mcp_standard_format(self):
        result = _hint([_tc("mcp_4_5v_mcp__analyze_image", {"imageSource": "https://img.jpg", "prompt": "describe"})])
        assert "4_5v" in result
        assert "analyze_image" in result

    def test_mcp_simple_name(self):
        result = _hint([_tc("mcp_github__create_issue", {"title": "Bug fix"})])
        assert "github" in result
        assert "create_issue" in result


class TestToolHintFallback:

    def test_unknown_tool_with_string_arg(self):
        result = _hint([_tc("custom_tool", {"data": "hello world"})])
        assert result == 'custom_tool("hello world")'

    def test_unknown_tool_with_long_arg_truncates(self):
        long_val = "a" * 60
        result = _hint([_tc("custom_tool", {"data": long_val})])
        assert len(result) < 80
        assert "\u2026" in result

    def test_unknown_tool_no_string_arg(self):
        result = _hint([_tc("custom_tool", {"count": 42})])
        assert result == "custom_tool"

    def test_empty_tool_calls(self):
        result = _hint([])
        assert result == ""


class TestToolHintFolding:

    def test_single_call_no_fold(self):
        calls = [_tc("grep", {"pattern": "*.py"})]
        result = _hint(calls)
        assert "\u00d7" not in result

    def test_two_consecutive_different_args_not_folded(self):
        calls = [
            _tc("grep", {"pattern": "*.py"}),
            _tc("grep", {"pattern": "*.ts"}),
        ]
        result = _hint(calls)
        assert "\u00d7" not in result

    def test_two_consecutive_same_args_folded(self):
        calls = [
            _tc("grep", {"pattern": "TODO"}),
            _tc("grep", {"pattern": "TODO"}),
        ]
        result = _hint(calls)
        assert "\u00d7 2" in result

    def test_three_consecutive_different_args_not_folded(self):
        calls = [
            _tc("read_file", {"path": "a.py"}),
            _tc("read_file", {"path": "b.py"}),
            _tc("read_file", {"path": "c.py"}),
        ]
        result = _hint(calls)
        assert "\u00d7" not in result

    def test_different_tools_not_folded(self):
        calls = [
            _tc("grep", {"pattern": "TODO"}),
            _tc("read_file", {"path": "a.py"}),
        ]
        result = _hint(calls)
        assert "\u00d7" not in result

    def test_interleaved_same_tools_not_folded(self):
        calls = [
            _tc("grep", {"pattern": "a"}),
            _tc("read_file", {"path": "f.py"}),
            _tc("grep", {"pattern": "b"}),
        ]
        result = _hint(calls)
        assert "\u00d7" not in result


class TestToolHintMultipleCalls:

    def test_two_different_tools(self):
        calls = [
            _tc("grep", {"pattern": "TODO"}),
            _tc("read_file", {"path": "main.py"}),
        ]
        result = _hint(calls)
        assert 'grep "TODO"' in result
        assert "read main.py" in result
        assert ", " in result


class TestToolHintEdgeCases:

    def test_known_tool_empty_list_args(self):
        result = _hint([_tc("read_file", [])])
        assert result == "read_file"

    def test_known_tool_none_args(self):
        result = _hint([_tc("read_file", None)])
        assert result == "read_file"

    def test_fallback_empty_list_args(self):
        result = _hint([_tc("custom_tool", [])])
        assert result == "custom_tool"

    def test_fallback_none_args(self):
        result = _hint([_tc("custom_tool", None)])
        assert result == "custom_tool"

    def test_list_dir_registered(self):
        result = _hint([_tc("list_dir", {"path": "/tmp"})])
        assert result == "ls /tmp"


class TestToolHintMixedFolding:

    def test_read_read_grep_grep_read(self):
        calls = [
            _tc("read_file", {"path": "a.py"}),
            _tc("read_file", {"path": "b.py"}),
            _tc("grep", {"pattern": "x"}),
            _tc("grep", {"pattern": "y"}),
            _tc("read_file", {"path": "c.py"}),
        ]
        result = _hint(calls)
        assert "\u00d7" not in result
        parts = result.split(", ")
        assert len(parts) == 5


class TestToolHintMaxLength:

    def test_exec_explicit_max_length_limits_hint(self):
        cmd = "cd /very/long/path/to/some/project && npm run build && npm test"
        result = _hint([_tc("exec", {"command": cmd})], max_length=40)
        assert len(result) <= 50
        assert "\u2026" in result

    def test_exec_larger_max_length_shows_more(self):
        cmd = "cd /very/long/path/to/some/project && npm run build && npm test"
        short = _hint([_tc("exec", {"command": cmd})], max_length=40)
        long = _hint([_tc("exec", {"command": cmd})], max_length=120)
        assert len(long) > len(short)
        assert "npm test" in long

    def test_exec_max_length_120_shows_full_command(self):
        cmd = "cd /home/user/project && npm install && npm run build"
        result = _hint([_tc("exec", {"command": cmd})], max_length=120)
        assert "npm run build" in result

    def test_fallback_respects_max_length(self):
        long_val = "a" * 100
        result = _hint([_tc("custom_tool", {"data": long_val})], max_length=60)
        assert "\u2026" in result
        result_40 = _hint([_tc("custom_tool", {"data": long_val})], max_length=40)
        assert len(result) > len(result_40)

    def test_mcp_respects_max_length(self):
        long_url = "https://example.com/very/long/path/to/resource"
        result = _hint([_tc("mcp_github__fetch", {"url": long_url})], max_length=80)
        result_40 = _hint([_tc("mcp_github__fetch", {"url": long_url})], max_length=40)
        assert len(result) >= len(result_40)

    def test_path_type_respects_max_length(self):
        long_path = "/home/user/.local/share/uv/tools/nanobot/agent/loop.py"
        short = _hint([_tc("read_file", {"path": long_path})], max_length=40)
        long = _hint([_tc("read_file", {"path": long_path})], max_length=120)
        assert len(long) > len(short)

    def test_edit_path_respects_max_length(self):
        long_path = "/home/user/projects/nanobot/src/agent/loop.py"
        short = _hint([_tc("edit", {"file_path": long_path})], max_length=40)
        long = _hint([_tc("edit", {"file_path": long_path})], max_length=120)
        assert len(long) > len(short)

    def test_list_dir_path_respects_max_length(self):
        long_path = "/home/user/.local/share/uv/tools/nanobot/"
        short = _hint([_tc("list_dir", {"path": long_path})], max_length=40)
        long = _hint([_tc("list_dir", {"path": long_path})], max_length=120)
        assert len(long) > len(short)

    def test_plain_value_tools_respect_max_length(self):
        """Plain-value tools must truncate like the is_path/is_command branches.

        grep, web_search, x_search and find_files carry no path or command
        structure to fold, so their raw value used to reach the progress hint
        untruncated: a 400-char search query produced a 400-char hint.
        """
        for name, key in (
            ("grep", "pattern"),
            ("web_search", "query"),
            ("x_search", "query"),
            ("find_files", "query"),
        ):
            short = _hint([_tc(name, {key: "x" * 400})], max_length=40)
            long = _hint([_tc(name, {key: "x" * 400})], max_length=120)
            assert len(long) > len(short), name
            assert len(short) <= 40 + 12, name
            assert "\u2026" in short, name

    def test_plain_value_short_value_untouched(self):
        result = _hint([_tc("grep", {"pattern": "TODO|FIXME"})], max_length=40)
        assert result == 'grep "TODO|FIXME"'

    def test_plain_value_exactly_at_max_length_untouched(self):
        query = "a" * 40
        result = _hint([_tc("web_search", {"query": query})], max_length=40)
        assert result == f'search "{query}"'
        assert "\u2026" not in result

    def test_plain_value_one_over_max_length_truncates(self):
        result = _hint([_tc("grep", {"pattern": "a" * 41})], max_length=40)
        assert result == 'grep "' + "a" * 39 + "\u2026" + '"'


class TestToolHintMalformedCalls:

    def test_none_name_is_skipped(self):
        result = _hint([_tc(None, None)])
        assert result == ""

    def test_empty_name_is_skipped(self):
        result = _hint([_tc("", {"path": "foo.txt"})])
        assert result == ""

    def test_none_name_mixed_with_valid_call(self):
        result = _hint([_tc(None, None), _tc("read_file", {"path": "foo.txt"})])
        assert result == "read foo.txt"