devsper 2.1.6__py3-none-any.whl

devsper/tui/dev_view.py

@@ -0,0 +1,99 @@
+"""
+TUI Dev View: repository tree, test results, file changes.
+
+Shown in dashboard when working with the autonomous application builder.
+"""
+
+from pathlib import Path
+
+from textual.widgets import Static
+from textual.reactive import reactive
+
+
+def _tree_for_path(root: Path, max_depth: int = 4, max_entries: int = 80) -> list[str]:
+    """Build a simple tree of relative paths under root."""
+    lines: list[str] = []
+    root = root.resolve()
+    if not root.exists() or not root.is_dir():
+        return ["(no directory)"]
+
+    def walk(p: Path, prefix: str, depth: int) -> None:
+        if len(lines) >= max_entries or depth > max_depth:
+            return
+        try:
+            entries = sorted(p.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+            for i, e in enumerate(entries):
+                if e.name.startswith(".") or e.name == "__pycache__":
+                    continue
+                if len(lines) >= max_entries:
+                    return
+                is_last = i == len(entries) - 1
+                branch = "└── " if is_last else "├── "
+                lines.append(prefix + branch + e.name)
+                if e.is_dir():
+                    ext = "    " if is_last else "│   "
+                    walk(e, prefix + ext, depth + 1)
+        except OSError:
+            pass
+
+    walk(root, "", 0)
+    return lines if lines else ["(empty)"]
+
+
+class DevView(Static):
+    """
+    Panel showing repository tree, test results, and file changes for build output.
+    """
+
+    repo_path: reactive[str | None] = reactive(None)
+    test_results: reactive[str] = reactive("")
+    file_changes: reactive[list[str]] = reactive(list)
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._repo_path: str | None = None
+        self._test_results = ""
+        self._file_changes: list[str] = []
+
+    def set_repo_path(self, path: str | None) -> None:
+        self._repo_path = path
+        self.repo_path = path
+
+    def set_test_results(self, text: str) -> None:
+        self._test_results = text
+        self.test_results = text
+
+    def set_file_changes(self, changes: list[str]) -> None:
+        self._file_changes = changes
+        self.file_changes = changes
+
+    def watch_repo_path(self, path: str | None) -> None:
+        self._repo_path = path
+        self._refresh()
+
+    def watch_test_results(self, text: str) -> None:
+        self._test_results = text
+        self._refresh()
+
+    def watch_file_changes(self, changes: list[str]) -> None:
+        self._file_changes = changes or []
+        self._refresh()
+
+    def _refresh(self) -> None:
+        lines = ["Dev — Build output", ""]
+        if self._repo_path:
+            root = Path(self._repo_path)
+            lines.append("Repository tree:")
+            lines.extend(_tree_for_path(root))
+            lines.append("")
+        else:
+            lines.append("Repository: (none — run 'devsper build \"app\"' to generate)")
+            lines.append("")
+
+        lines.append("Test results:")
+        lines.append(self._test_results[:1500] if self._test_results else "(no results)")
+        lines.append("")
+        lines.append("File changes:")
+        for c in (self._file_changes or [])[:20]:
+            lines.append(f"  {c}")
+        self.update("\n".join(lines))

devsper/tui/inject_screen.py

@@ -0,0 +1,73 @@
+"""
+Overlay screen: inject a note to the swarm (stored as high-priority memory).
+"""
+
+from datetime import datetime, timezone
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static
+
+from devsper.types.event import Event, events
+from devsper.memory.memory_store import get_default_store, generate_memory_id
+from devsper.memory.memory_types import MemoryRecord, MemoryType
+
+
+class InjectScreen(ModalScreen[None]):
+    """Modal: 'Inject note to swarm' input; on Submit store as episodic + user_injection and close."""
+
+    BINDINGS = [("escape", "cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Container(id="inject-container"):
+            yield Static("Inject note to swarm:", id="inject-label")
+            yield Input(placeholder="Type your message...", id="inject-input")
+            with Container(id="inject-buttons"):
+                yield Button("Submit", variant="primary", id="inject-submit")
+                yield Button("Cancel", id="inject-cancel")
+
+    def on_mount(self) -> None:
+        self.query_one("#inject-input", Input).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "inject-submit":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "inject-input":
+            self._submit()
+
+    def _submit(self) -> None:
+        inp = self.query_one("#inject-input", Input)
+        message = (inp.value or "").strip()
+        if not message:
+            return
+        store = get_default_store()
+        record = MemoryRecord(
+            id=generate_memory_id(),
+            memory_type=MemoryType.EPISODIC,
+            source_task="user_injection",
+            content=message,
+            tags=["user_injection"],
+        )
+        store.store(record)
+        log_path = getattr(self.app, "_event_log_path", None)
+        if log_path:
+            try:
+                ev = Event(
+                    timestamp=datetime.now(timezone.utc),
+                    type=events.USER_INJECTION,
+                    payload={"message": message[:500]},
+                )
+                with open(log_path, "a", encoding="utf-8") as f:
+                    f.write(ev.model_dump_json() + "\n")
+            except OSError:
+                pass
+        self.dismiss(None)
+        self.notify("📌 Injected. Subsequent agent calls will see this note.", severity="information")
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

devsper/tui/knowledge_graph_view.py

@@ -0,0 +1,46 @@
+"""
+Knowledge graph viewer: list entities and relationships from the knowledge graph.
+Builds KG from default memory store on demand.
+"""
+
+from textual.widgets import Static
+
+
+class KnowledgeGraphView(Static):
+    """Shows entities and edges from the knowledge graph (built from memory)."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._text = "(knowledge graph)\n\nRefresh to build from memory."
+
+    def load_from_memory(self, limit_entities: int = 40, limit_edges: int = 30) -> None:
+        """Build KG from default store and display entities + edges."""
+        try:
+            from devsper.knowledge.knowledge_graph import KnowledgeGraph
+            from devsper.memory.memory_store import get_default_store
+
+            store = get_default_store()
+            kg = KnowledgeGraph(store=store)
+            kg.build_from_memory()
+            g = kg.graph
+            entities = []
+            for nid, data in g.nodes(data=True):
+                kind = data.get("kind", "?")
+                label = (data.get("label") or nid)[:60]
+                entities.append(f"  {nid[:40]} [{kind}] {label}")
+            edges = []
+            for u, v, data in list(g.edges(data=True))[:limit_edges]:
+                et = data.get("type", "")
+                edges.append(f"  {u[:25]} --[{et}]--> {v[:25]}")
+            if not entities and not edges:
+                self._text = "(no entities)\n\nAdd memory and refresh."
+            else:
+                self._text = "Entities:\n" + "\n".join(entities[:limit_entities])
+                if edges:
+                    self._text += "\n\nEdges:\n" + "\n".join(edges)
+        except Exception as e:
+            self._text = f"(error: {e})"
+        self.update(self._text)
+
+    def on_mount(self) -> None:
+        self.update(self._text)

devsper/tui/layout.py

@@ -0,0 +1,43 @@
+"""
+TUI layout: output-first. One main view = prompt + full-height output.
+
+No side panels on main screen (no scrolling in tiny boxes). Dashboard (d) for tasks/logs/memory.
+"""
+
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical
+from textual.widgets import Input, Static
+
+from devsper.tui.results_view import ResultsView
+
+
+class PromptInput(Input):
+    """Input that yields focus on Escape so r / d / q work."""
+
+    def on_key(self, event):
+        if event.key == "escape":
+            try:
+                self.app.set_focus(self.app.query_one("#results-view"))
+            except Exception:
+                pass
+            event.prevent_default().stop()
+
+
+class devsperLayout(Static):
+    """Main view: compact branding → prompt → one large Output (rest of screen)."""
+
+    def compose(self) -> ComposeResult:
+        with Container(id="branding"):
+            yield Static("devsper — Distributed AI Swarm Runtime", id="logo-line")
+        with Container(id="prompt-box"):
+            yield PromptInput(
+                placeholder="Ask anything... e.g. Summarize swarm intelligence in one paragraph.",
+                id="prompt-input",
+            )
+        yield Static(
+            "Esc unfocus input  •  Enter or r run  •  o output  •  q quit",
+            id="action-hints",
+        )
+        with Vertical(id="output-container"):
+            yield Static("Response", classes="output-title")
+            yield ResultsView(id="results-view")

devsper/tui/logs_view.py

@@ -0,0 +1,83 @@
+"""
+Logs panel: stream events from EventLog.
+
+Polls event log file(s) or uses in-memory events. Displays event type and payload summary.
+"""
+
+import os
+from pathlib import Path
+
+from textual.widgets import Static
+
+
+class LogsView(Static):
+    """Displays event log stream: event type, task_id, etc."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._log_path: str | None = None
+        self._events_folder: str = ".devsper/events"
+        self._max_lines: int = 100
+        self._last_count: int = 0
+
+    def set_log_path(self, path: str | None) -> None:
+        """Set the event log file path to read from."""
+        self._log_path = path
+
+    def set_events_folder(self, folder: str) -> None:
+        """Set folder to search for latest events_*.jsonl."""
+        self._events_folder = folder
+
+    def _latest_log_path(self) -> str | None:
+        if self._log_path and os.path.exists(self._log_path):
+            return self._log_path
+        if not os.path.isdir(self._events_folder):
+            alt = ".devsper/events"
+            if os.path.isdir(alt):
+                self._events_folder = alt
+            else:
+                return None
+        files = list(Path(self._events_folder).glob("events_*.jsonl"))
+        if not files:
+            return None
+        files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+        return str(files[0])
+
+    def _read_events(self) -> list[str]:
+        """Read events and return list of display lines."""
+        path = self._latest_log_path()
+        if not path:
+            return [
+                "No logs yet.",
+                "",
+                "↑ Run a task (prompt above, then Enter or r);",
+                "  events will appear here.",
+            ]
+        lines = []
+        try:
+            from devsper.types.event import Event
+
+            with open(path, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        ev = Event.model_validate_json(line)
+                        payload = ev.payload or {}
+                        task_id = payload.get("task_id", "")
+                        extra = f" {task_id}" if task_id else ""
+                        lines.append(f"{ev.type.value}{extra}")
+                    except Exception:
+                        lines.append(line[:80])
+        except Exception as e:
+            lines.append(f"(error: {e})")
+        return lines[-self._max_lines :] if len(lines) > self._max_lines else lines
+
+    def refresh_logs(self) -> None:
+        """Re-read event log and update display."""
+        lines = self._read_events()
+        self.update("\n".join(lines) if lines else "(no events)")
+
+    def on_mount(self) -> None:
+        self.refresh_logs()

devsper/tui/memory_view.py

@@ -0,0 +1,58 @@
+"""
+Memory panel: list memory entries with tags and summaries.
+"""
+
+from textual.widgets import Static
+
+
+class MemoryView(Static):
+    """Displays memory entries: id, tags, content summary."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._entries: list[dict] = []
+
+    def set_entries(self, entries: list[dict]) -> None:
+        """Update entries. Each dict: id, tags (list), summary or content (str)."""
+        self._entries = entries
+        self._refresh_display()
+
+    def load_from_store(self, limit: int = 20, namespace: str | None = None) -> None:
+        """Load from default memory store. If namespace is set, filter by namespace tag."""
+        try:
+            from devsper.memory.memory_store import get_default_store
+
+            store = get_default_store()
+            records = store.list_memory(limit=limit * 2 if namespace else limit)
+            if namespace:
+                from devsper.memory.namespaces import filter_by_namespace
+                records = filter_by_namespace(records, namespace)[:limit]
+            self._entries = [
+                {
+                    "id": r.id[:8] + "…" if len(r.id) > 8 else r.id,
+                    "tags": r.tags or [],
+                    "summary": (r.content or "")[:120]
+                    + ("…" if len(r.content or "") > 120 else ""),
+                }
+                for r in records
+            ]
+        except Exception as e:
+            self._entries = [{"id": "error", "tags": [], "summary": str(e)}]
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        if not self._entries:
+            self.update("(no memory entries)\n\n[m] refresh memory")
+            return
+        lines = []
+        for e in self._entries:
+            eid = e.get("id", "?")
+            tags = e.get("tags", [])
+            summary = e.get("summary", e.get("content", ""))[:100]
+            tag_str = ", ".join(tags[:5]) if tags else "-"
+            lines.append(f"{eid} [{tag_str}]")
+            lines.append(f"  {summary}")
+        self.update("\n".join(lines))
+
+    def on_mount(self) -> None:
+        self.load_from_store()

devsper/tui/performance_view.py

@@ -0,0 +1,33 @@
+"""Dashboard panel: speculative tasks, cache hits, tool usage stats."""
+
+from textual.widgets import Static
+
+
+class PerformanceView(Static):
+    """Shows speculative status, cache stats, and tool usage summary."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__("", *args, **kwargs)
+
+    def set_stats(
+        self,
+        speculative_enabled: bool = False,
+        speculative_count: int = 0,
+        cache_entries: int = 0,
+        tool_stats: list[dict] | None = None,
+    ) -> None:
+        lines = [
+            "Speculative: " + ("on" if speculative_enabled else "off"),
+            f"Speculative tasks: {speculative_count}",
+            f"Cache entries: {cache_entries}",
+            "Tools:",
+        ]
+        if tool_stats:
+            for s in tool_stats[:8]:
+                lines.append(
+                    f"  {s['tool_name']}: n={s['count']} "
+                    f"ok%={s['success_rate']:.0f} lat={s['avg_latency_ms']}ms"
+                )
+        else:
+            lines.append("  (no data)")
+        self.update("\n".join(lines))

devsper/tui/reasoning_graph_view.py

@@ -0,0 +1,39 @@
+"""
+Reasoning graph viewer: show reasoning nodes from the current run's reasoning store.
+"""
+
+from textual.widgets import Static
+
+
+class ReasoningGraphView(Static):
+    """Displays reasoning nodes (agent_id, task_id, content preview) from ReasoningStore."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._reasoning_store = None
+
+    def set_reasoning_store(self, store) -> None:
+        """Set the ReasoningStore to display (e.g. from app or swarm)."""
+        self._reasoning_store = store
+
+    def load_from_store(self) -> None:
+        """Load nodes from the configured store and update display."""
+        if self._reasoning_store is None:
+            self.update("(Reasoning graph)\n\nNo reasoning store for this run.")
+            return
+        try:
+            nodes = self._reasoning_store.query_nodes(limit=30)
+            if not nodes:
+                self.update("(Reasoning graph)\n\nNo reasoning nodes yet.")
+                return
+            lines = ["(Reasoning graph)", ""]
+            for n in nodes[:20]:
+                preview = (n.content or "")[:80].replace("\n", " ")
+                if len(n.content or "") > 80:
+                    preview += "..."
+                lines.append(f"  {n.id} [{n.agent_id}] task={n.task_id}")
+                lines.append(f"    {preview}")
+                lines.append("")
+            self.update("\n".join(lines))
+        except Exception as e:
+            self.update(f"(Reasoning graph)\n\nError: {e}")

devsper/tui/results_view.py

@@ -0,0 +1,139 @@
+"""
+Response panel: LLM-style. Shows "You asked" + cleaned response (real content only).
+"""
+
+import re
+from textual.widgets import Static
+
+
+def _collapse_long_tool_results(text: str, max_keep: int = 120) -> str:
+    """Replace long 'Tool result (name): ...' blocks with [output omitted] so we don't dump code/file contents."""
+    if not text or "Tool result (" not in text:
+        return text
+    pattern = re.compile(
+        r"(Tool result\s*\(\s*\w+\s*\)\s*:\s*\n?)(.*?)(?=Tool result\s*\(\s*\w+\s*\)\s*:|Response:\n|\Z)",
+        re.DOTALL | re.IGNORECASE,
+    )
+    def repl(m):
+        prefix, content = m.group(1), (m.group(2) or "").strip()
+        if len(content) <= max_keep and content.count("\n") <= 1:
+            return m.group(0)
+        return prefix + "[output omitted]\n"
+    return pattern.sub(repl, text)
+
+
+def _extract_real_content(text: str) -> str:
+    """Keep only the actual answer: remove all agent boilerplate."""
+    if not text or not text.strip():
+        return ""
+    out = text.strip()
+    out = _collapse_long_tool_results(out)
+    out = re.sub(
+        r"Completed:\s*You are an AI worker in a distributed system\.?\s*",
+        "",
+        out,
+        flags=re.IGNORECASE,
+    )
+    out = re.sub(r"Task:\s*\n\s*[^\n]*", "", out, flags=re.IGNORECASE)
+    out = re.sub(r"^Task:\s*$", "", out, flags=re.MULTILINE | re.IGNORECASE)
+    out = re.sub(
+        r"RELEVANT MEMORY\s*\([^)]*\)\s*:?\s*\n(?:\s*-\s*[^\n]*\n?)*",
+        "",
+        out,
+        flags=re.IGNORECASE,
+    )
+    out = re.sub(
+        r"RELEVANT MEMORY\s*\n(?:\s*-\s*[^\n]*\n?)*",
+        "",
+        out,
+        flags=re.IGNORECASE,
+    )
+    out = re.sub(r"^RELEVANT MEMORY\s*$", "", out, flags=re.MULTILINE | re.IGNORECASE)
+    out = re.sub(r"\(previous research notes[^)]*\)", "", out, flags=re.IGNORECASE)
+    out = re.sub(
+        r"^(?:First|Second|Third|Fourth|Fifth|Sixth)\s+step\s*$",
+        "",
+        out,
+        flags=re.MULTILINE | re.IGNORECASE,
+    )
+    out = re.sub(r"^\.\.\.\s*$", "", out, flags=re.MULTILINE)
+    out = re.sub(r"^—\s*$", "", out, flags=re.MULTILINE)
+    out = re.sub(r"^\s*-\s*[a-f0-9]{8}[^\n]*$", "", out, flags=re.MULTILINE)
+    out = re.sub(r"\n{3,}", "\n\n", out)
+    return out.strip()
+
+
+SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
+class ResultsView(Static):
+    """LLM-style: shows last question + cleaned response (real content only)."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._prompt = ""
+        self._response = ""
+        self._loading = False
+        self._loading_message = "Running…"
+        self._spinner_index = 0
+
+    def set_loading(self, running: bool, message: str = "Running…") -> None:
+        self._loading = running
+        self._loading_message = message or "Running…"
+        self._refresh_display()
+
+    def tick_loading(self) -> None:
+        if not self._loading:
+            return
+        self._spinner_index = (self._spinner_index + 1) % len(SPINNER)
+        self._refresh_display()
+
+    def set_exchange(self, prompt: str, response: str) -> None:
+        """Set the last user prompt and the cleaned response (LLM-style)."""
+        self._prompt = (prompt or "").strip()
+        raw = (response or "").strip()
+        cleaned = _extract_real_content(raw)
+        self._response = cleaned if cleaned else ""
+        self._refresh_display()
+
+    def set_output(self, text: str, strip_boilerplate: bool = True) -> None:
+        """Legacy: set response only (no prompt)."""
+        raw = (text or "").strip()
+        cleaned = _extract_real_content(raw) if strip_boilerplate else raw
+        self._response = cleaned if cleaned else raw
+        self._refresh_display()
+
+    def clear_output(self) -> None:
+        self._prompt = ""
+        self._response = ""
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        if self._loading:
+            parts = []
+            if self._prompt:
+                parts.append(f"You asked: {self._prompt}\n")
+            parts.append(f"{SPINNER[self._spinner_index]} {self._loading_message}")
+            self.update("\n".join(parts))
+            return
+        if not self._response and not self._prompt:
+            self.update(
+                "Ask something above and press Enter or r to run.\n\n"
+                "Your response will appear here."
+            )
+            return
+        parts = []
+        if self._prompt:
+            parts.append(f"You asked: {self._prompt}\n")
+        parts.append(
+            self._response
+            if self._response
+            else "No substantive output yet. Set OPENAI_API_KEY (or another provider) and run again for the full response."
+        )
+        self.update("\n".join(parts))
+
+    @property
+    def can_focus(self) -> bool:
+        return True
+
+    def on_mount(self) -> None:
+        self._refresh_display()

devsper/tui/swarm_view.py

@@ -0,0 +1,37 @@
+"""
+Swarm graph panel: ASCII DAG from scheduler.
+
+Uses runtime.visualize.visualize_scheduler_dag when scheduler is set.
+"""
+
+from textual.widgets import Static
+
+
+class SwarmView(Static):
+    """Displays DAG visualization of the task graph."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._dag_text = "(no DAG)\n\nRun swarm to see graph."
+
+    def set_scheduler(self, scheduler: object | None) -> None:
+        """Update DAG from scheduler. Pass None to clear."""
+        if scheduler is None:
+            self._dag_text = "(no DAG)\n\nRun swarm to see graph."
+            self.update(self._dag_text)
+            return
+        try:
+            from devsper.runtime.visualize import visualize_scheduler_dag
+
+            self._dag_text = visualize_scheduler_dag(scheduler)
+        except Exception as e:
+            self._dag_text = f"(error: {e})"
+        self.update(self._dag_text)
+
+    def set_dag_text(self, text: str) -> None:
+        """Set DAG content directly (e.g. for demo)."""
+        self._dag_text = text
+        self.update(text)
+
+    def on_mount(self) -> None:
+        self.update(self._dag_text)