devsper 2.1.6__py3-none-any.whl

devsper/upgrade/installer.py

@@ -0,0 +1,103 @@
+"""
+Installer detection (uv vs pip) and install execution.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Literal
+
+PACKAGE_NAME = "devsper"
+INSTALL_TIMEOUT = 120
+
+
+def detect_installer() -> Literal["uv", "pip"]:
+    """
+    Check in order: DEVSPER_INSTALLER env, uv-managed env, which uv, else pip.
+    """
+    env = os.environ.get("DEVSPER_INSTALLER", "").strip().lower()
+    if env in ("uv", "pip"):
+        return "uv" if env == "uv" else "pip"
+
+    # Check if we're in a uv-managed environment
+    cwd = Path.cwd()
+    home = Path.home()
+    while cwd != home and cwd != cwd.parent:
+        if (cwd / ".python-version").exists() or (cwd / "uv.lock").exists():
+            if shutil.which("uv"):
+                return "uv"
+            break
+        cwd = cwd.parent
+    if (home / ".python-version").exists() or (home / "uv.lock").exists():
+        if shutil.which("uv"):
+            return "uv"
+
+    # sys.executable in .venv or /uv/ often indicates uv
+    exe = sys.executable
+    if "/uv/" in exe or ".venv" in exe:
+        if shutil.which("uv"):
+            return "uv"
+
+    if shutil.which("uv"):
+        return "uv"
+    return "pip"
+
+
+def get_install_command(
+    installer: Literal["uv", "pip"],
+    package: str = PACKAGE_NAME,
+    version: str | None = None,
+) -> list[str]:
+    """Build the install command list."""
+    spec = f"{package}=={version}" if version else package
+    if installer == "uv":
+        return ["uv", "pip", "install", "--upgrade", spec]
+    return [sys.executable, "-m", "pip", "install", "--upgrade", spec]
+
+
+def perform_install(
+    installer: Literal["uv", "pip"], version: str | None = None
+) -> tuple[bool, str]:
+    """
+    Run the install command. Returns (success, output).
+    Timeout 120 seconds.
+    """
+    cmd = get_install_command(installer, version=version)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=INSTALL_TIMEOUT,
+        )
+        out = (result.stdout or "") + (result.stderr or "")
+        if result.returncode != 0:
+            return (False, out)
+        return (True, out)
+    except subprocess.TimeoutExpired:
+        return (False, "Installation timed out after 120 seconds.")
+    except Exception as e:
+        return (False, str(e))
+
+
+def verify_installation(expected_version: str) -> bool:
+    """Run Python to get installed devsper version and compare to expected."""
+    try:
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-c",
+                "import importlib.metadata; print(importlib.metadata.version('devsper'))",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if result.returncode != 0:
+            return False
+        actual = result.stdout.strip()
+        return actual == expected_version
+    except Exception:
+        return False

devsper/upgrade/notifier.py

@@ -0,0 +1,52 @@
+"""
+Startup nag: print upgrade notice if behind, once per session; suppress during upgrade.
+"""
+
+import time
+
+from rich.console import Console
+from rich.panel import Panel
+
+_notified = False
+_suppress = False
+_console = Console(stderr=True)
+
+
+def suppress_notifications() -> None:
+    """Call when running 'devsper upgrade' so the nag does not appear."""
+    global _suppress
+    _suppress = True
+
+
+def check_and_notify() -> None:
+    """
+    If an update is available, print a compact Rich notice once per session.
+    Non-blocking, try/except, aim for <100ms (cache read usually).
+    """
+    global _notified
+    if _suppress or _notified:
+        return
+    deadline = time.monotonic() + 0.1  # 100ms max
+    try:
+        from .version_check import is_update_available, get_version_diff_type
+
+        if time.monotonic() > deadline:
+            return
+        available, current, latest = is_update_available()
+        if not available or current == latest:
+            return
+        if time.monotonic() > deadline:
+            return
+        _notified = True
+        diff_type = get_version_diff_type(current, latest)
+        color: str = {"major": "red", "minor": "yellow", "patch": "green"}.get(
+            diff_type, "white"
+        )
+        msg = (
+            f"Update available: [bold]{current}[/bold] → [bold]{latest}[/bold]  "
+            f"[{color}][{diff_type}][/{color}]\n"
+            "Run [bold]devsper upgrade[/bold] to update"
+        )
+        _console.print(Panel(msg, border_style="dim", padding=(0, 1)))
+    except Exception:
+        pass

devsper/upgrade/version_check.py

@@ -0,0 +1,121 @@
+"""
+Version checking: PyPI latest version, cache, semver comparison.
+"""
+
+import json
+from pathlib import Path
+from typing import Literal
+
+import httpx
+
+PYPI_URL = "https://pypi.org/pypi/devsper/json"
+CACHE_FILE = Path("~/.config/devsper/update_check.json").expanduser()
+CACHE_TTL_HOURS = 24
+PACKAGE_NAME = "devsper"
+
+
+def get_current_version() -> str:
+    """Read current installed version from importlib.metadata."""
+    import importlib.metadata
+
+    return importlib.metadata.version(PACKAGE_NAME)
+
+
+def _cache_is_fresh() -> bool:
+    if not CACHE_FILE.is_file():
+        return False
+    try:
+        data = json.loads(CACHE_FILE.read_text())
+        checked_at = data.get("checked_at", "")
+        if not checked_at:
+            return False
+        from datetime import datetime, timezone
+
+        # ISO format with Z
+        dt = datetime.fromisoformat(checked_at.replace("Z", "+00:00"))
+        now = datetime.now(timezone.utc)
+        age_hours = (now - dt).total_seconds() / 3600
+        return age_hours < CACHE_TTL_HOURS
+    except (json.JSONDecodeError, ValueError, OSError):
+        return False
+
+
+def _read_cached_version() -> str | None:
+    if not _cache_is_fresh():
+        return None
+    try:
+        data = json.loads(CACHE_FILE.read_text())
+        return data.get("latest")
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def _write_cache(latest: str) -> None:
+    from datetime import datetime, timezone
+
+    CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "latest": latest,
+        "checked_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    }
+    CACHE_FILE.write_text(json.dumps(data, indent=2))
+    try:
+        CACHE_FILE.chmod(0o600)
+    except OSError:
+        pass
+
+
+def get_latest_version() -> str:
+    """
+    Fetch latest version from PyPI with 24h cache.
+    On network error, return current version (fail silently).
+    """
+    cached = _read_cached_version()
+    if cached is not None:
+        return cached
+    try:
+        resp = httpx.get(PYPI_URL, timeout=5.0)
+        resp.raise_for_status()
+        info = resp.json().get("info") or {}
+        latest = info.get("version") or get_current_version()
+        _write_cache(latest)
+        return latest
+    except (httpx.HTTPError, json.JSONDecodeError, KeyError):
+        return get_current_version()
+
+
+def parse_semver(version: str) -> tuple[int, int, int]:
+    """Parse '1.2.3' or '1.2.3.post1' into (1, 2, 3)."""
+    # Strip pre/post/dev suffixes for comparison
+    base = version.split("+")[0].split("-")[0]
+    parts = base.split(".")
+    major = int(parts[0]) if len(parts) > 0 else 0
+    minor = int(parts[1]) if len(parts) > 1 else 0
+    patch = int(parts[2]) if len(parts) > 2 else 0
+    return (major, minor, patch)
+
+
+def get_version_diff_type(
+    current: str, latest: str
+) -> Literal["major", "minor", "patch"]:
+    """Compare semver tuples; return highest changed segment."""
+    c = parse_semver(current)
+    l = parse_semver(latest)
+    if l[0] != c[0]:
+        return "major"
+    if l[1] != c[1]:
+        return "minor"
+    return "patch"
+
+
+def is_update_available() -> tuple[bool, str, str]:
+    """
+    Returns (available, current, latest).
+    Uses cache for latest; on network error latest may equal current.
+    """
+    current = get_current_version()
+    latest = get_latest_version()
+    c = parse_semver(current)
+    l = parse_semver(latest)
+    available = (l[0], l[1], l[2]) > (c[0], c[1], c[2])
+    return (available, current, latest)

devsper/utils/event_logger.py

@@ -0,0 +1,88 @@
+import asyncio
+import os
+from datetime import datetime, timezone
+
+from devsper.types.event import Event, events
+
+
+# Map Event types to bus topics (v1.9). Unmapped events use event.<type_value>.
+EVENT_TO_TOPIC = {
+    events.TASK_STARTED: "task.started",
+    events.TASK_COMPLETED: "task.completed",
+    events.TASK_FAILED: "task.failed",
+    events.TASK_CREATED: "task.ready",
+    events.AGENT_BROADCAST: "agent.broadcast",
+    events.SWARM_STARTED: "swarm.control",
+    events.SWARM_FINISHED: "swarm.control",
+    events.AGENT_STARTED: "agent.broadcast",
+    events.AGENT_FINISHED: "agent.broadcast",
+    events.EXECUTOR_STARTED: "swarm.control",
+    events.EXECUTOR_FINISHED: "swarm.control",
+}
+
+
+def _event_to_bus_topic(event_type: events) -> str:
+    return EVENT_TO_TOPIC.get(event_type, f"event.{event_type.value}")
+
+
+class EventLog:
+    def __init__(
+        self,
+        events_folder_path: str = ".devsper/events",
+        bus: object = None,
+        run_id: str | None = None,
+    ):
+        os.makedirs(events_folder_path, exist_ok=True)
+        self.log_path = os.path.join(
+            events_folder_path, f"events_{datetime.now(timezone.utc)}.jsonl"
+        )
+        self._bus = bus
+        self._run_id = run_id
+
+    @property
+    def run_id(self) -> str:
+        """Identifier for this run (basename of log file without extension)."""
+        if self._run_id is not None:
+            return self._run_id
+        return os.path.basename(self.log_path).replace(".jsonl", "")
+
+    def append_event(self, event: Event) -> None:
+        with open(self.log_path, "a") as f:
+            f.write(event.model_dump_json() + "\n")
+        if self._bus is not None:
+            self._publish_to_bus(event)
+
+    def _publish_to_bus(self, event: Event) -> None:
+        try:
+            from devsper.bus.message import create_bus_message
+            topic = _event_to_bus_topic(event.type)
+            payload = event.to_dict()
+            msg = create_bus_message(
+                topic=topic,
+                payload=payload,
+                run_id=getattr(self, "run_id", "") or "",
+            )
+            loop = None
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                pass
+            if loop is not None:
+                loop.create_task(self._bus.publish(msg))
+            else:
+                try:
+                    asyncio.run(self._bus.publish(msg))
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+    def read_events(self) -> list[Event]:
+        if not os.path.exists(self.log_path):
+            return []
+        with open(self.log_path, "r") as f:
+            return [Event.model_validate_json(line) for line in f if line.strip()]
+
+    def clear(self) -> None:
+        if os.path.exists(self.log_path):
+            os.remove(self.log_path)

devsper/utils/http.py

@@ -0,0 +1,43 @@
+"""HTTP client helpers. Respects DEVSPER_SSL_VERIFY for corp/uni networks with SSL inspection."""
+
+import os
+from typing import Any
+
+
+def format_retry_after(response: Any) -> str:
+    """
+    Read Retry-After from response headers and return a short message for the user.
+    response: object with .headers (e.g. httpx.Response). Headers may be case-insensitive.
+    Returns e.g. " Back off: retry after 60s" or " Back off: retry after <date>" or "".
+    """
+    if response is None:
+        return ""
+    headers = getattr(response, "headers", None)
+    if headers is None:
+        return ""
+    try:
+        raw = headers.get("retry-after")
+    except Exception:
+        raw = None
+    if raw is None:
+        return ""
+    raw = str(raw).strip()
+    if not raw:
+        return ""
+    # Integer seconds
+    try:
+        sec = int(raw)
+        return f" Back off: retry after {sec}s"
+    except ValueError:
+        pass
+    # HTTP-date or other
+    return f" Back off: Retry-After {raw}"
+
+
+def ssl_verify() -> bool:
+    """
+    Return False if DEVSPER_SSL_VERIFY is 'false' or '0' (e.g. university/corp WiFi with MITM).
+    Otherwise True. Use for httpx Client(verify=ssl_verify()).
+    """
+    v = os.environ.get("DEVSPER_SSL_VERIFY", "true").strip().lower()
+    return v not in ("false", "0", "no", "off")

devsper/utils/models.py

@@ -0,0 +1,54 @@
+"""
+Model invocation layer: generate(model_name, prompt) -> text.
+
+Uses v2 LLMRouter when available (from config), else legacy ProviderRouter.
+When model_name is "auto", use resolve_model(spec, task_type) first.
+"""
+
+import asyncio
+
+from devsper.providers.model_router import TaskType, select_model
+from devsper.providers.router import get_router
+
+
+def resolve_model(model_spec: str, task_type: TaskType) -> str:
+    """If model_spec is 'auto', return model_router.select_model(task_type); else return model_spec."""
+    if (model_spec or "").strip().lower() == "auto":
+        return select_model(task_type)
+    return model_spec or "mock"
+
+
+def _run_async(coro):
+    """Run coroutine from sync context (new loop or current)."""
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+    import concurrent.futures
+    with concurrent.futures.ThreadPoolExecutor(max_workers=1) as pool:
+        future = pool.submit(asyncio.run, coro)
+        return future.result()
+
+
+def generate(model_name: str, prompt: str, stream: bool = False):
+    """Call the model with the given prompt and return text output (or stream iterator if stream=True)."""
+    if not stream:
+        try:
+            from devsper.providers.router.factory import get_llm_router
+            from devsper.providers.router.base import LLMRequest
+            router = get_llm_router()
+            if router is not None:
+                req = LLMRequest(
+                    model=model_name,
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=4096,
+                    temperature=0.0,
+                    tools=None,
+                    stream=False,
+                )
+                resp = _run_async(router.route(req))
+                return resp.content
+        except Exception:
+            pass
+    provider = get_router().get_provider(model_name)
+    return provider.generate(model_name, prompt, stream=stream)

devsper/visualization/__init__.py

@@ -0,0 +1,5 @@
+"""DAG and run visualization."""
+
+from devsper.visualization.dag_export import export_mermaid, export_graphviz, load_dag
+
+__all__ = ["export_mermaid", "export_graphviz", "load_dag"]

devsper/visualization/dag_export.py

@@ -0,0 +1,67 @@
+"""
+Export task DAG to Mermaid or Graphviz format.
+
+DAG is loaded from a JSON file written by the swarm run (run_id_dag.json).
+"""
+
+import json
+from pathlib import Path
+
+
+def _safe_id(node_id: str) -> str:
+    """Mermaid/Graphviz safe node id (no spaces or special chars)."""
+    return node_id.replace(" ", "_").replace("-", "_").replace(".", "_")
+
+
+def load_dag(
+    events_dir: str | Path, run_id: str
+) -> tuple[list[dict], list[tuple[str, str]]]:
+    """
+    Load DAG from events_dir / {run_id}_dag.json.
+    Returns (nodes: [{"id", "description"}], edges: [(from_id, to_id)]).
+    """
+    path = Path(events_dir) / f"{run_id}_dag.json"
+    if not path.is_file():
+        return [], []
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    nodes = data.get("nodes", [])
+    edges = [tuple(e) for e in data.get("edges", [])]
+    return nodes, edges
+
+
+def export_mermaid(nodes: list[dict], edges: list[tuple[str, str]]) -> str:
+    """Produce a Mermaid diagram string (flowchart)."""
+    lines = ["flowchart LR"]
+    for n in nodes:
+        nid = _safe_id(n.get("id", ""))
+        desc = (n.get("description", "") or nid).replace('"', "'")[:40]
+        lines.append(f'  {nid}["{desc}"]')
+    for a, b in edges:
+        lines.append(f"  {_safe_id(a)} --> {_safe_id(b)}")
+    return "\n".join(lines)
+
+
+def export_graphviz(nodes: list[dict], edges: list[tuple[str, str]]) -> str:
+    """Produce a Graphviz DOT string."""
+    lines = ["digraph G {", "  rankdir=LR;"]
+    for n in nodes:
+        nid = _safe_id(n.get("id", ""))
+        desc = (n.get("description", "") or nid).replace('"', '\\"')[:40]
+        lines.append(f'  {nid} [label="{desc}"];')
+    for a, b in edges:
+        lines.append(f"  {_safe_id(a)} -> {_safe_id(b)};")
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def list_run_ids(events_dir: str | Path) -> list[str]:
+    """List available run ids (from _dag.json files)."""
+    path = Path(events_dir)
+    if not path.is_dir():
+        return []
+    run_ids = []
+    for f in path.glob("*_dag.json"):
+        run_id = f.stem.replace("_dag", "")
+        run_ids.append(run_id)
+    return sorted(run_ids, reverse=True)

devsper/workflow/__init__.py

@@ -0,0 +1,18 @@
+"""Workflow definitions: load from workflow.devsper.toml and run by name (v1.4 pipeline engine)."""
+
+from devsper.workflow.loader import load_workflow, list_workflows
+from devsper.workflow.runner import WorkflowRunner, run_workflow, WorkflowStepError
+from devsper.workflow.schema import WorkflowDefinition, WorkflowStep
+from devsper.workflow.validator import ValidationReport, validate_workflow
+
+__all__ = [
+    "load_workflow",
+    "list_workflows",
+    "run_workflow",
+    "WorkflowRunner",
+    "WorkflowDefinition",
+    "WorkflowStep",
+    "WorkflowStepError",
+    "ValidationReport",
+    "validate_workflow",
+]