devsper 2.1.6__py3-none-any.whl

devsper/tools/system/run_shell_command.py

@@ -0,0 +1,51 @@
+"""Run a shell command and return stdout/stderr."""
+
+import subprocess
+import shlex
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class RunShellCommandTool(Tool):
+    """Execute a shell command and return combined stdout and stderr."""
+
+    name = "run_shell_command"
+    description = "Run a shell command. Returns stdout and stderr. Timeout 60s."
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "command": {"type": "string", "description": "Shell command to run"},
+            "timeout_seconds": {"type": "integer", "description": "Timeout in seconds (default 60)"},
+        },
+        "required": ["command"],
+    }
+
+    def run(self, **kwargs) -> str:
+        command = kwargs.get("command")
+        timeout = kwargs.get("timeout_seconds", 60)
+        if not command or not isinstance(command, str):
+            return "Error: command must be a non-empty string"
+        if not isinstance(timeout, int) or timeout < 1:
+            timeout = 60
+        try:
+            result = subprocess.run(
+                shlex.split(command) if isinstance(command, str) else [command],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            out = result.stdout or ""
+            err = result.stderr or ""
+            if err:
+                out = out + "\n--- stderr ---\n" + err
+            if result.returncode != 0:
+                out = f"[exit {result.returncode}]\n" + out
+            return out.strip() or "(no output)"
+        except subprocess.TimeoutExpired:
+            return f"Error: command timed out after {timeout}s"
+        except Exception as e:
+            return f"Error: {e}"
+
+
+register(RunShellCommandTool())

devsper/tools/system/system_info.py

@@ -0,0 +1,26 @@
+"""Return basic system information."""
+
+import platform
+import sys
+
+from devsper.tools.base import Tool
+from devsper.tools.registry import register
+
+
+class SystemInfoTool(Tool):
+    """Return system info: OS, machine, Python version."""
+
+    name = "system_info"
+    description = "Get system information: OS, machine, Python version."
+    input_schema = {"type": "object", "properties": {}, "required": []}
+
+    def run(self, **kwargs) -> str:
+        return (
+            f"system = {platform.system()}\n"
+            f"machine = {platform.machine()}\n"
+            f"processor = {platform.processor() or 'N/A'}\n"
+            f"python = {sys.version}"
+        )
+
+
+register(SystemInfoTool())

devsper/tools/tool_runner.py

@@ -0,0 +1,122 @@
+"""
+Tool runner: execute a tool by name with validated arguments and safe error handling.
+"""
+
+import time
+
+from devsper.tools.registry import get_with_mcp_fallback
+
+
+def _validate_args(args: dict, schema: dict) -> str | None:
+    """
+    Validate args against JSON Schema-style input_schema.
+    Returns None if valid, or an error message string if invalid.
+    """
+    if not isinstance(args, dict):
+        return "args must be a dict"
+    required = schema.get("required", [])
+    properties = schema.get("properties", {})
+    for key in required:
+        if key not in args:
+            return f"Missing required argument: {key}"
+    for key, value in args.items():
+        if key not in properties:
+            continue
+        prop = properties[key]
+        expected_type = prop.get("type")
+        if expected_type == "string" and not isinstance(value, str):
+            return f"Argument '{key}' must be a string"
+        if expected_type == "number" and not isinstance(value, (int, float)):
+            return f"Argument '{key}' must be a number"
+        if expected_type == "integer" and not isinstance(value, int):
+            return f"Argument '{key}' must be an integer"
+        if expected_type == "boolean" and not isinstance(value, bool):
+            return f"Argument '{key}' must be a boolean"
+        if expected_type == "array" and not isinstance(value, list):
+            return f"Argument '{key}' must be an array"
+        if expected_type == "object" and not isinstance(value, dict):
+            return f"Argument '{key}' must be an object"
+    return None
+
+
+def run_tool(
+    name: str,
+    args: dict,
+    task_type: str | None = None,
+) -> str:
+    """
+    Execute the tool by name with the given arguments.
+
+    Validates args against the tool's input_schema, runs the tool, and returns
+    its string output. On validation failure or exception, returns a formatted error string.
+    Records usage to tool analytics and tool scoring when available.
+    """
+    start = time.perf_counter()
+    tool = get_with_mcp_fallback(name)
+    if tool is None:
+        _record_analytics(name, False, start)
+        _record_scoring(name, task_type, False, start, error_type="ToolNotFound")
+        return f"Tool not found: {name}"
+    resolved_name = tool.name
+    err = _validate_args(args, tool.input_schema)
+    if err is not None:
+        _record_analytics(resolved_name, False, start)
+        _record_scoring(resolved_name, task_type, False, start, error_type="ValidationError")
+        return f"Validation error: {err}"
+    try:
+        result = tool.run(**args)
+        latency_ms = int((time.monotonic() - start) * 1000)
+        success = not (isinstance(result, str) and result.startswith("Tool error:"))
+        _record_analytics(resolved_name, success, start)
+        _record_scoring(resolved_name, task_type, success, start, latency_ms=latency_ms)
+        return result
+    except Exception as e:
+        latency_ms = int((time.monotonic() - start) * 1000)
+        _record_analytics(resolved_name, False, start)
+        _record_scoring(
+            resolved_name,
+            task_type,
+            False,
+            start,
+            latency_ms=latency_ms,
+            error_type=type(e).__name__,
+        )
+        return f"Tool error: {type(e).__name__}: {e}"
+
+
+def _record_analytics(tool_name: str, success: bool, start_time: float) -> None:
+    """Record tool invocation to analytics if available."""
+    try:
+        from devsper.analytics import get_default_analytics
+
+        latency_ms = (time.perf_counter() - start_time) * 1000
+        get_default_analytics().record(tool_name, success, latency_ms)
+    except Exception:
+        pass
+
+
+def _record_scoring(
+    tool_name: str,
+    task_type: str | None,
+    success: bool,
+    start_time: float,
+    latency_ms: int | None = None,
+    error_type: str | None = None,
+) -> None:
+    """Record tool result to scoring store if available."""
+    try:
+        from devsper.tools.scoring import record_tool_result
+    except Exception:
+        return
+    if latency_ms is None:
+        latency_ms = int((time.perf_counter() - start_time) * 1000)
+    try:
+        record_tool_result(
+            tool_name,
+            task_type or "general",
+            success=success,
+            latency_ms=latency_ms,
+            error_type=error_type,
+        )
+    except Exception:
+        pass

devsper/tui/__init__.py

@@ -0,0 +1,5 @@
+"""Terminal UI for devsper swarm runtime."""
+
+from devsper.tui.app import devsperTUI
+
+__all__ = ["devsperTUI"]

devsper/tui/activity_feed_view.py

@@ -0,0 +1,73 @@
+"""
+Agent activity feed: chronological feed of agent actions (task started/ended, tool calls).
+Reads from EventLog when log path is set.
+"""
+
+from textual.widgets import Static
+
+
+class ActivityFeedView(Static):
+    """Shows recent events: TASK_STARTED, TASK_COMPLETED, TOOL_CALLED, etc."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._events_folder: str = ".devsper/events"
+        self._log_path: str | None = None
+        self._lines: list[str] = []
+
+    def set_events_folder(self, folder: str) -> None:
+        self._events_folder = folder
+
+    def set_log_path(self, path: str | None) -> None:
+        self._log_path = path
+
+    def refresh_events(self, limit: int = 50) -> None:
+        """Load recent events from the event log and display as feed."""
+        self._lines = []
+        try:
+            from pathlib import Path
+            import json
+
+            path = self._log_path
+            if not path and self._events_folder:
+                folder = Path(self._events_folder)
+                if folder.is_dir():
+                    files = sorted(folder.glob("*.jsonl"), key=lambda p: p.stat().st_mtime, reverse=True)
+                    path = str(files[0]) if files else None
+            if not path or not Path(path).is_file():
+                self._lines = ["(no event log)\nRun swarm to see activity."]
+                self.update("\n".join(self._lines))
+                return
+            with open(path) as f:
+                raw_lines = f.readlines()
+            for line in raw_lines[-limit:]:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                    ev = obj.get("type", "?")
+                    payload = obj.get("payload", {})
+                    task_id = payload.get("task_id", "")
+                    tool = payload.get("tool", "")
+                    if ev == "task_started":
+                        self._lines.append(f"[dim]▶ task {task_id}[/dim]")
+                    elif ev == "task_completed":
+                        self._lines.append(f"[dim]✔ task {task_id}[/dim]")
+                    elif ev == "tool_called":
+                        self._lines.append(f"[dim]🔧 {tool} (task {task_id})[/dim]")
+                    elif ev == "user_injection":
+                        msg = (payload.get("message") or "")[:60]
+                        if len(payload.get("message") or "") > 60:
+                            msg += "…"
+                        self._lines.append(f"📌 [bold]User injected:[/] [dim]{msg}[/]")
+                    else:
+                        self._lines.append(f"[dim]{ev}[/dim]")
+                except Exception:
+                    self._lines.append(line[:80])
+        except Exception as e:
+            self._lines = [f"(error: {e})"]
+        self.update("\n".join(self._lines[-limit:]))
+
+    def on_mount(self) -> None:
+        self.update("(activity feed)\n\nRun swarm to see events.")

devsper/tui/adaptive_tasks_view.py

@@ -0,0 +1,75 @@
+"""
+Adaptive task creation: show when alternative tasks were injected (e.g. after failure).
+"""
+
+from textual.widgets import Static
+
+
+class AdaptiveTasksView(Static):
+    """Shows adaptive events: failed tasks and newly created alternative tasks."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._events_folder: str = ".devsper/events"
+        self._log_path: str | None = None
+
+    def set_events_folder(self, folder: str) -> None:
+        self._events_folder = folder
+
+    def set_log_path(self, path: str | None) -> None:
+        self._log_path = path
+
+    def refresh_adaptive_events(self, limit: int = 20) -> None:
+        """Load task_failed and subsequent task_created from event log."""
+        lines = ["(Adaptive task creation)", ""]
+        try:
+            from pathlib import Path
+            import json
+
+            path = self._log_path
+            if not path and self._events_folder:
+                folder = Path(self._events_folder)
+                if folder.is_dir():
+                    files = sorted(
+                        folder.glob("*.jsonl"),
+                        key=lambda p: p.stat().st_mtime,
+                        reverse=True,
+                    )
+                    path = str(files[0]) if files else None
+            if not path or not Path(path).is_file():
+                self.update("(Adaptive tasks)\n\nNo event log.\nRun with adaptive_execution=true to see alternatives.")
+                return
+            with open(path) as f:
+                raw = f.readlines()
+            failed_ids = set()
+            created_after_fail = []
+            for line in raw:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                    ev = obj.get("type", "?")
+                    payload = obj.get("payload", {})
+                    if ev == "task_failed":
+                        failed_ids.add(payload.get("task_id", ""))
+                    if ev == "task_created" and failed_ids:
+                        created_after_fail.append(
+                            (payload.get("task_id", ""), payload.get("description", "")[:60])
+                        )
+                except Exception:
+                    pass
+            if failed_ids:
+                lines.append("Failed tasks:")
+                for tid in list(failed_ids)[:5]:
+                    lines.append(f"  • {tid}")
+                lines.append("")
+            if created_after_fail:
+                lines.append("New tasks (after failure):")
+                for tid, desc in created_after_fail[-limit:]:
+                    lines.append(f"  • {tid}: {desc}")
+            elif not failed_ids:
+                lines.append("No adaptive events in this run.")
+        except Exception as e:
+            lines.append(f"Error: {e}")
+        self.update("\n".join(lines))

devsper/tui/agent_role_view.py

@@ -0,0 +1,35 @@
+"""
+Agent role activity: show which roles are active and for which tasks.
+"""
+
+from textual.widgets import Static
+
+
+class AgentRoleActivityView(Static):
+    """Shows agent role per task: research_agent, code_agent, analysis_agent, critic_agent."""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._tasks_with_roles: list[dict] = []
+
+    def set_tasks_with_roles(self, tasks: list[dict]) -> None:
+        """Update with list of {task_id, role, status}. Role can be None."""
+        self._tasks_with_roles = tasks
+        self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        if not self._tasks_with_roles:
+            self.update("(Agent roles)\n\nNo task/role data yet.")
+            return
+        by_role: dict[str, list[str]] = {}
+        for t in self._tasks_with_roles:
+            role = t.get("role") or "general"
+            tid = t.get("task_id", "?")
+            by_role.setdefault(role, []).append(tid)
+        lines = ["(Agent role activity)", ""]
+        for role in ["research_agent", "code_agent", "analysis_agent", "critic_agent", "general"]:
+            if role not in by_role:
+                continue
+            tasks = by_role[role][:10]
+            lines.append(f"  {role}: {', '.join(tasks)}")
+        self.update("\n".join(lines))