flowent 0.0.1 → 0.0.4

package/backend/tests/unit/tools/test_edit_tool.py

@@ -0,0 +1,115 @@
+import json
+
+from flowent.agent import Agent
+from flowent.models import NodeConfig, NodeType
+from flowent.tools.edit import EditTool
+
+
+def test_edit_tool_applies_multiple_edits_in_sequence(tmp_path):
+    target = tmp_path / "sample.txt"
+    target.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            tools=["edit"],
+            write_dirs=[str(tmp_path)],
+        )
+    )
+
+    result = json.loads(
+        EditTool().execute(
+            agent,
+            {
+                "path": str(target),
+                "edits": [
+                    {
+                        "start_line": 2,
+                        "end_line": 2,
+                        "new_content": "beta-1\nbeta-2\n",
+                    },
+                    {
+                        "start_line": 4,
+                        "end_line": 4,
+                        "new_content": "gamma-updated\n",
+                    },
+                ],
+            },
+        )
+    )
+
+    assert result["status"] == "edited"
+    assert (
+        target.read_text(encoding="utf-8") == "alpha\nbeta-1\nbeta-2\ngamma-updated\n"
+    )
+
+
+def test_edit_tool_creates_missing_file_with_edits(tmp_path):
+    target = tmp_path / "new.txt"
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            tools=["edit"],
+            write_dirs=[str(tmp_path)],
+        )
+    )
+
+    result = json.loads(
+        EditTool().execute(
+            agent,
+            {
+                "path": str(target),
+                "edits": [
+                    {
+                        "start_line": 1,
+                        "end_line": 1,
+                        "new_content": "hello\nworld\n",
+                    }
+                ],
+            },
+        )
+    )
+
+    assert result["status"] == "edited"
+    assert target.read_text(encoding="utf-8") == "hello\nworld\n"
+
+
+def test_edit_tool_streams_progress_updates(tmp_path):
+    target = tmp_path / "sample.txt"
+    target.write_text("alpha\nbeta\ngamma\n", encoding="utf-8")
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            tools=["edit"],
+            write_dirs=[str(tmp_path)],
+        )
+    )
+    chunks: list[str] = []
+
+    result = json.loads(
+        EditTool().execute(
+            agent,
+            {
+                "path": str(target),
+                "edits": [
+                    {
+                        "start_line": 2,
+                        "end_line": 2,
+                        "new_content": "beta-updated\n",
+                    },
+                    {
+                        "start_line": 3,
+                        "end_line": 3,
+                        "new_content": "gamma-updated\n",
+                    },
+                ],
+            },
+            on_output=chunks.append,
+        )
+    )
+
+    assert result["status"] == "edited"
+    assert "".join(chunks) == (
+        f"Applying edit 1/2 at lines 2-2\n"
+        f"Applying edit 2/2 at lines 3-3\n"
+        f"Wrote {target}\n"
+    )

package/backend/tests/unit/tools/test_exec_tool.py

@@ -0,0 +1,81 @@
+import json
+import shutil
+import subprocess
+
+import pytest
+
+from flowent.agent import Agent
+from flowent.models import NodeConfig, NodeType
+from flowent.settings import Settings
+from flowent.tools.exec import ExecTool
+
+
+def _sandbox_exec_supported(tmp_path) -> bool:
+    if shutil.which("bwrap") is None:
+        return False
+
+    probe = subprocess.run(
+        [
+            "bwrap",
+            "--ro-bind",
+            "/",
+            "/",
+            "--dev",
+            "/dev",
+            "--proc",
+            "/proc",
+            "--tmpfs",
+            "/tmp",
+            "--ro-bind",
+            str(tmp_path),
+            str(tmp_path),
+            "--chdir",
+            str(tmp_path),
+            "--die-with-parent",
+            "--new-session",
+            "--",
+            "bash",
+            "-c",
+            "pwd >/dev/null",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    return probe.returncode == 0
+
+
+def test_exec_tool_runs_in_working_dir_when_tmp_is_sandboxed(
+    monkeypatch,
+    tmp_path,
+):
+    if not _sandbox_exec_supported(tmp_path):
+        pytest.skip("bwrap sandbox is unavailable in this environment")
+
+    target = tmp_path / "settings.json"
+    target.write_text('{"name": "demo"}\n', encoding="utf-8")
+    monkeypatch.setattr(
+        "flowent.settings.get_settings",
+        lambda: Settings(working_dir=str(tmp_path)),
+    )
+
+    agent = Agent(
+        NodeConfig(
+            node_type=NodeType.AGENT,
+            tools=["exec"],
+            write_dirs=[],
+        )
+    )
+
+    result = json.loads(
+        ExecTool().execute(
+            agent,
+            {
+                "command": "pwd; cat settings.json",
+                "timeout": 30,
+            },
+        )
+    )
+
+    assert result["returncode"] == 0
+    assert result["stdout"] == f"{tmp_path}\n" + '{"name": "demo"}\n'
+    assert result["stderr"] == ""

package/backend/tests/unit/tools/test_fetch_tool.py

@@ -0,0 +1,65 @@
+import json
+
+from flowent.agent import Agent
+from flowent.models import NodeConfig, NodeType
+from flowent.tools.fetch import FetchTool
+
+
+class _FakeResponse:
+    def __init__(self, status_code: int, chunks: list[str]):
+        self.status_code = status_code
+        self._chunks = chunks
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+    def iter_content(self):
+        for chunk in self._chunks:
+            yield chunk.encode()
+
+
+class _FakeClient:
+    last_impersonate_browser: bool | None = None
+
+    def __init__(self, *, timeout: float, impersonate_browser: bool = False):
+        self.timeout = timeout
+        self.impersonate_browser = impersonate_browser
+        type(self).last_impersonate_browser = impersonate_browser
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, tb):
+        return False
+
+    def stream(self, method, url, headers=None, data=None):
+        assert method == "GET"
+        assert url == "https://example.com/data"
+        assert headers is None
+        assert data is None
+        return _FakeResponse(200, ["hello ", "world"])
+
+
+def test_fetch_tool_streams_response_body_chunks(monkeypatch):
+    agent = Agent(
+        NodeConfig(node_type=NodeType.AGENT, tools=["fetch"], allow_network=True)
+    )
+    chunks: list[str] = []
+    _FakeClient.last_impersonate_browser = None
+
+    monkeypatch.setattr("flowent.tools.fetch.create_http_session", _FakeClient)
+
+    result = json.loads(
+        FetchTool().execute(
+            agent,
+            {"method": "GET", "url": "https://example.com/data"},
+            on_output=chunks.append,
+        )
+    )
+
+    assert result == {"status_code": 200, "body": "hello world"}
+    assert "".join(chunks) == "GET https://example.com/data\nHTTP 200\n\nhello world"
+    assert _FakeClient.last_impersonate_browser is True

package/backend/tests/unit/tools/test_manage_prompts_tool.py

@@ -0,0 +1,117 @@
+import json
+
+from flowent.agent import Agent
+from flowent.models import NodeConfig, NodeType
+from flowent.settings import Settings
+from flowent.tools.manage_prompts import ManagePromptsTool
+
+
+def test_manage_prompts_get_returns_current_prompt(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
+    settings = Settings(
+        custom_prompt="Be concise.",
+        custom_post_prompt="Stay routed.",
+    )
+
+    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
+
+    result = json.loads(ManagePromptsTool().execute(agent, {"action": "get"}))
+
+    assert result == {
+        "custom_prompt": "Be concise.",
+        "custom_post_prompt": "Stay routed.",
+    }
+
+
+def test_manage_prompts_update_saves_custom_prompt(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
+    settings = Settings(custom_prompt="", custom_post_prompt="")
+    saved: list[Settings] = []
+
+    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.settings.save_settings", lambda current: saved.append(current)
+    )
+
+    result = json.loads(
+        ManagePromptsTool().execute(
+            agent,
+            {
+                "action": "update",
+                "custom_prompt": "Always prefer terse answers.",
+                "custom_post_prompt": "Only route with @target.",
+            },
+        )
+    )
+
+    assert result == {
+        "custom_prompt": "Always prefer terse answers.",
+        "custom_post_prompt": "Only route with @target.",
+    }
+    assert settings.custom_prompt == "Always prefer terse answers."
+    assert settings.custom_post_prompt == "Only route with @target."
+    assert saved == [settings]
+
+
+def test_manage_prompts_update_requires_prompt_field(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
+    monkeypatch.setattr("flowent.settings.get_settings", lambda: Settings())
+
+    result = json.loads(
+        ManagePromptsTool().execute(
+            agent,
+            {"action": "update"},
+        )
+    )
+
+    assert result == {"error": "custom_prompt or custom_post_prompt is required"}
+
+
+def test_manage_prompts_update_allows_custom_post_prompt_only(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
+    settings = Settings(custom_prompt="Keep this.", custom_post_prompt="")
+
+    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
+    monkeypatch.setattr("flowent.settings.save_settings", lambda current: None)
+
+    result = json.loads(
+        ManagePromptsTool().execute(
+            agent,
+            {
+                "action": "update",
+                "custom_post_prompt": "Append this after history.",
+            },
+        )
+    )
+
+    assert result == {
+        "custom_prompt": "Keep this.",
+        "custom_post_prompt": "Append this after history.",
+    }
+    assert settings.custom_prompt == "Keep this."
+    assert settings.custom_post_prompt == "Append this after history."
+
+
+def test_manage_prompts_update_accepts_legacy_post_prompt_alias(monkeypatch):
+    agent = Agent(NodeConfig(node_type=NodeType.ASSISTANT, tools=["manage_prompts"]))
+    settings = Settings(custom_prompt="Keep this.", custom_post_prompt="")
+
+    monkeypatch.setattr("flowent.settings.get_settings", lambda: settings)
+    monkeypatch.setattr("flowent.settings.save_settings", lambda current: None)
+
+    result = json.loads(
+        ManagePromptsTool().execute(
+            agent,
+            {
+                "action": "update",
+                "post_prompt": "Append this after history.",
+            },
+        )
+    )
+
+    assert result == {
+        "custom_prompt": "Keep this.",
+        "custom_post_prompt": "Append this after history.",
+    }
+    assert settings.custom_prompt == "Keep this."
+    assert settings.custom_post_prompt == "Append this after history."