kolega-code 0.5.0__tar.gz → 0.5.1__tar.gz

{kolega_code-0.5.0 → kolega_code-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kolega-code
-Version: 0.5.0
+Version: 0.5.1
 Summary: Local-first AI coding agent for the terminal
 Project-URL: Homepage, https://kolega-ai.github.io/kolega-code/
 Project-URL: Documentation, https://kolega-ai.github.io/kolega-code/

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/__init__.py

@@ -148,4 +148,4 @@ __all__ = [
     "parse_git_status_output",
 ]
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "ToolExtension",
 ]
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/coder.py

@@ -116,7 +116,6 @@ class CoderAgent(BaseAgent, LogMixin):
             "get_tool_list",
             "log_error",
             "log_info",
-            "run_command",  # Disabled: unreliable completion detection, use run_command_tracked instead
             # Exclude task-specific dispatch tools since coder shouldn't call itself or other agents
             "dispatch_coding_agent",
         ]

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/generalagent.py

@@ -112,7 +112,6 @@ class GeneralAgent(BaseAgent):
             "get_tool_list",
             "log_error",
             "log_info",
-            "run_command",  # Disabled: unreliable completion detection, use run_command_tracked instead
             # Recursion guard: a general sub-agent may not spawn further sub-agents
             *ToolCollection.agent_dispatch_tools,
         ]

kolega_code-0.5.1/kolega_code/agent/tests/services/test_sandbox_terminal_input.py

@@ -0,0 +1,129 @@
+import asyncio
+from types import SimpleNamespace
+
+import pytest
+
+from kolega_code.sandbox.terminal import SandboxTerminalManager
+
+
+class FakeCommandHandle:
+    def __init__(self, pid: int = 123, exit_code: int = 0):
+        self.pid = pid
+        self._done = asyncio.Event()
+        self._exit_code = exit_code
+        self.killed = False
+
+    async def wait(self):
+        await self._done.wait()
+        return SimpleNamespace(exit_code=self._exit_code)
+
+    def complete(self) -> None:
+        self._done.set()
+
+    async def kill(self) -> None:
+        self.killed = True
+        self._exit_code = 137
+        self._done.set()
+
+
+class FakeCommands:
+    def __init__(self):
+        self.handle = FakeCommandHandle()
+        self.run_calls = []
+        self.send_stdin_calls = []
+        self.started = asyncio.Event()
+
+    async def run(self, command: str, **kwargs):
+        if command.startswith("test -d") or command.startswith("mkdir"):
+            return SimpleNamespace(exit_code=0)
+
+        self.run_calls.append((command, kwargs))
+        self.started.set()
+        on_stdout = kwargs.get("on_stdout")
+        if on_stdout:
+            await on_stdout("line1\n")
+        return self.handle
+
+    async def send_stdin(self, pid: int, data: str):
+        self.send_stdin_calls.append((pid, data))
+
+
+class FakeSandbox:
+    def __init__(self):
+        self.commands = FakeCommands()
+
+
+@pytest.mark.asyncio
+async def test_exec_command_runs_background_with_stdin():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+
+    result = await manager.exec_command("python prompt.py", yield_time_ms=300)
+
+    assert sandbox.commands.run_calls
+    _, kwargs = sandbox.commands.run_calls[0]
+    assert kwargs["background"] is True
+    assert kwargs["stdin"] is True
+    # Still waiting on input -> reported as a running session.
+    assert result.status == "running"
+    assert result.session_id is not None
+    assert "line1" in result.output
+
+
+@pytest.mark.asyncio
+async def test_write_stdin_sends_raw_input_and_reports_exit():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+
+    result = await manager.exec_command("python prompt.py", yield_time_ms=300)
+    session_id = result.session_id
+
+    running = await manager.write_stdin(session_id, "Ada\n", yield_time_ms=200)
+    assert (123, "Ada\n") in sandbox.commands.send_stdin_calls
+    assert running.status == "running"
+
+    sandbox.commands.handle.complete()
+    final = await manager.write_stdin(session_id, "", yield_time_ms=2000)
+    assert final.status == "exited"
+    assert final.exit_code == 0
+
+
+@pytest.mark.asyncio
+async def test_kill_session_kills_handle():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+
+    result = await manager.exec_command("sleep 100", yield_time_ms=200)
+    assert result.status == "running"
+
+    killed = await manager.kill_session(result.session_id, "TERM")
+    assert sandbox.commands.handle.killed is True
+    assert killed.status == "exited"
+
+
+@pytest.mark.asyncio
+async def test_kill_session_interrupt_sends_ctrl_c():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+
+    result = await manager.exec_command("sleep 100", yield_time_ms=200)
+    await manager.kill_session(result.session_id, "INT")
+    assert (123, "\x03") in sandbox.commands.send_stdin_calls
+
+
+@pytest.mark.asyncio
+async def test_list_sessions_reports_running():
+    sandbox = FakeSandbox()
+    manager = SandboxTerminalManager(sandbox, "workspace", "thread")
+
+    result = await manager.exec_command("sleep 100", yield_time_ms=200)
+    sessions = await manager.list_sessions()
+    assert result.session_id in sessions
+    assert sessions[result.session_id]["running"] is True
+
+
+@pytest.mark.asyncio
+async def test_write_stdin_unknown_session_raises():
+    manager = SandboxTerminalManager(FakeSandbox(), "workspace", "thread")
+    with pytest.raises(KeyError):
+        await manager.write_stdin("nope", "x")

kolega_code-0.5.1/kolega_code/agent/tests/services/test_terminal.py

@@ -0,0 +1,139 @@
+import pytest
+
+from kolega_code.services.terminal import LocalTerminalManager
+
+
+@pytest.fixture
+def manager():
+    # connection_manager=None: output broadcasting is skipped in tests.
+    return LocalTerminalManager("workspace", "thread", None)
+
+
+@pytest.mark.asyncio
+async def test_exec_command_success(manager):
+    result = await manager.exec_command("echo hello world", yield_time_ms=5000)
+    assert result.status == "exited"
+    assert result.exit_code == 0
+    assert "hello world" in result.output
+    assert result.session_id is None
+
+
+@pytest.mark.asyncio
+async def test_exec_command_nonzero_exit_code(manager):
+    result = await manager.exec_command("exit 7", yield_time_ms=5000)
+    assert result.status == "exited"
+    assert result.exit_code == 7
+
+
+@pytest.mark.asyncio
+async def test_exec_command_failing_command_is_nonzero(manager):
+    result = await manager.exec_command("ls /this_path_does_not_exist_xyz", yield_time_ms=5000)
+    assert result.status == "exited"
+    assert result.exit_code != 0
+
+
+@pytest.mark.asyncio
+async def test_long_running_returns_session_then_completes(manager):
+    result = await manager.exec_command("echo start; sleep 1; echo done", yield_time_ms=250)
+    assert result.status == "running"
+    assert result.session_id is not None
+    session_id = result.session_id
+
+    for _ in range(40):
+        result = await manager.write_stdin(session_id, "", yield_time_ms=2000)
+        if result.status == "exited":
+            break
+    assert result.status == "exited"
+    assert result.exit_code == 0
+    assert "done" in result.output
+
+
+@pytest.mark.asyncio
+async def test_interactive_stdin(manager):
+    result = await manager.exec_command('printf "P> "; read x; echo got=$x', yield_time_ms=400)
+    assert result.status == "running"
+    assert "P>" in result.output
+
+    result = await manager.write_stdin(result.session_id, "ada\n", yield_time_ms=3000)
+    assert result.status == "exited"
+    assert "got=ada" in result.output
+
+
+@pytest.mark.asyncio
+async def test_kill_session_interrupt_reports_130(manager):
+    result = await manager.exec_command("sleep 30", yield_time_ms=300)
+    assert result.status == "running"
+    killed = await manager.kill_session(result.session_id, "INT")
+    assert killed.status == "exited"
+    assert killed.exit_code == 130
+
+
+@pytest.mark.asyncio
+async def test_kill_session_term(manager):
+    result = await manager.exec_command("sleep 30", yield_time_ms=300)
+    killed = await manager.kill_session(result.session_id, "TERM")
+    assert killed.status == "exited"
+    # SIGTERM -> 143, or SIGKILL fallback -> 137
+    assert killed.exit_code in (143, 137)
+
+
+@pytest.mark.asyncio
+async def test_list_sessions_tracks_running_and_clears(manager):
+    result = await manager.exec_command("sleep 5", yield_time_ms=200)
+    sessions = await manager.list_sessions()
+    assert result.session_id in sessions
+    assert sessions[result.session_id]["running"] is True
+
+    await manager.kill_session(result.session_id, "TERM")
+    assert result.session_id not in await manager.list_sessions()
+
+
+@pytest.mark.asyncio
+async def test_write_stdin_unknown_session_raises(manager):
+    with pytest.raises(KeyError):
+        await manager.write_stdin("does_not_exist")
+
+
+@pytest.mark.asyncio
+async def test_kill_unknown_session_raises(manager):
+    with pytest.raises(KeyError):
+        await manager.kill_session("does_not_exist")
+
+
+@pytest.mark.asyncio
+async def test_run_command_convenience_accumulates_output(manager):
+    output = await manager.run_command("echo a; echo b; echo c")
+    assert "a" in output and "b" in output and "c" in output
+
+
+@pytest.mark.asyncio
+async def test_workdir_is_respected(manager, tmp_path):
+    result = await manager.exec_command("pwd", workdir=str(tmp_path), yield_time_ms=3000)
+    assert result.status == "exited"
+    # macOS resolves symlinks (/var -> /private/var); the leaf dir is enough.
+    assert result.output.strip().endswith(tmp_path.name)
+
+
+@pytest.mark.asyncio
+async def test_no_cwd_persistence_between_calls(manager, tmp_path):
+    sub = tmp_path / "sub"
+    sub.mkdir()
+    # cd in one call must NOT affect the next (fresh process per exec).
+    await manager.exec_command(f"cd {sub}", workdir=str(tmp_path), yield_time_ms=3000)
+    result = await manager.exec_command("pwd", workdir=str(tmp_path), yield_time_ms=3000)
+    assert result.output.strip().endswith(tmp_path.name)
+
+
+@pytest.mark.asyncio
+async def test_clean_env_overlay(manager):
+    result = await manager.exec_command("echo $NO_COLOR-$TERM-$PAGER", yield_time_ms=3000)
+    assert "1-dumb-cat" in result.output
+
+
+@pytest.mark.asyncio
+async def test_close_all_terminates_sessions(manager):
+    await manager.exec_command("sleep 30", yield_time_ms=200)
+    await manager.exec_command("sleep 30", yield_time_ms=200)
+    assert len(manager.sessions) == 2
+    await manager.close_all()
+    assert len(manager.sessions) == 0

kolega_code-0.5.1/kolega_code/agent/tests/services/test_terminal_buffer.py

@@ -0,0 +1,71 @@
+from kolega_code.services.terminal_buffer import (
+    MAX_POLL_MS,
+    MAX_YIELD_MS,
+    MIN_POLL_MS,
+    MIN_YIELD_MS,
+    HeadTailBuffer,
+    cap_tokens,
+    clamp_yield,
+)
+
+
+def test_headtail_no_truncation():
+    buffer = HeadTailBuffer(head_bytes=10, tail_bytes=10)
+    buffer.append(b"hello")
+    assert buffer.text() == "hello"
+    assert buffer.omitted_bytes == 0
+
+
+def test_headtail_truncates_middle_with_marker():
+    buffer = HeadTailBuffer(head_bytes=5, tail_bytes=5)
+    buffer.append(b"A" * 5 + b"B" * 100 + b"C" * 5)
+    text = buffer.text()
+    assert text.startswith("AAAAA")
+    assert text.endswith("CCCCC")
+    assert "omitted" in text
+    assert buffer.omitted_bytes == 100
+
+
+def test_headtail_append_in_chunks():
+    buffer = HeadTailBuffer(head_bytes=4, tail_bytes=4)
+    for chunk in (b"12", b"34", b"56", b"78", b"90"):
+        buffer.append(chunk)
+    text = buffer.text()
+    assert text.startswith("1234")
+    assert text.endswith("7890")
+    assert buffer.total_bytes == 10
+    assert buffer.omitted_bytes == 2
+
+
+def test_headtail_reset():
+    buffer = HeadTailBuffer()
+    buffer.append(b"x")
+    buffer.reset()
+    assert buffer.text() == ""
+    assert len(buffer) == 0
+
+
+def test_cap_tokens_under_budget():
+    out = cap_tokens("short text", 1000)
+    assert out.truncated is False
+    assert out.text == "short text"
+
+
+def test_cap_tokens_over_budget_truncates_middle():
+    text = "word " * 5000
+    out = cap_tokens(text, 50)
+    assert out.truncated is True
+    assert out.original_token_count > 50
+    assert "truncated to fit" in out.text
+    assert len(out.text) < len(text)
+
+
+def test_clamp_yield_write():
+    assert clamp_yield(10, poll=False) == MIN_YIELD_MS
+    assert clamp_yield(999999, poll=False) == MAX_YIELD_MS
+    assert clamp_yield(None, poll=False) == 10000
+
+
+def test_clamp_yield_poll():
+    assert clamp_yield(10, poll=True) == MIN_POLL_MS
+    assert clamp_yield(999999, poll=True) == MAX_POLL_MS

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/tests/test_agent_tools_inventory.py

@@ -195,7 +195,7 @@ def test_general_agent_tool_inventory(project_path, mock_connection_manager, age
     assert "search_codebase" in tool_names
     assert "create_file" in tool_names
     assert "replace_entire_file" in tool_names
-    assert "run_command_tracked" in tool_names
+    assert "exec_command" in tool_names
     # Recursion guard: no dispatch tools at all
     assert not any(name.startswith("dispatch_") for name in tool_names)
 
@@ -237,7 +237,7 @@ def test_planning_agent_exposes_read_only_and_planning_tools(project_path, mock_
     assert "create_file" not in tool_names
     assert "replace_entire_file" not in tool_names
     assert "apply_patch" not in tool_names
-    assert "run_command_tracked" not in tool_names
+    assert "exec_command" not in tool_names
     assert tool_names - expected_planning_tools <= set(agent.tool_collection.read_only_tools)
 
 

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/tests/test_permissions.py

@@ -46,7 +46,7 @@ def agent_config():
 
 def test_permission_store_matches_command_rules(tmp_path):
     request = permission_request_for_tool(
-        "run_command_tracked",
+        "exec_command",
         {"command": "npm run test -- --watch=false"},
     )
     assert request is not None
@@ -67,7 +67,7 @@ def test_permission_store_matches_command_rules(tmp_path):
 
 
 def test_allow_rule_options_for_command_include_exact_prefix_and_executable():
-    request = permission_request_for_tool("run_command_tracked", {"command": "npm run test"})
+    request = permission_request_for_tool("exec_command", {"command": "npm run test"})
     assert request is not None
 
     options = allow_rule_options(request)
@@ -100,8 +100,8 @@ async def test_execute_single_tool_denies_gated_tool_before_dispatch(tmp_path, a
             return ToolRegistry(
                 [
                     Tool(
-                        name="run_command_tracked",
-                        definition=ToolDefinition(name="run_command_tracked", description="", parameters=[]),
+                        name="exec_command",
+                        definition=ToolDefinition(name="exec_command", description="", parameters=[]),
                         handler=handler,
                     )
                 ]
@@ -127,8 +127,8 @@ async def test_execute_single_tool_denies_gated_tool_before_dispatch(tmp_path, a
     result = await agent.execute_single_tool(
         ToolCall(
             id="tool_1",
-            name="run_command_tracked",
-            input={"terminal_id": "term", "command": "npm run test", "purpose": "test"},
+            name="exec_command",
+            input={"command": "npm run test"},
             execution_id="exec_1",
         )
     )

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/tests/test_tool_registry.py

@@ -82,7 +82,7 @@ class TestToolCollectionRegistry:
         assert registry.get("read_entire_file").parallel_safe
         assert registry.get("search_codebase").parallel_safe
         assert not registry.get("create_file").parallel_safe
-        assert not registry.get("run_command_tracked").parallel_safe
+        assert not registry.get("exec_command").parallel_safe
 
     def test_get_tool_list_matches_registry_definitions(self, tmp_path):
         from unittest.mock import Mock

{kolega_code-0.5.0 → kolega_code-0.5.1}/kolega_code/agent/tests/test_tools.py

@@ -71,7 +71,7 @@ def tool_collection(
     collection.search_codebase_tool.search_codebase = AsyncMock()
     collection.glob_tool.find_files_by_pattern = AsyncMock()
     collection.web_fetch_tool.web_fetch = AsyncMock()
-    collection.terminal_tool.send_terminal_input = AsyncMock()
+    collection.terminal_tool.write_stdin = AsyncMock()
 
     return collection
 
@@ -214,15 +214,15 @@ class TestToolCollection:
         assert result == expected_response
         tool_collection.terminal_tool.execute_terminal_command.assert_called_once_with(command)
 
-    async def test_send_terminal_input(self, tool_collection: AsyncMock) -> None:
-        expected_response = "Sent input"
-        tool_collection.terminal_tool.send_terminal_input.return_value = expected_response
+    async def test_write_stdin(self, tool_collection: AsyncMock) -> None:
+        expected_response = '{"status": "running"}'
+        tool_collection.terminal_tool.write_stdin.return_value = expected_response
 
-        result = await tool_collection.send_terminal_input("terminal_1", "Ada", submit=True, command_id="cmd_1")
+        result = await tool_collection.write_stdin("s_1", "Ada\n")
 
         assert result == expected_response
-        tool_collection.terminal_tool.send_terminal_input.assert_called_once_with(
-            "terminal_1", "Ada", submit=True, command_id="cmd_1"
+        tool_collection.terminal_tool.write_stdin.assert_called_once_with(
+            "s_1", "Ada\n", yield_time_ms=10000, max_output_tokens=10000
         )
 
     async def test_read_entire_file(self, tool_collection: AsyncMock) -> None:
@@ -457,7 +457,8 @@ class TestToolCollection:
         # Check that excluded tools are not in the list
         excluded_tools = tool_collection.tool_exclusions
         tool_names = [tool.name for tool in tool_list]
-        assert "send_terminal_input" in tool_names
+        assert "exec_command" in tool_names
+        assert "write_stdin" in tool_names
         for excluded_tool in excluded_tools:
             assert excluded_tool not in tool_names