voidx 3.4.4__tar.gz → 3.6.0__tar.gz

{voidx-3.4.4/src/voidx.egg-info → voidx-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 3.4.4
+Version: 3.6.0
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Author: chikhamx
 License: MIT

{voidx-3.4.4 → voidx-3.6.0}/pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "httpx>=0.28.0",
     "websockets>=14",
     "pathspec>=0.12",
-    "Pillow>=10.0.0; platform_system == 'Windows'",
+	    "Pillow>=10.0.0; platform_system == 'Windows'",
 ]
 
 [project.scripts]
@@ -55,10 +55,10 @@ where = ["src"]
     "bundled/*/SKILL.md",
 ]
 "voidx.data" = [
-    "templates/*.md",
+    "documents/**/*.md",
 ]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
-pythonpath = ["src"]
-testpaths = ["tests"]
+pythonpath = ["src", "tui"]
+testpaths = ["src/tests", "tui/tests"]

voidx-3.6.0/src/tests/conftest.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+import pytest
+from voidx.memory import store
+
+
+@pytest.fixture(autouse=True)
+def isolated_settings_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path):
+    monkeypatch.setattr("voidx.config.settings._settings_home", lambda: tmp_path)
+    if store._conn is not None:
+        store._conn.close()
+    store._conn = None
+    monkeypatch.setattr(store, "DATA_DIR", tmp_path / ".voidx")
+    yield
+    if store._conn is not None:
+        store._conn.close()
+    store._conn = None

voidx-3.6.0/src/tests/test_agent/conftest.py

@@ -0,0 +1,101 @@
+"""Shared fixtures and helpers for test_agent tests."""
+
+import json
+import sqlite3
+import sys
+from pathlib import Path
+
+
+import pytest
+
+import voidx.memory.store as store
+
+
+@pytest.fixture(autouse=True)
+def isolated_memory_store(tmp_path):
+    if store._conn is not None:
+        store._conn.close()
+    store._conn = None
+    store.DATA_DIR = tmp_path / ".voidx"
+    yield
+    if store._conn is not None:
+        store._conn.close()
+    store._conn = None
+
+
+def _session_dir(session_id: str) -> Path:
+    return store.DATA_DIR / "sessions" / session_id
+
+
+def _read_jsonl(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()]
+
+
+async def _table_names() -> set[str]:
+    rows = await store._fetch_all("SELECT name FROM sqlite_master WHERE type = 'table'")
+    return {str(row["name"]) for row in rows}
+
+
+async def _table_columns(table: str) -> set[str]:
+    rows = await store._fetch_all(f"PRAGMA table_info({table})")
+    return {str(row["name"]) for row in rows}
+
+
+def _create_legacy_db(path: Path, session_id: str, *, title: str = "Legacy") -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path))
+    try:
+        conn.execute(
+            """CREATE TABLE sessions (
+                   id TEXT PRIMARY KEY,
+                   title TEXT NOT NULL DEFAULT 'New session',
+                   workspace TEXT NOT NULL DEFAULT '.',
+                   model_provider TEXT NOT NULL DEFAULT 'anthropic',
+                   model_name TEXT NOT NULL DEFAULT 'claude-sonnet-4-6',
+                   created_at TEXT NOT NULL,
+                   updated_at TEXT NOT NULL
+               )"""
+        )
+        conn.execute(
+            """CREATE TABLE messages (
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   session_id TEXT NOT NULL,
+                   role TEXT NOT NULL,
+                   content TEXT NOT NULL DEFAULT '',
+                   tool_calls TEXT,
+                   tool_call_id TEXT,
+                   created_at TEXT NOT NULL
+               )"""
+        )
+        conn.execute(
+            """INSERT INTO sessions (
+                   id, title, workspace, model_provider, model_name, created_at, updated_at
+               )
+               VALUES (?, ?, '.', 'anthropic', 'claude-sonnet-4-6', '2026-06-14T00:00:00+00:00', '2026-06-14T00:00:00+00:00')""",
+            (session_id, title),
+        )
+        conn.execute(
+            """INSERT INTO messages (session_id, role, content, created_at)
+               VALUES (?, 'user', 'hello', '2026-06-14T00:00:00+00:00')""",
+            (session_id,),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+
+def _create_new_store_db(path: Path, session_id: str, *, title: str = "New Store") -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path))
+    try:
+        store._init_schema(conn)
+        conn.execute(
+            """INSERT INTO sessions (
+                   id, title, workspace, model_provider, model_name, created_at, updated_at, message_count
+               )
+               VALUES (?, ?, '.', 'anthropic', 'claude-sonnet-4-6', '2026-06-14T00:00:00+00:00', '2026-06-14T00:00:00+00:00', 0)""",
+            (session_id, title),
+        )
+        conn.commit()
+    finally:
+        conn.close()

voidx-3.6.0/src/tests/test_agent/graph/run_loop_helpers.py

@@ -0,0 +1,107 @@
+"""Shared helpers for test_run_loop split files."""
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+import voidx.memory.store as store
+
+
+from voidx.agent.graph import VoidXGraph
+from voidx.agent.graph.run_loop import GraphRunLoopMixin
+from voidx.agent.graph.title_mixin import _sanitize_generated_title
+from voidx.config import Config, ModelConfig
+from voidx.llm.usage import UsageStats
+from voidx.tools.task_tracker import TaskTracker
+from voidx.ui.output.dock import BottomInputDock, set_dock
+from voidx.ui.output.events import DockEventConsumer, ui_events
+from voidx.ui.protocol import UiSubmitCommand
+from voidx.runtime.ui_port import runtime_ui_port
+
+
+class FakeTui:
+    instances = []
+
+    def __init__(self, status, commands):
+        self.status = status
+        self.commands = commands
+        FakeTui.instances.append(self)
+
+    async def run(self, on_submit):
+        keep_running = await on_submit("/model reasoning")
+        assert keep_running is True
+
+    def set_external_command_handler(self, handler):
+        self.command_handler = handler
+
+    def consume_quiet_command(self, command: str) -> bool:
+        return command == "/model reasoning"
+
+
+class ExitTui:
+    def __init__(self, status, commands):
+        self.status = status
+        self.commands = commands
+        self.command_handler = None
+
+    async def run(self, on_submit):
+        return
+
+    def set_external_command_handler(self, handler):
+        self.command_handler = handler
+
+
+class NoopMcpManager:
+    def statuses(self):
+        return []
+
+    async def start_all(self):
+        return None
+
+    async def stop_all(self):
+        return None
+
+
+class NoopLspManager:
+    initialized = True
+    initializing = False
+
+    async def initialize(self):
+        return None
+
+    def doctor(self):
+        return []
+
+    async def warm_up(self):
+        return {}
+
+    async def stop_all(self):
+        return None
+
+
+def _graph(session=None, workspace: str = "/tmp/workspace") -> GraphRunLoopMixin:
+    graph = GraphRunLoopMixin()
+    graph._session = session
+    graph._workspace = workspace
+    graph.model = object()
+    graph.config = SimpleNamespace(
+        workspace=workspace,
+        model=ModelConfig(provider="mimo", model="mimo-v2.5", reasoning_effort="high"),
+    )
+    graph._settings = SimpleNamespace(list_mcp_servers=lambda: [], path=f"{workspace}/.voidx/settings.json")
+    graph._permission = SimpleNamespace(
+        status_label=lambda: "default",
+        clear_session_permissions=lambda: None,
+    )
+    graph._usage_stats = UsageStats()
+    graph._debug = False
+    graph._plan_mode = False
+    graph._tracker = TaskTracker()
+    graph._session_msg_cache = None
+    graph._ui = runtime_ui_port
+    return graph
+
+
+def _disable_external_managers(graph) -> None:
+    graph._mcp_manager = NoopMcpManager()
+    graph._lsp_manager = NoopLspManager()

voidx-3.6.0/src/tests/test_agent/graph/stream_llm_helpers.py

@@ -0,0 +1,252 @@
+"""Shared helpers for test_stream_llm split files."""
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+
+from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage, RemoveMessage, SystemMessage, ToolMessage
+from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from rich.console import Console
+
+
+from voidx.agent.graph.streaming import stream_llm as _stream_llm
+from voidx.agent.graph import VoidXGraph
+from voidx.agent.graph.convergence import is_step_hint_message
+from voidx.agent.runtime_context import RuntimeContextBuilder
+from voidx.agent.task_state import TaskState, TodoRunState
+from voidx.config import Config, ModelConfig
+from voidx.llm.compaction import CompactionSelection
+from voidx.llm.message_markers import is_guidance_message
+from voidx.memory.context_frames import load_context_frames
+from voidx.memory.session import MessageRow, create_session, delete_session, save_message
+from voidx.ui.output.console import StreamingRenderer
+from voidx.ui.output.dock import ANSI_LINE_PREFIX, BottomInputDock, set_dock
+from voidx.ui.output.events import AnsiAppended, DockEventConsumer, StatusFinished, StatusUpdated, ui_events
+from voidx.workflow.runtime import WorkflowRunState, WorkflowRunStatus
+
+def _plain(line: str) -> str:
+    return line.replace(ANSI_LINE_PREFIX, "")
+
+
+class FakeStreamingModel:
+    def __init__(self) -> None:
+        self.messages = None
+
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        self.messages = messages
+        yield AIMessageChunk(content=[{"type": "thinking", "text": "think"}])
+        yield AIMessageChunk(content="answer")
+
+
+class FakeUsageStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(
+            content="answer",
+            usage_metadata={
+                "input_tokens": 7,
+                "output_tokens": 3,
+                "total_tokens": 10,
+            },
+        )
+
+
+class FakeDuplicatedReasoningStreamingModel:
+    async def astream(self, messages):
+        yield AIMessageChunk(
+            content="622",
+            additional_kwargs={"reasoning_content": "622"},
+        )
+        yield AIMessageChunk(content="final answer")
+
+
+class FakeDsmlStreamingModel:
+    def __init__(self) -> None:
+        self.messages = None
+
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        self.messages = messages
+        yield AIMessageChunk(content=(
+            '也必须在 commands 列表中注册:\n\n'
+            '<｜｜DSML｜｜tool_calls>\n'
+            '<｜｜DSML｜｜invoke name="grep">\n'
+            '<｜｜DSML｜｜parameter name="path" string="true">src/voidx/ui/commands.py</｜｜DSML｜｜parameter>\n'
+            '<｜｜DSML｜｜parameter name="pattern" string="true">permissions</｜｜DSML｜｜parameter>\n'
+            '</｜｜DSML｜｜invoke>\n'
+            '</｜｜DSML｜｜tool_calls>'
+        ))
+
+
+class FakeMalformedDsmlStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(content=(
+            '<|||DSML||tool_calls>\n'
+            '<||DSML||invoke name="grep">\n'
+            '<||DSML||parameter name="path" string="true">src/voidx/ui/commands.py</||DSML||parameter>\n'
+            '</||DSML||invoke>\n'
+            '</|||DSML||tool_calls>'
+        ))
+
+
+class FakeMalformedLegacyXmlStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(content=(
+            "<tool_call>"
+            "<tool_name>read</tool_name>"
+            "<arg_key>file_path</arg_key><arg_value>src/voidx/permission/engine.py</arg_value>"
+        ))
+
+
+class RepairsMalformedToolCallStreamingModel:
+    def __init__(self) -> None:
+        self.calls = 0
+        self.messages_by_call = []
+
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        self.calls += 1
+        self.messages_by_call.append(messages)
+        if self.calls == 1:
+            yield AIMessageChunk(content=(
+                "<tool_call>"
+                "<tool_name>read</tool_name>"
+                "<arg_key>file_path</arg_key><arg_value>src/voidx/permission/engine.py</arg_value>"
+            ))
+            return
+        yield AIMessageChunk(content="repaired answer")
+
+
+class AlwaysMalformedToolCallStreamingModel:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        self.calls += 1
+        yield AIMessageChunk(content=(
+            "<tool_call>"
+            "<tool_name>read</tool_name>"
+            "<arg_key>file_path</arg_key><arg_value>src/voidx/permission/engine.py</arg_value>"
+        ))
+
+
+class FakeMalformedProviderJsonToolCallStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(content=(
+            '{"tool_calls":[{"function":{"name":"read","arguments":"{\\"file_path\\":'
+        ))
+
+
+class FakeLegacyXmlToolCallStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(content=(
+            "<tool_call>"
+            "<tool_name>Read</tool_name>"
+            "<arg_key>file_path</arg_key><arg_value>src/voidx/permission/engine.py</arg_value>"
+            "<arg_key>offset</arg_key><arg_value>110</arg_value>"
+            "<arg_key>limit</arg_key><arg_value>50</arg_value>"
+            "</tool_call>"
+        ))
+
+
+class FakeLegacyXmlArgPairToolCallStreamingModel:
+    def bind_tools(self, tool_defs):
+        return self
+
+    async def astream(self, messages):
+        yield AIMessageChunk(content=(
+            "<tool_call>"
+            "<arg_key>tool_name</arg_key><arg_value>read</arg_value>"
+            "<arg_key>file_path</arg_key><arg_value>src/voidx/permission/engine.py</arg_value>"
+            "<arg_key>offset</arg_key><arg_value>110</arg_value>"
+            "</tool_call>"
+        ))
+
+
+class TrackingStreamingModel(FakeStreamingModel):
+    def __init__(self) -> None:
+        super().__init__()
+        self.bound_tools = None
+
+    def bind_tools(self, tool_defs):
+        self.bound_tools = tool_defs
+        return self
+
+
+class FailsOnceStreamingModel(FakeStreamingModel):
+    def __init__(self) -> None:
+        super().__init__()
+        self.calls = 0
+
+    async def astream(self, messages):
+        self.calls += 1
+        if self.calls == 1:
+            raise ConnectionError("Connection error.")
+        self.messages = messages
+        yield AIMessageChunk(content="answer")
+
+
+class FakeRenderer:
+    def __init__(self, *args, **kwargs) -> None:
+        self.text: list[str] = []
+        self.thinking: list[str] = []
+        self.started = False
+        self.done_called = False
+        self.discarded = False
+
+    def start(self) -> None:
+        self.started = True
+
+    def feed_text(self, text: str) -> None:
+        self.text.append(text)
+
+    def feed_thinking(self, text: str) -> None:
+        self.thinking.append(text)
+
+    def discard(self) -> None:
+        self.discarded = True
+
+    def done(self) -> None:
+        self.done_called = True
+
+    def error(self, text: str) -> None:
+        pass
+
+
+class FailsNonRetryableStreamingModel(FakeStreamingModel):
+    """Raises an exception with status_code=404 on first call."""
+    def __init__(self) -> None:
+        super().__init__()
+        self.calls = 0
+
+    async def astream(self, messages):
+        self.calls += 1
+        # Must yield first to remain an async generator
+        yield AIMessageChunk(content="")
+        exc = RuntimeError("404 model_not_found")
+        exc.status_code = 404  # type: ignore
+        raise exc