@scemoon/cdh 1.0.4 → 1.0.6

package/tui/widgets/terminal.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 from time import monotonic
-from typing import Awaitable, Callable, Iterable
+from typing import Awaitable, Callable
 
 from textual.cache import LRUCache
 
@@ -18,7 +18,6 @@ from textual.strip import Strip
 from textual.timer import Timer
 
 from tui import ansi
-from tui.menus import MenuItem
 
 
 # Time required to double tab escape

package/tui/widgets/terminal_tool.py

@@ -11,14 +11,13 @@ from collections import deque
 from dataclasses import dataclass
 import struct
 import termios
-from typing import Iterable, Mapping
+from typing import Mapping
 
 from textual.content import Content
 from textual.reactive import var
 
 from tui.shell_read import shell_read
 from tui.widgets.terminal import Terminal
-from tui.menus import MenuItem
 
 
 @dataclass
@@ -249,6 +248,16 @@ class TerminalTool(Terminal):
                     break
         finally:
             transport.close()
+            try:
+                write_transport.close()
+            except Exception:
+                pass
+            if self._shell_fd is not None:
+                try:
+                    os.close(self._shell_fd)
+                except OSError:
+                    pass
+                self._shell_fd = None
 
         self.finalize()
         return_code = self._return_code = await process.wait()

package/tui/widgets/tool_call.py

@@ -136,7 +136,26 @@ class ToolCall(containers.VerticalGroup):
         super().__init__(id=id, classes=classes)
 
     async def update_tool_call(self, tool_call: protocol.ToolCall) -> None:
+        old_call = self.tool_call
+        old_status = old_call.get("status") if old_call else None
+        old_content_len = len(old_call.get("content", [])) if old_call else 0
+        new_status = tool_call.get("status")
+        new_content = tool_call.get("content", [])
+
         self.tool_call = tool_call
+
+        # Update header immediately (cheap)
+        try:
+            self.query_one(ToolCallHeader).update(self.tool_call_header_content)
+        except NoMatches:
+            pass
+
+        if old_status != new_status:
+            self.check_expand()
+
+        # Skip full recompose if nothing material changed
+        if old_status == new_status and old_content_len == len(new_content):
+            return
         await self.recompose()
 
     def get_block_menu(self) -> Iterable[MenuItem]:
@@ -192,10 +211,18 @@ class ToolCall(containers.VerticalGroup):
             return
         tool_call = self.tool_call
         assert tool_call is not None
-        if tool_call.get("kind", "") == "read":
+        kind = tool_call.get("kind", "")
+        if kind == "read":
             return
-        tool_call_expand = self.app.settings.get("tools.expand", str, expand=False)
+
         status = tool_call.get("status")
+
+        # write/edit: always expanded
+        if kind == "edit":
+            self.expanded = True
+            return
+
+        tool_call_expand = self.app.settings.get("tools.expand", str, expand=False)
         if tool_call_expand == "always":
             self.expanded = True
         elif tool_call_expand != "never" and status is not None:
@@ -303,6 +330,12 @@ class ToolCall(containers.VerticalGroup):
     def _compose_content(
         self, tool_call_content: list[protocol.ToolCallContent]
     ) -> ComposeResult:
+        # TodoCreate/TodoList/TodoUpdate return trivial "updated" text - skip display
+        title = self.tool_call.get("title", "") if self.tool_call else ""
+        tool_name = title.split(":")[0] if ":" in title else title
+        if tool_name in ("TodoCreate", "TodoList", "TodoUpdate"):
+            return
+
         found = False
         for widget in compose_tool_content(tool_call_content, self.app):
             yield widget

package/onecode/memory/offload.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-import re
-import fnmatch
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional
-
-
-@dataclass
-class OffloadConfig:
-    enabled: bool = True
-    mild_ratio: float = 0.5
-    aggressive_ratio: float = 0.85
-    mmd_max_token_ratio: float = 0.2
-
-
-class ContextOffloader:
-    def __init__(
-        self,
-        refs_dir: Optional[Path] = None,
-        config: Optional[OffloadConfig] = None,
-    ):
-        from onecode.config import CLOUD_DEV_HARNESS_DIR
-        self.refs_dir = refs_dir or (CLOUD_DEV_HARNESS_DIR / "memory" / "refs")
-        self.refs_dir.mkdir(parents=True, exist_ok=True)
-        self.config = config or OffloadConfig()
-        self._offloaded_refs: dict[str, Path] = {}
-
-    def should_offload(self, context_length: int, max_tokens: int) -> tuple[bool, str]:
-        if not self.config.enabled:
-            return False, "disabled"
-
-        ratio = context_length / max_tokens if max_tokens > 0 else 0
-
-        if ratio >= self.config.aggressive_ratio:
-            return True, "aggressive"
-        elif ratio >= self.config.mild_ratio:
-            return True, "mild"
-        return False, "none"
-
-    def offload_content(
-        self,
-        content: str,
-        node_id: str,
-        file_pattern: str = "*.md",
-    ) -> str:
-        ext = file_pattern.replace("*", "md")
-        ref_file = self.refs_dir / f"{node_id}.{ext}"
-        ref_file.write_text(content, encoding="utf-8")
-        self._offloaded_refs[node_id] = ref_file
-        return f"See refs/{node_id}.{ext}"
-
-    def recall_ref(self, node_id: str) -> Optional[str]:
-        ref_file = self._offloaded_refs.get(node_id)
-        if ref_file and ref_file.exists():
-            return ref_file.read_text(encoding="utf-8")
-        for ext in ["md", "txt", "log"]:
-            alt_path = self.refs_dir / f"{node_id}.{ext}"
-            if alt_path.exists():
-                return alt_path.read_text(encoding="utf-8")
-        return None
-
-    def list_offloaded(self) -> list[str]:
-        return list(self._offloaded_refs.keys())
-
-    def cleanup_old_refs(self, max_age_hours: int = 24) -> int:
-        import time
-        from datetime import datetime, timezone
-        removed = 0
-        for ref_file in self.refs_dir.iterdir():
-            if ref_file.is_file():
-                age_hours = (time.time() - ref_file.stat().st_mtime) / 3600
-                if age_hours > max_age_hours:
-                    ref_file.unlink()
-                    node_id = ref_file.stem
-                    if node_id in self._offloaded_refs:
-                        del self._offloaded_refs[node_id]
-                    removed += 1
-        return removed
-
-
-class ToolCallExtractor:
-    PATTERNS = [
-        re.compile(r'\[TOOL_CALL\]\s*(\w+)\s*:\s*(.+)', re.DOTALL),
-        re.compile(r'"tool":\s*"(\w+)"[^}]*"args":\s*({.+?})', re.DOTALL),
-        re.compile(r'(\w+)\((.*?)\)\s*=>\s*(.+)', re.DOTALL),
-    ]
-
-    @classmethod
-    def extract_calls(cls, text: str) -> list[dict]:
-        calls = []
-        for pattern in cls.PATTERNS:
-            matches = pattern.finditer(text)
-            for match in matches:
-                if pattern == cls.PATTERNS[0]:
-                    calls.append({"tool": match.group(1), "args": match.group(2)})
-                elif pattern == cls.PATTERNS[1]:
-                    calls.append({"tool": match.group(1), "args": match.group(2)})
-                else:
-                    calls.append({"tool": match.group(1), "args": match.group(2), "result": match.group(3)})
-        return calls
-
-    @classmethod
-    def format_as_mermaid(cls, calls: list[dict]) -> str:
-        lines = ["graph LR"]
-        for i, call in enumerate(calls):
-            node_id = f"C{i:03d}"
-            tool_name = call.get("tool", "unknown")
-            lines.append(f"    {node_id}[{tool_name}]")
-            if i > 0:
-                prev_id = f"C{i-1:03d}"
-                lines.append(f"    {prev_id} --> {node_id}")
-        return "\n".join(lines)

package/onecode/memory/symbolic.py

@@ -1,164 +0,0 @@
-from __future__ import annotations
-
-import re
-import uuid
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from enum import Enum
-from typing import Optional
-
-
-class NodeType(Enum):
-    TASK = "task"
-    ACTION = "action"
-    RESULT = "result"
-    ERROR = "error"
-    CHECKPOINT = "checkpoint"
-
-
-@dataclass
-class MermaidNode:
-    node_id: str
-    node_type: NodeType
-    label: str
-    metadata: dict = field(default_factory=dict)
-
-    def to_mermaid(self) -> str:
-        type_styles = {
-            NodeType.TASK: "([,shape=ellipse",
-            NodeType.ACTION: "[,shape=box",
-            NodeType.RESULT: "[(,shape=cylinder",
-            NodeType.ERROR: "([,shape=ellipse,color=red",
-            NodeType.CHECKPOINT: "[,shape=diamond",
-        }
-        style = type_styles.get(self.node_type, "[")
-        return f"    {self.node_id}{style} {self.label}])"
-
-
-@dataclass
-class MermaidEdge:
-    from_node: str
-    to_node: str
-    label: Optional[str] = None
-    style: str = ""
-
-    def to_mermaid(self) -> str:
-        edge_str = f"    {self.from_node} --> {self.to_node}"
-        if self.label:
-            edge_str = f"    {self.from_node} -->|{self.label}| {self.to_node}"
-        if self.style:
-            edge_str += f" -. {self.style} .-> {self.to_node}"
-        return edge_str
-
-
-class MermaidCanvas:
-    def __init__(self, task_id: Optional[str] = None):
-        self.task_id = task_id or str(uuid.uuid4())[:8]
-        self.nodes: list[MermaidNode] = []
-        self.edges: list[MermaidEdge] = []
-        self.refs: dict[str, str] = {}
-
-    def add_node(
-        self,
-        node_type: NodeType,
-        label: str,
-        metadata: Optional[dict] = None,
-    ) -> str:
-        node_id = f"N{len(self.nodes):03d}"
-        node = MermaidNode(node_id, node_type, label, metadata or {})
-        self.nodes.append(node)
-        return node_id
-
-    def add_edge(
-        self,
-        from_node: str,
-        to_node: str,
-        label: Optional[str] = None,
-        style: str = "",
-    ) -> None:
-        edge = MermaidEdge(from_node, to_node, label, style)
-        self.edges.append(edge)
-
-    def add_ref(self, node_id: str, content: str) -> None:
-        self.refs[node_id] = content
-
-    def get_ref(self, node_id: str) -> Optional[str]:
-        return self.refs.get(node_id)
-
-    def to_mermaid(self) -> str:
-        if not self.nodes:
-            return "graph LR\n    empty((empty))"
-
-        lines = ["graph LR"]
-        for node in self.nodes:
-            lines.append(node.to_mermaid())
-        for edge in self.edges:
-            lines.append(edge.to_mermaid())
-        return "\n".join(lines)
-
-    def to_markdown(self) -> str:
-        lines = [f"## Task Canvas: {self.task_id}\n"]
-        lines.append(f"Generated: {datetime.now(timezone.utc).isoformat()}\n")
-        lines.append("### Mermaid Diagram\n```mermaid")
-        lines.append(self.to_mermaid())
-        lines.append("```\n")
-        if self.refs:
-            lines.append("### References\n")
-            for node_id, content in self.refs.items():
-                lines.append(f"**{node_id}**: {content[:200]}...\n")
-        return "\n".join(lines)
-
-    @classmethod
-    def from_mermaid(cls, mermaid_text: str) -> Optional["MermaidCanvas"]:
-        try:
-            canvas = cls()
-            node_pattern = re.compile(r"(\w+)\[(.*?)\]")
-            for match in node_pattern.finditer(mermaid_text):
-                node_id, label = match.groups()
-                if node_id.startswith("N"):
-                    canvas.add_node(NodeType.ACTION, label)
-            return canvas
-        except Exception:
-            return None
-
-
-class SymbolicMemory:
-    def __init__(self, canvas: Optional[MermaidCanvas] = None):
-        self.canvas = canvas or MermaidCanvas()
-        self._verbose_cache: dict[str, str] = {}
-
-    def offload_log(self, node_id: str, verbose_content: str) -> str:
-        self._verbose_cache[node_id] = verbose_content
-        self.canvas.add_ref(node_id, f"See ref: {node_id}")
-        return f"[{node_id}]"
-
-    def recall_log(self, node_id: str) -> Optional[str]:
-        return self._verbose_cache.get(node_id)
-
-    def create_task_node(self, label: str, metadata: Optional[dict] = None) -> str:
-        return self.canvas.add_node(NodeType.TASK, label, metadata)
-
-    def create_action_node(self, label: str, metadata: Optional[dict] = None) -> str:
-        return self.canvas.add_node(NodeType.ACTION, label, metadata)
-
-    def create_result_node(self, label: str, result_content: str, metadata: Optional[dict] = None) -> str:
-        node_id = self.canvas.add_node(NodeType.RESULT, label, metadata)
-        self.offload_log(node_id, result_content)
-        return node_id
-
-    def create_error_node(self, label: str, error_content: str, metadata: Optional[dict] = None) -> str:
-        node_id = self.canvas.add_node(NodeType.ERROR, label, metadata)
-        self.offload_log(node_id, error_content)
-        return node_id
-
-    def link(self, from_id: str, to_id: str, label: Optional[str] = None) -> None:
-        self.canvas.add_edge(from_id, to_id, label)
-
-    def get_canvas_markdown(self) -> str:
-        return self.canvas.to_markdown()
-
-    def get_canvas_mermaid(self) -> str:
-        return self.canvas.to_mermaid()
-
-    def get_ref_content(self, node_id: str) -> Optional[str]:
-        return self._verbose_cache.get(node_id)