voidx 1.0.0__py3-none-any.whl

voidx/ui/transcript.py

@@ -0,0 +1,148 @@
+"""Serialize and restore OutputTree snapshots for session resume."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Literal, cast
+
+from voidx.memory.transcript import TranscriptNodeRow
+from voidx.ui.tree import OutputNode, OutputTree
+
+NodeType = Literal[
+    "root",
+    "startup",
+    "turn",
+    "tool_call",
+    "tool_result",
+    "subagent",
+    "message",
+    "assistant",
+    "thought",
+    "status",
+    "permission",
+    "error",
+    "warn",
+    "diff",
+]
+Status = Literal["running", "done", "error"]
+_NODE_TYPES = set(NodeType.__args__)
+_STATUSES = set(Status.__args__)
+
+
+def tree_to_transcript_rows(session_id: str, tree: OutputTree) -> tuple[list[TranscriptNodeRow], int]:
+    rows: list[TranscriptNodeRow] = []
+    turn_id = -1
+    next_node_id = 0
+    sort_order = 0
+
+    def add_node(node: OutputNode, parent_node_id: int | None) -> None:
+        nonlocal next_node_id, sort_order
+        if _is_blank_separator(node):
+            return
+        node_id = next_node_id
+        next_node_id += 1
+        metadata = {
+            "tree_id": node.id,
+            "header_style": node.header_style,
+            "agent_name": node.agent_name,
+            "step_info": node.step_info,
+            "meta": node.meta,
+            "payload": node.payload,
+        }
+        rows.append(
+            TranscriptNodeRow(
+                session_id=session_id,
+                turn_id=turn_id,
+                node_id=node_id,
+                parent_node_id=parent_node_id,
+                sort_order=sort_order,
+                node_type=node.node_type,
+                header=node.header,
+                body_lines=list(node.body_lines),
+                status=node.status,
+                collapsed=node.collapsed,
+                elapsed=node.elapsed,
+                message_id=node.message_id,
+                tool_call_id=node.tool_call_id,
+                agent_run_id=node.agent_run_id,
+                metadata={key: value for key, value in metadata.items() if value not in (None, "", {})},
+            )
+        )
+        sort_order += 1
+        for child in node.children:
+            add_node(child, node_id)
+
+    for child in tree.root.children:
+        if child.node_type == "startup":
+            continue
+        if _is_blank_separator(child):
+            continue
+        if child.node_type == "turn":
+            turn_id += 1
+            next_node_id = 0
+            sort_order = 0
+        elif turn_id < 0:
+            continue
+        add_node(child, None)
+
+    return rows, max(turn_id + 1, 0)
+
+
+def transcript_rows_to_tree(rows: list[TranscriptNodeRow]) -> OutputTree:
+    tree = OutputTree()
+    by_turn: dict[int, list[TranscriptNodeRow]] = defaultdict(list)
+    for row in rows:
+        by_turn[row.turn_id].append(row)
+
+    for turn_id in sorted(by_turn):
+        nodes: dict[int, OutputNode] = {}
+        pending = sorted(by_turn[turn_id], key=lambda row: (row.sort_order, row.node_id))
+        for row in pending:
+            metadata = row.metadata
+            payload = metadata.get("payload")
+            node = OutputNode(
+                id=f"t{turn_id}:n{row.node_id}",
+                node_type=_node_type(row.node_type),
+                header=row.header,
+                header_style=str(metadata.get("header_style") or ""),
+                body_lines=list(row.body_lines),
+                collapsed=row.collapsed,
+                status=_status(row.status),
+                elapsed=row.elapsed,
+                agent_name=_optional_str(metadata.get("agent_name")),
+                step_info=_optional_str(metadata.get("step_info")),
+                meta=_optional_str(metadata.get("meta")),
+                tool_call_id=row.tool_call_id,
+                agent_run_id=row.agent_run_id,
+                message_id=row.message_id,
+                payload=payload if isinstance(payload, dict) else {},
+            )
+            nodes[row.node_id] = node
+            parent = tree.root if row.parent_node_id is None else nodes.get(row.parent_node_id)
+            if parent is not None:
+                tree.add_node(parent, node)
+
+    tree.mark_dirty()
+    return tree
+
+
+def _is_blank_separator(node: OutputNode) -> bool:
+    return node.node_type == "message" and not node.header and not node.body_lines and not node.children
+
+
+def _optional_str(value: object) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def _node_type(value: str) -> NodeType:
+    if value in _NODE_TYPES:
+        return cast(NodeType, value)
+    return "message"
+
+
+def _status(value: str) -> Status:
+    if value in _STATUSES:
+        return cast(Status, value)
+    return "running"

voidx/ui/tree.py

@@ -0,0 +1,316 @@
+"""Tree-structured output — OutputNode, OutputTree, box-drawing renderer."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+from typing import Literal
+
+
+@dataclass
+class OutputNode:
+    """A single node in the output tree."""
+    id: str
+    parent: OutputNode | None = None
+    children: list[OutputNode] = field(default_factory=list)
+    depth: int = 0
+
+    node_type: Literal[
+        "root",
+        "startup",
+        "turn",
+        "tool_call",
+        "tool_result",
+        "subagent",
+        "message",
+        "assistant",
+        "thought",
+        "status",
+        "permission",
+        "error",
+        "warn",
+        "diff",
+    ] = "message"
+
+    header: str = ""                   # Always visible (collapse summary)
+    header_style: str = ""             # Rich style for header
+    body_lines: list[str] = field(default_factory=list)  # Hidden when collapsed
+
+    collapsed: bool = False
+    status: Literal["running", "done", "error"] = "running"
+    elapsed: float | None = None
+    agent_name: str | None = None
+    step_info: str | None = None
+    meta: str | None = None
+    tool_call_id: str | None = None
+    agent_run_id: str | None = None
+    message_id: int | None = None
+    payload: dict[str, Any] = field(default_factory=dict)
+
+    _is_last_sibling: bool = False  # Set by parent when children are finalised
+
+    @property
+    def collapse_summary(self) -> str:
+        """One-line summary shown when collapsed."""
+        if self.node_type == "thought" and self.meta:
+            return self.meta
+        elif self.node_type == "status":
+            return self.header[:120] if self.header else self.meta or ""
+        elif self.node_type == "subagent" and self.agent_name:
+            steps = self.step_info or ""
+            elapsed = f"{self.elapsed:.1f}s" if self.elapsed else ""
+            meta = " ".join(filter(None, [self.agent_name, steps, elapsed]))
+            return f"\u25bc {meta}"
+        elif self.node_type == "tool_call":
+            parts = [self.header]
+            if self.elapsed:
+                parts.append(f"({self.elapsed:.1f}s)")
+            return " ".join(parts)
+        elif self.node_type == "tool_result":
+            preview = self.header[:80] or (self.body_lines[0][:80] if self.body_lines else "")
+            return preview
+        else:
+            return self.header[:80] if self.header else ""
+
+    def add_child(self, child: OutputNode) -> None:
+        """Add a child node, updating its parent, depth, and sibling flags."""
+        child.parent = self
+        child.depth = self.depth + 1
+        # Update all existing children's _is_last_sibling
+        for c in self.children:
+            c._is_last_sibling = False
+        child._is_last_sibling = True
+        self.children.append(child)
+
+
+class OutputTree:
+    """Tree container with box-drawing renderer."""
+
+    BOX_BRANCH = "[dim]├─[/dim] "
+    BOX_LAST   = "[dim]└─[/dim] "
+    BOX_VERT   = "   "
+    BOX_SPACE  = "   "
+
+    def __init__(self):
+        self.root = OutputNode(id="root", node_type="root", depth=0)
+        self._counter = 0
+        self._all: dict[str, OutputNode] = {}  # id → node lookup
+        self._click_map: dict[int, str] = {}   # backward compat
+        self._dirty: bool = True
+        self._cached_lines: list[str] = []
+        self._cached_width: int = 0
+
+    def mark_dirty(self) -> None:
+        self._dirty = True
+
+    def new_node(self, parent: OutputNode, *, node_id: str | None = None, **kwargs) -> OutputNode:
+        """Create a new node under parent. Auto-assigns id."""
+        if node_id is None:
+            self._counter += 1
+            node_id = f"n{self._counter}"
+        node = OutputNode(id=node_id, **kwargs)
+        self.add_node(parent, node)
+        self._sync_counter(node.id)
+        return node
+
+    def add_node(self, parent: OutputNode, node: OutputNode) -> None:
+        """Attach an existing node and register its subtree."""
+        parent.add_child(node)
+        self._register_subtree(node)
+        self._sync_counter(node.id)
+        self.mark_dirty()
+
+    def extend_from(self, other: OutputTree) -> None:
+        """Append another tree's root children to this tree."""
+        for child in list(other.root.children):
+            self.add_node(self.root, child)
+
+    def _register_subtree(self, node: OutputNode) -> None:
+        self._all[node.id] = node
+        for child in node.children:
+            child.parent = node
+            child.depth = node.depth + 1
+            self._register_subtree(child)
+
+    def _sync_counter(self, node_id: str) -> None:
+        match = re.fullmatch(r"n(\d+)", node_id)
+        if match:
+            self._counter = max(self._counter, int(match.group(1)))
+
+    def get(self, node_id: str) -> OutputNode | None:
+        return self._all.get(node_id)
+
+    def expand(self, node_id: str) -> OutputNode | None:
+        node = self._all.get(node_id)
+        if node:
+            node.collapsed = False
+            self.mark_dirty()
+        return node
+
+    def collapse(self, node_id: str) -> OutputNode | None:
+        node = self._all.get(node_id)
+        if node:
+            node.collapsed = True
+            self.mark_dirty()
+        return node
+
+    def expand_all(self) -> None:
+        for node in self._all.values():
+            node.collapsed = False
+        self.mark_dirty()
+
+    def collapse_all(self, max_depth: int = 0) -> None:
+        for node in self._all.values():
+            if node.depth > max_depth:
+                node.collapsed = True
+        self.mark_dirty()
+
+    # ── rendering ──────────────────────────────────────────────────────────
+
+    def render(self, console_width: int = 80) -> list[str]:
+        """Flatten tree to lines with box-drawing characters.
+
+        Returns list of plain strings (no Rich markup needed at this level —
+        markup can be embedded in header/body_lines by the caller).
+        """
+        if not self._dirty and self._cached_width == console_width:
+            return self._cached_lines
+
+        self._click_map.clear()
+        lines: list[str] = []
+        line_map: dict[int, str] = {}
+        self._walk_render(self.root, [], lines, line_map)
+        # Populate backward-compat _click_map
+        self._click_map = dict(line_map)
+
+        self._cached_lines = lines
+        self._cached_width = console_width
+        self._dirty = False
+        return lines
+
+    def render_with_line_map(self, console_width: int = 80) -> tuple[list[str], dict[int, str]]:
+        """Like render() but also returns a map of line_number → node_id
+        for mouse click targeting."""
+        self.render(console_width)
+        return self._cached_lines, self._click_map
+
+    def render_expanded(self, node_id: str, console_width: int = 80) -> list[str]:
+        """Render a single collapsed node's subtree as an expanded view."""
+        node = self._all.get(node_id)
+        if not node:
+            return []
+
+        lines: list[str] = []
+        # Title bar
+        lines.append(f"  \u2500\u2500 [bold]Expanded[/bold] " + "\u2500" * (console_width - 13))
+
+        # Temporarily expand this node for rendering
+        was_collapsed = node.collapsed
+        node.collapsed = False
+
+        # Render children with box-drawing (like depth 1 nodes)
+        new_parts = ["  "]
+        for child in node.children:
+            self._walk_render(child, new_parts, lines, None)
+
+        node.collapsed = was_collapsed
+
+        lines.append("  " + "\u2500" * (console_width - 4))
+        return lines
+
+    def click_at_row(self, row: int) -> str | None:
+        return self._click_map.get(row)
+
+    # ── internal walk ──────────────────────────────────────────────────────
+
+    def _walk_render(self, node: OutputNode, prefix_parts: list[str],
+                     lines: list[str], line_map: dict[int, str] | None = None) -> None:
+        """Recursive depth-first walk to render the tree.
+
+        Depth 0 (root):      not rendered, iterate children directly.
+        Depth 1 (turns):     no box-drawing connector — header only.
+        Depth 2+ (nested):   dim connector on the first header, spaces after that.
+        """
+        if node is self.root:
+            prev = None
+            for child in node.children:
+                if prev is not None and prev.node_type == "turn" and child.node_type == "message" and child.header:
+                    lines.append("")
+                prev = child
+                self._walk_render(child, [], lines, line_map)
+            return
+
+        # ── depth 1: no box-drawing ────────────────────────────────────
+        if node.depth == 1:
+            if node.collapsed:
+                line = node.collapse_summary
+                lines.append(line)
+                if line_map is not None:
+                    line_map[len(lines) - 1] = node.id
+                return
+
+            line = node.header if node.header else ""
+            lines.append(line)
+            if line_map is not None and _is_clickable(node):
+                line_map[len(lines) - 1] = node.id
+
+            # Body lines — plain spaces continuation
+            for bl in node.body_lines:
+                lines.append(bl)
+
+            # Children get box-drawing, indented under this node
+            new_parts = [" "]
+            for child in node.children:
+                self._walk_render(child, new_parts, lines, line_map)
+            return
+
+        # ── depth >= 2: full box-drawing ───────────────────────────────
+        indent = "".join(prefix_parts)
+        connector = self.BOX_LAST if node._is_last_sibling else self.BOX_BRANCH
+        is_first_sibling = (
+            node.parent is not None
+            and bool(node.parent.children)
+            and node.parent.children[0] is node
+        )
+        suppress_connector = node.parent is not None and node.parent.node_type == "assistant"
+        prefix = indent + connector
+        aligned_prefix = indent + self.BOX_SPACE if suppress_connector else (
+            prefix if is_first_sibling else indent + self.BOX_SPACE
+        )
+        inline_tool_result = (
+            node.node_type == "tool_result"
+            and node.parent is not None
+            and node.parent.node_type == "tool_call"
+        )
+
+        if node.collapsed:
+            line = f"{indent if inline_tool_result else aligned_prefix}{node.collapse_summary}"
+            lines.append(line)
+            if line_map is not None:
+                line_map[len(lines) - 1] = node.id
+            return
+
+        # Header line
+        current_prefix = indent if inline_tool_result else aligned_prefix
+        line = f"{current_prefix}{node.header}" if node.header else current_prefix
+        lines.append(line)
+        if line_map is not None and _is_clickable(node):
+            line_map[len(lines) - 1] = node.id
+
+        # Continuation for body lines and children
+        cont_suffix = self.BOX_SPACE if suppress_connector or node._is_last_sibling else self.BOX_VERT
+        cont = indent if inline_tool_result else indent + cont_suffix
+
+        # Body lines
+        for bl in node.body_lines:
+            lines.append(f"{cont}{bl}")
+
+        # Children
+        new_parts = prefix_parts if inline_tool_result else prefix_parts + [cont_suffix]
+        for child in node.children:
+            self._walk_render(child, new_parts, lines, line_map)
+
+
+def _is_clickable(node: OutputNode) -> bool:
+    return node.node_type in {"subagent", "tool_call", "tool_result", "thought", "status"}

voidx-1.0.0.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: voidx
+Version: 1.0.0
+Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: langgraph>=0.3.0
+Requires-Dist: langchain>=0.3.0
+Requires-Dist: langchain-anthropic>=0.3.0
+Requires-Dist: langchain-openai>=0.3.0
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pydantic-settings>=2.7.0
+Requires-Dist: typer>=0.15.0
+Requires-Dist: rich>=13.9.0
+Requires-Dist: prompt_toolkit>=3.0.0
+Requires-Dist: tiktoken>=0.8.0
+Requires-Dist: httpx>=0.28.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.25.0; extra == "dev"
+
+# voidx
+
+voidx is a terminal AI coding agent built in Python.
+
+## Install
+
+Python users can install the canonical package from PyPI:
+
+```bash
+pip install voidx
+voidx
+```
+
+Node users can install the npm launcher. The launcher requires Python 3.11+
+on the machine and installs the matching Python package into an isolated
+user-local virtual environment on first run:
+
+```bash
+npm install -g @voidx/cli
+voidx
+```
+
+## Useful Commands
+
+```bash
+voidx version
+voidx sessions
+voidx -w /path/to/project
+```
+
+## Development
+
+```bash
+.venv/bin/python -m pytest
+.venv/bin/python scripts/package.py --format all --clean
+npm --prefix npm run check
+```

voidx-1.0.0.dist-info/RECORD

@@ -0,0 +1,126 @@
+voidx/__init__.py,sha256=cbFWhQdBBpYLCU3yVfbepYoZHOd3nECdp591GzGB8sM,80
+voidx/config.py,sha256=pr0oeagA-czlViW94gAaTt8WmArBZCxvvEK3aCh-fl4,27067
+voidx/main.py,sha256=qblhaac_b56Gn506EUsnZsUNh1lFH_Sfbpxr2p9OAqw,4408
+voidx/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voidx/agent/agents.py,sha256=xfonoOsO1l21aHe8bSMyb7EP0XeDq3Q3aueHtd8nv9Q,17490
+voidx/agent/attachments.py,sha256=oumjx2JUzgppi2kQRyFh0agDSf3FbLLDHKwyAQOXBjI,7609
+voidx/agent/graph.py,sha256=eiAoAIzxK71rdu8HQ7RouM2SkZKD-qDAkWvAad8TnX8,19349
+voidx/agent/runtime_context.py,sha256=TurBVymv13eWpY0vqL84VHd15Hc_2XE8PaB75Kx8CUI,14207
+voidx/agent/slash.py,sha256=eA8h1aWpl_C7pFrK9siH8asbVodefnNeQ0vOLTm2grM,19676
+voidx/agent/state.py,sha256=uRc-OI1TTxoNWFmKcvOVNSxn_WDjeKQ5TbhYbtdPwoo,1447
+voidx/agent/task_state.py,sha256=y_QslX_ua36DpvNRTwHWLxsuMa-4N7o50A_rMxwOOoo,7478
+voidx/agent/tool_filters.py,sha256=8DXNXvJJUxws17MDQRGo43L3Sv_EKltXwhlYUiNvdLA,808
+voidx/agent/graph_components/__init__.py,sha256=M0w0W4Jjl4m8NVbShKPi3JEdhjjjqxySVCz1L7OOcIA,43
+voidx/agent/graph_components/compaction.py,sha256=wd24z_9fokOumGIwQuUVfvzny-yPFhPWIugEIJDjULw,11408
+voidx/agent/graph_components/permissions.py,sha256=P1e__ymk5a0G4FyJidekgiWHtD_g9YE61fTVcBNkMy0,5142
+voidx/agent/graph_components/run_loop.py,sha256=XcZdMbaaYkdZEyXX3Wte7s-hHE7C5poDBxmpxZmv_S8,23272
+voidx/agent/graph_components/runtime.py,sha256=55DzCKs4vpIo61Khh3k4cMk1jAd7rB5TeCmeZ3MknRA,319
+voidx/agent/graph_components/streaming.py,sha256=tbG1JvQEJjigtPN7qMx4omc2wRozefl2noeqCmBexuc,11106
+voidx/agent/graph_components/subagent.py,sha256=rAVm6MRhGldlaI2sA-h_rcn59oRTPtV_ZTIHwnt2Eig,11417
+voidx/agent/graph_components/tool_execution.py,sha256=oJEWAwrT-Cz0bj70y55tcsmfr-363TYno4ZCeL3ErTg,8192
+voidx/agent/slash_components/__init__.py,sha256=lEUeU7ejcX7QmFRU-8Xo67rZYPl0g8lRU8Jpa4xNUK0,47
+voidx/agent/slash_components/code_ide.py,sha256=M5g67iR17htr7ys4LF5j4Fj4a9m-5PoyhO2P6Dr4rXE,2662
+voidx/agent/slash_components/lsp.py,sha256=4n65NxSjFrn6nAwZEwi6Tog4r2jcO0aKQztL9jENErg,4480
+voidx/agent/slash_components/mcp.py,sha256=gU1p0ljZcsmGmBCYsuVXHEzLRNRfzW1jIIkhe2PXXpo,12846
+voidx/agent/slash_components/model.py,sha256=q4pYSZyKECqHZ0iVPSyEzRaJODTZgCgfsnLM30-Tyb0,17326
+voidx/agent/slash_components/runtime.py,sha256=FMzg1gx37bh0PZ7c45NvVlgvdbQbiIIXAJqT-2GupLk,1297
+voidx/agent/slash_components/skills.py,sha256=vgJ_I9cZJJKJdoyq5QhX9ncPjcgqborHE_9eREW95tQ,3767
+voidx/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voidx/llm/catalog.py,sha256=y37LmfjV2T3KNk_kMQo3OKBgEgYkQZatVScXTaMgJZA,5951
+voidx/llm/compaction.py,sha256=pr7XLqOFTObtu3qZB6xtn5K24HyX4DoIDRfn_YsNk08,10331
+voidx/llm/context.py,sha256=Fqptw-YmaY6mXQMWbtHyVbmaotLuA1km4Pc2INwJQAo,1320
+voidx/llm/instruction.py,sha256=hN07LRvsBh5v0znNyTqrE96HUeht-jpPkIP5CVK_dVo,8367
+voidx/llm/provider.py,sha256=lfdqtIvAI1X_KVZkggrERt6tg0lTArlEWR0AtX7i0uM,10693
+voidx/llm/usage.py,sha256=MkqdJmnmxiCDCiS4QkQSpFQORhYrZeWY1Kk1FAQSNgI,12162
+voidx/lsp/__init__.py,sha256=pQvnIVHVTA2n0qxxEKUOleSHba6N1ac4xX5-C7ft8_Y,604
+voidx/lsp/client.py,sha256=DoxNk9IWVlnusOiKC4Z2ZqklOE5CWQHuSiounb6EfuA,9681
+voidx/lsp/config.py,sha256=L0GSWy-qQdfYdo72P6UwDTZBJT9jmG6MEKsAQ0gd8qc,5761
+voidx/lsp/detector.py,sha256=6Q7HbmJrHq7SatYLml1zWt6093ZYbEUwT8TcCLEYlFM,18498
+voidx/lsp/errors.py,sha256=A8TfktAfPqOqXjRIgA9Lhbf3Po2uSi9GxMtB8DZpv04,429
+voidx/lsp/manager.py,sha256=8-RX4L_PStNtmjXh-CLEoRykrl-ondqc3mtfI-0PSlk,11215
+voidx/lsp/schema.py,sha256=Ytf09PJHsrejNymP_u_LGSkcHVWdISYKnfM2J1cQps4,5078
+voidx/lsp/service.py,sha256=Oq4RX4PCQXxHF-WqkrxtZkORq0ptqS-KNJpFm9FeQVw,3815
+voidx/mcp/__init__.py,sha256=dG3cWqRBffqzqfWRNT1sPRCB8aQyUdCVYTaswtgczP8,1100
+voidx/mcp/client.py,sha256=ij4fHad3_0t6j-SMsNXhQOtvRTD3tQUOJaCVLTv5tPE,17932
+voidx/mcp/manager.py,sha256=VfHWXQZhLblmTw-rQJs7E0YVU5r6R1IGy42AbBYwIpo,10172
+voidx/mcp/schema.py,sha256=ERdiBojFxfRZKjXAlQ4r8RjtafdjB-AB1lE4i-3Wq7o,3096
+voidx/mcp/tool.py,sha256=B7kzzleLoTzzRC2STqVOqcDfB918jhcMvc0M616wE3s,4810
+voidx/mcp_servers/__init__.py,sha256=A2CS-VzGlluE3xSu53Sd-_gjL__gIFIS-MVi0NtbCVY,47
+voidx/mcp_servers/web.py,sha256=wTz9kYQYCLDf9XygL8wp2vVdBXXUi8Q_XeNrq8QxNns,3104
+voidx/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voidx/memory/context_frames.py,sha256=R_pGZ-w5gvKIyCOiN_NWFcROmrpA04r4C-wDJR_BV7E,5945
+voidx/memory/model_profiles.py,sha256=YM_dq2wZGR2VFfCBRNJ_EUyekcWL7EcAZsz77TkerEo,2853
+voidx/memory/runtime_state.py,sha256=15WPe4JbarXQZwq4ikw35cXzPLX_5xE1EbPdcqIkN6U,9333
+voidx/memory/session.py,sha256=WeqXDltdCsngj50xWWidNkfx-rHt1DYseRfPNDYuo8k,9598
+voidx/memory/store.py,sha256=D3v7wXb0MWZJWJQLPMt3zuVCtuI1UepyeqNiF-gsB9Q,9084
+voidx/memory/transcript.py,sha256=vGAhbNCsIUOSKmhZQBe7pxNttVaFi0Qv4awvj_-qA44,4586
+voidx/permission/__init__.py,sha256=8nBMbD4Rsk91W_vPcStX5M55P8IZwK8p7f4wWyBGZaU,884
+voidx/permission/engine.py,sha256=3XSjyYm5p5DVwwOxNZLOqu3AnPbWKeppx6oLIK-F87Q,16420
+voidx/permission/evaluate.py,sha256=xjY7yz1GMesyQW-A75czBOS1GMcPKIZ-Up0YzAsjvWs,4234
+voidx/permission/sandbox.py,sha256=dE7Rr1zkwFJzqF6j85tK4x3P4sf3V1QON06DSv5cQ_A,9786
+voidx/permission/schema.py,sha256=imnZwSNyUNWcKBjGz5KlsIYWsmQC6T6nFQZXOtERNPo,530
+voidx/permission/service.py,sha256=Av47zZ_Jr3Rp_uIwbV-tDRqP_-KI_pWBMdCO9M--KT8,12715
+voidx/permission/wildcard.py,sha256=-TEuGPye-dqzcqfa00eseiKZUPusYOZkPJf5Wc8XJOY,986
+voidx/skills/__init__.py,sha256=tKe6ccKAbdLf_0JxpXe1aCcGEsdw0dcyoV1kwdtSGk8,485
+voidx/skills/policy.py,sha256=WWbtM8_MTewhGAezueLzYxT8oOAYYIgGxMTDI9cCBBQ,2584
+voidx/skills/registry.py,sha256=gsAL6b9uLoMcAZZ8IkKAHgKCsCdLTkfPDA0xqrKGH0M,5312
+voidx/skills/schema.py,sha256=xeassMfow1eM77GgpBgiNAQR-jvvXGRgPM-XwTy72oA,948
+voidx/skills/service.py,sha256=XkL8MgGMTPUZKKdxWZSeioeIojJRU7DU1Lz3fcsH9qk,6510
+voidx/skills/bundled/superpowers/receiving-code-review/SKILL.md,sha256=zTphlJ-Fk2StA_UByTkGpa_3soKzDG0aU-7bp3bPvKc,988
+voidx/skills/bundled/superpowers/requesting-code-review/SKILL.md,sha256=hs-7C4GDZGDGSaLMYa2VCtQ8SBHMdzAlMuy4D06tfuY,830
+voidx/skills/bundled/superpowers/systematic-debugging/SKILL.md,sha256=KCqyBK2SiL-kamdMXBijJH25xnXc1iicGqSDDvy5WSc,1069
+voidx/skills/bundled/superpowers/test-driven-development/SKILL.md,sha256=69pdcd9XkkVRzSrpQSxHIleCGoJGLDkP14PXJgih1Fw,1036
+voidx/skills/bundled/superpowers/verification-before-completion/SKILL.md,sha256=o7Umc5ErT5N-tIk33qwqUhp3Q3Tr0AFQLm-Vnd5HBd8,828
+voidx/skills/bundled/superpowers/writing-plans/SKILL.md,sha256=TDEcXJPCQOEkQ703Z9_xjUx0CzDoN2XKZrq1h-fjHho,858
+voidx/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voidx/tools/agent.py,sha256=Cc5fb2XUfepcIWHUqq7D9PO4-jE2Pf-_anBgExx4IGE,3031
+voidx/tools/base.py,sha256=4K2KB7lwsqOwISIi6M11jHWOeH1awkv8orNENHqOWRQ,2546
+voidx/tools/bash.py,sha256=5YLKGPOth4uPIZF8W75y9B5_VZ5Hd6sIl65tkMPyMGc,3994
+voidx/tools/file_ops.py,sha256=ZopwEvOLv_zURbjP0X7HpGAiIA6WIznMXT4SLbg65V4,7458
+voidx/tools/lsp.py,sha256=1CCnARGRCImXC428XFTAUKVXMWIPnd-E-7D2IWhh_XA,6282
+voidx/tools/registry.py,sha256=RruXcNEn4eNhKz61twOdljyVPzLVJN_hsb_fFpwoCRc,3834
+voidx/tools/repomap.py,sha256=ozEHkjBpwcekxHCAIpqHvj2V0ujROHjbNlW6MGt2A6I,8057
+voidx/tools/search.py,sha256=lv7gXsvRN8Vb5b5JAMszXMcE_8cyax3FSxRd4t2jluQ,6061
+voidx/tools/task_status.py,sha256=G19AOQm3KaUQxWgdZ6R6jSItDCruvR0BuNUHYMD6Y5A,1946
+voidx/tools/task_tracker.py,sha256=MaE6ewu5lGuFfajRDytAWrjFIiaknO2rS8XcJWvenK8,2823
+voidx/tools/todo.py,sha256=8UiZ8llSel2Qb4StEwIrNgtEqxxKaXKRmK_2ACsA9FU,2801
+voidx/tools/web_content.py,sha256=khU1tWcVBGRT9iaNkZdRhyPdGZGWtfAb4JzSnXN1acs,9958
+voidx/tools/web_mcp.py,sha256=B8tK-FdERnrrLJyjVhiN1Q9T6f3A1jErqbkAX-C_gtA,3123
+voidx/tools/webfetch.py,sha256=_z79THxotG3c8HwzUeKjzDG8WYhhLFTz4pt9QBUDYYY,5687
+voidx/tools/websearch.py,sha256=rv7PeoMQYWXLYRrrBTZ8ABk_vLZp3m-U_MfVcj0xb_E,9542
+voidx/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voidx/ui/app.py,sha256=MOzupIRGpNSLHUYl54Doz10gGESDCiyUqJd7OSjWvc4,39159
+voidx/ui/browse.py,sha256=w3Tv3GYEnbSGpvJ4-SmErNORd0OpcWgiJSzTYP_evdQ,6282
+voidx/ui/capture.py,sha256=dKnrxM1SvcHP9xRhdp-7eWCf8SlVCSkZexK02qWABzA,6341
+voidx/ui/code_ide.py,sha256=MclNUfmjSW-O0qwfx05kZWSIseRuxM_ctzi42qSr2oc,8357
+voidx/ui/commands.py,sha256=f_QOjXxboTqTfnACGgJkm-TGBvkcsuV74NDmtu9ijBU,4187
+voidx/ui/console.py,sha256=GqiDe8B68tp4dLXbHzD3z5qwYjeNeMd6MEvIikRvxWo,13574
+voidx/ui/diff.py,sha256=0iRWaJyy3kiilgcizJff1750DbflLsnM9pISxlAJeYI,10353
+voidx/ui/dock.py,sha256=RzsXzO0m-H4rsuo9Xebsoc1g_iH_Yw6suiH7C0wJ8G0,12229
+voidx/ui/events.py,sha256=THuiVXEyUiRe3ZjLrcmlifpHlcprRWlPIMNX8X0cflQ,13208
+voidx/ui/session_changes.py,sha256=ks8_ARBNDZCOPM8AYUmA8ooy3G5AQxjLq769QMUv5Lo,4716
+voidx/ui/startup.py,sha256=mpz_YFb2-2pZFJcumhfGqZK5dwfBRFMdOHzuwTsKbxQ,5037
+voidx/ui/transcript.py,sha256=vA5VVi5AynouNOuTlOrbsDlymE4BYxn7ar5c6IIqi1w,4671
+voidx/ui/tree.py,sha256=7_pfgB3qj6EQanZ1m2n7pNKmqBjn1sxqROapEhkXw8M,11867
+voidx/ui/app_components/__init__.py,sha256=RPNDe1VgSFbouRJ3nwYZ83lrkZCSpuegCNvPEGJwyC0,49
+voidx/ui/app_components/clipboard_image.py,sha256=np2GgvWkhIh5QRn8ul3tFAXg_SHelLZfmUuNGD06oPg,7612
+voidx/ui/app_components/commands.py,sha256=oB54KUUSyCwTHcQH0Hs1mVO5fxYQHEf_iILwooB_Eyo,597
+voidx/ui/app_components/controls.py,sha256=wlhdBpzF-pPXXmyktJIb86YctT1__gjCbDT3M6syzLw,944
+voidx/ui/app_components/file_picker.py,sha256=wRuPsTh4YZxpY7J0yOvVmfDGTILGi92A9kvJeyZqpDQ,3387
+voidx/ui/app_components/formatting.py,sha256=VDiecSTKjLgoyQBwCCXJ8QzVMBpoFvOtdtFc5uxj3BE,5978
+voidx/ui/app_components/git_changes.py,sha256=5Mynt5d7nKvwdDEe_TVXWBrhxn-AUTlIa_HD8H-wbtc,1516
+voidx/ui/app_components/rendering.py,sha256=JI-h1dEc4L2Gt4dp-JkonKFtsl3yBN1wFChkD1keIHk,47643
+voidx/ui/console_components/__init__.py,sha256=sV9ymVuyfe4IF9VwDcBMjZ-kbyj76TqBLPxZ8_wvH_I,50
+voidx/ui/console_components/formatting.py,sha256=JPklqWgVNhDXosVNwKSTue5g8kFs59NPvi9hfKTrxWM,2790
+voidx/ui/console_components/streaming.py,sha256=SXDRhuh55nRf2VwfX2kUqVZVYp72CikTtsupy-yn4dA,8719
+voidx/ui/dock_components/__init__.py,sha256=B1wAKH0dBEvzLq9GtyQ3PRqVhB0JXjKwcCpkxzO_v1A,48
+voidx/ui/dock_components/formatting.py,sha256=FHpuyutSRNshfElOoL3AIrIwbgCWCPr4xFJXdZCXfyk,3341
+voidx/ui/dock_components/nodes.py,sha256=WNxmF_KZsqumUKdpweWB2GFWC01DpQOXPac5bXtlpd8,13736
+voidx/ui/dock_components/state.py,sha256=uiWmwFlZg8435YMVgDEo9I1LX7-SRkz5TcU3ZtF49qw,1254
+voidx/ui/event_components/__init__.py,sha256=8qa8UbaxRSeopM_6698e2bWq9Puy6zp-x4JPAYkcky0,42
+voidx/ui/event_components/schema.py,sha256=UNOcjmFCgQSjiILzeo3sE-WPXOKolnwhhqRut7mHhO8,5854
+voidx-1.0.0.dist-info/METADATA,sha256=HBRznaII0q9s1Hm1Vd2hzaTWrC21OK_xhDnPI8fsV18,1379
+voidx-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+voidx-1.0.0.dist-info/entry_points.txt,sha256=hS_l7aI4XL-9UB1-4NhFGWTUgPj3Cii37-UmkCSvWrM,41
+voidx-1.0.0.dist-info/top_level.txt,sha256=DG4cfADJBiWwfHkId7vpqd-zAbLvbqFTpiXU5w1lzXQ,6
+voidx-1.0.0.dist-info/RECORD,,

voidx-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

voidx-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voidx = voidx.main:cli

voidx-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+voidx