devsper 2.1.6__py3-none-any.whl

devsper/intelligence/adaptation.py

@@ -0,0 +1,88 @@
+"""
+Self-optimizing swarm: adapt execution strategy in real time.
+
+Detects slow tasks, failed tasks, and spawns alternative subtasks.
+The adaptive planner can inject new tasks into the scheduler DAG.
+"""
+
+from datetime import datetime, timezone
+from devsper.types.task import Task, TaskStatus
+from devsper.swarm.scheduler import Scheduler
+
+
+def detect_slow_tasks(
+    scheduler: Scheduler,
+    task_start_times: dict[str, datetime],
+    threshold_seconds: float = 60.0,
+    *,
+    now: datetime | None = None,
+) -> list[str]:
+    """
+    Return task ids that are still RUNNING and have been running longer than threshold_seconds.
+    task_start_times maps task_id -> start time (e.g. when task was set to RUNNING).
+    """
+    now = now or datetime.now(timezone.utc)
+    slow: list[str] = []
+    for task_id, task in scheduler._tasks.items():
+        if task.status != TaskStatus.RUNNING:
+            continue
+        start = task_start_times.get(task_id)
+        if start is None:
+            continue
+        elapsed = (now - start).total_seconds()
+        if elapsed >= threshold_seconds:
+            slow.append(task_id)
+    return slow
+
+
+def detect_failed_tasks(scheduler: Scheduler) -> list[str]:
+    """Return task ids that have status FAILED."""
+    return [
+        task_id
+        for task_id, task in scheduler._tasks.items()
+        if task.status == TaskStatus.FAILED
+    ]
+
+
+def suggest_alternative_tasks(
+    task: Task,
+    planner: object,
+    context: list[Task] | None = None,
+) -> list[Task]:
+    """
+    Ask the planner to suggest alternative follow-up tasks (e.g. after failure or timeout).
+    Returns new tasks that depend on the same dependencies as the given task, so they
+    can be injected as alternatives. The planner's expand_tasks is used with a synthetic
+    "failed" result to get alternatives.
+    """
+    if not hasattr(planner, "expand_tasks"):
+        return []
+    # Create a minimal completed task with a note that original failed/timed out
+    synthetic = Task(
+        id=task.id + "_alt",
+        description=f"(Alternative to failed/slow task) {task.description}",
+        dependencies=task.dependencies.copy(),
+        status=TaskStatus.COMPLETED,
+        result="[Previous attempt failed or timed out. Suggest alternative approach.]",
+    )
+    return planner.expand_tasks(synthetic, context=context)
+
+
+def create_alternative_subtasks_for_failed(
+    failed_task: Task,
+    planner: object,
+    scheduler: Scheduler,
+) -> list[Task]:
+    """
+    Generate alternative tasks for a failed task and return them (caller should
+    add to scheduler via scheduler.add_tasks). New tasks depend on the same
+    dependencies as the failed task so they can run in place of it.
+    """
+    new_tasks = suggest_alternative_tasks(failed_task, planner)
+    if not new_tasks:
+        return []
+    # Ensure new tasks depend on same deps so they are runnable when failed_task's deps are done
+    for t in new_tasks:
+        if t.dependencies != failed_task.dependencies:
+            t.dependencies = failed_task.dependencies.copy()
+    return new_tasks

devsper/intelligence/analysis/__init__.py

@@ -0,0 +1,19 @@
+"""
+Run analysis: build RunReport from events, cost estimation, LLM analysis, Rich formatting.
+"""
+
+from devsper.intelligence.analysis.run_report import (
+    RunReport,
+    TaskSummary,
+    build_report_from_events,
+)
+from devsper.intelligence.analysis.analyzer import analyze
+from devsper.intelligence.analysis.formatter import print_run_report
+
+__all__ = [
+    "RunReport",
+    "TaskSummary",
+    "build_report_from_events",
+    "analyze",
+    "print_run_report",
+]

devsper/intelligence/analysis/analyzer.py

@@ -0,0 +1,71 @@
+"""
+LLM-powered plain-English analysis of a RunReport.
+"""
+
+from typing import Callable
+
+from devsper.types.task import TaskStatus
+from devsper.intelligence.analysis.run_report import RunReport
+
+
+def analyze(
+    report: RunReport,
+    worker_model: str,
+    stream_callback: Callable[[str], None] | None = None,
+) -> str:
+    """
+    Call the LLM with a structured prompt; stream the response for progressive CLI display
+    when stream_callback is provided. On error return "Analysis unavailable."
+    """
+    try:
+        from devsper.utils.models import generate
+    except ImportError:
+        return "Analysis unavailable."
+
+    bottleneck_desc = ""
+    if report.bottleneck_task_id:
+        for t in report.tasks:
+            if t.task_id == report.bottleneck_task_id:
+                bottleneck_desc = f"{t.description[:80]} ({t.duration_seconds:.1f}s)"
+                break
+        if not bottleneck_desc:
+            bottleneck_desc = report.bottleneck_task_id
+
+    failed_block = []
+    for t in report.tasks:
+        if t.status == TaskStatus.FAILED:
+            failed_block.append(
+                f"- {t.description[:100]}: error={t.error or 'unknown'}; tools_that_failed={t.tool_failures or 'none'}"
+            )
+    failed_text = "\n".join(failed_block) if failed_block else "(none)"
+
+    user_content = f"""Run ID: {report.run_id}
+Root task: {report.root_task[:200]}
+Duration: {report.total_duration_seconds:.1f}s
+Tasks: {report.completed_tasks}/{report.total_tasks} completed, {report.failed_tasks} failed
+Bottleneck: {bottleneck_desc}
+Failed tasks:
+{failed_text}
+Tool success rate: {report.tool_success_rate:.1f}%
+Peak parallelism: {report.peak_parallelism}"""
+
+    system_content = """You are analyzing a devsper swarm run. Be concise, specific, and actionable.
+Focus on: what failed and why, what was slow, what could be improved.
+Do not summarize what succeeded unless it's relevant to failures.
+Max 200 words."""
+
+    prompt = f"{system_content}\n\n---\n\n{user_content}"
+
+    try:
+        out = generate(worker_model, prompt, stream=bool(stream_callback))
+        if isinstance(out, str):
+            return out.strip() or "Analysis unavailable."
+        chunks = []
+        for chunk in out:
+            if chunk:
+                chunks.append(chunk)
+                if stream_callback:
+                    stream_callback(chunk)
+        return "".join(chunks).strip() or "Analysis unavailable."
+    except Exception:
+        return "Analysis unavailable."

devsper/intelligence/analysis/cost_estimator.py

@@ -0,0 +1,66 @@
+"""
+Cost estimation from token counts and model pricing.
+"""
+
+from devsper.intelligence.analysis.run_report import TaskSummary
+
+
+MODEL_PRICING = {
+    # (input_per_1k_tokens, output_per_1k_tokens) in USD
+    "gpt-4o": (0.0025, 0.010),
+    "gpt-4o-mini": (0.000150, 0.000600),
+    "claude-opus-4": (0.015, 0.075),
+    "claude-sonnet-4": (0.003, 0.015),
+    "claude-haiku-4": (0.00025, 0.00125),
+    "gemini-1.5-pro": (0.00125, 0.005),
+    "gemini-1.5-flash": (0.000075, 0.000300),
+}
+
+
+class CostEstimator:
+    """Estimate run cost from task token usage and model pricing."""
+
+    @staticmethod
+    def estimate(
+        tasks: list[TaskSummary],
+        models_used: list[str],
+    ) -> float | None:
+        """
+        Compute total USD cost from token counts and model pricing.
+        Returns None if token counts are not available (don't guess).
+        """
+        if not tasks and not models_used:
+            return None
+        total = 0.0
+        any_tokens = False
+        for t in tasks:
+            if t.tokens_used is None:
+                continue
+            any_tokens = True
+            model = models_used[0] if models_used else None
+            if not model:
+                return None
+            pricing = MODEL_PRICING.get(model)
+            if not pricing:
+                # Try prefix match for model variants
+                for key in MODEL_PRICING:
+                    if model.startswith(key) or key in model:
+                        pricing = MODEL_PRICING[key]
+                        break
+                if not pricing:
+                    return None
+            input_per_1k, output_per_1k = pricing
+            # Assume 50/50 split if we only have total; task summary has tokens_used as single int
+            inp = t.tokens_used // 2
+            out = t.tokens_used - inp
+            total += (inp / 1000.0) * input_per_1k + (out / 1000.0) * output_per_1k
+        if not any_tokens:
+            return None
+        return round(total, 4)
+
+    @staticmethod
+    def format_cost(usd: float | None) -> str:
+        """Return '$0.0023' or 'unknown'."""
+        if usd is None:
+            return "unknown"
+        return f"${usd:.4f}"

devsper/intelligence/analysis/formatter.py

@@ -0,0 +1,103 @@
+"""
+Rich CLI output for RunReport.
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from devsper.types.task import TaskStatus
+from devsper.intelligence.analysis.run_report import RunReport
+from devsper.intelligence.analysis.cost_estimator import CostEstimator
+
+
+def print_run_report(report: RunReport, console: Console) -> None:
+    """Print report sections: header, overview, timeline table, critical path, tool usage, analysis panel, footer."""
+    # 1. Header
+    console.print()
+    console.print(f"[bold cyan]Run[/] [bold]{report.run_id}[/]")
+    console.print(f"  Root task: [dim]{report.root_task[:120]}{'…' if len(report.root_task) > 120 else ''}[/]")
+    console.print(f"  Strategy: [dim]{report.strategy}[/]  Started: [dim]{report.started_at}[/]  Finished: [dim]{report.finished_at}[/]")
+    console.print()
+
+    # 2. Overview panel
+    cost_str = CostEstimator.format_cost(report.estimated_cost_usd)
+    overview = (
+        f"Duration: [bold]{report.total_duration_seconds:.1f}s[/]  "
+        f"Tasks: [green]{report.completed_tasks}[/]/[bold]{report.total_tasks}[/] completed, "
+        f"[red]{report.failed_tasks}[/] failed  "
+        f"Cost: [dim]{cost_str}[/]  "
+        f"Models: [dim]{', '.join(report.models_used) or '—'}[/]"
+    )
+    console.print(Panel(overview, title="Overview", border_style="dim"))
+    console.print()
+
+    # 3. Timeline table
+    table = Table(title="Timeline")
+    table.add_column("Task", style="dim", max_width=50, overflow="fold")
+    table.add_column("Role", style="dim", width=10)
+    table.add_column("Status", width=12)
+    table.add_column("Duration", justify="right", width=10)
+    table.add_column("Tools", style="dim", max_width=30, overflow="fold")
+    bottleneck_id = report.bottleneck_task_id
+    for t in report.tasks:
+        desc = (t.description or t.task_id)[:48]
+        role = (t.role or "—")
+        if t.status == TaskStatus.COMPLETED:
+            status = "[green]completed[/]"
+        elif t.status == TaskStatus.FAILED:
+            status = "[red]failed[/]"
+        elif t.status == TaskStatus.PENDING:
+            status = "[dim]skipped[/]"
+        else:
+            status = "[yellow]running[/]"
+        dur = f"{t.duration_seconds:.1f}s"
+        tools = ", ".join(t.tools_used[:5]) if t.tools_used else "—"
+        if len(t.tools_used) > 5:
+            tools += "…"
+        row_style = ""
+        if t.task_id == bottleneck_id:
+            row_style = "bold"
+            status = "[bold]⚡ bottleneck[/]"
+        elif t.status == TaskStatus.FAILED:
+            row_style = "red"
+        elif t.status == TaskStatus.PENDING:
+            row_style = "dim"
+        table.add_row(desc, role, status, dur, tools, style=row_style)
+    console.print(table)
+    console.print()
+
+    # 4. Critical path
+    if report.critical_path:
+        path_parts = [
+            tid + (" [bold](bottleneck)[/]" if tid == report.bottleneck_task_id else "")
+            for tid in report.critical_path
+        ]
+        path_str = " → ".join(path_parts)
+    else:
+        path_str = "(none)"
+    console.print("[bold]Critical path:[/] [dim]" + path_str)
+    console.print()
+
+    # 5. Tool usage (aggregate)
+    tool_table = Table(title="Tool usage")
+    tool_table.add_column("Metric", style="dim")
+    tool_table.add_column("Value", justify="right")
+    tool_table.add_row("Tools called", str(report.tools_called))
+    tool_table.add_row("Success rate", f"{report.tool_success_rate:.1f}%")
+    console.print(tool_table)
+    console.print()
+
+    # 6. Plain-English Analysis (only if already set; CLI streams and prints after)
+    if report.plain_english_analysis:
+        console.print(
+            Panel(
+                report.plain_english_analysis,
+                title="Plain-English Analysis",
+                border_style="dim",
+            )
+        )
+        console.print()
+
+    # 7. Footer (caller may print again after streaming analysis)
+    console.print(f"[dim]Cost estimate: {CostEstimator.format_cost(report.estimated_cost_usd)}[/]")