devsper 2.7.2__tar.gz → 3.0.0__tar.gz

{devsper-2.7.2 → devsper-3.0.0}/.gitignore

@@ -43,6 +43,8 @@ Thumbs.db
 *.swp
 *.swo
 .cursor/
+.claude/
+.worktrees/
 
 tmp
 **/build-errors.log
@@ -51,4 +53,7 @@ node_modules
 
 # Rust (workspace and worker crate)
 target/
-worker/target/
+worker/target/.worktrees/
+
+# Local-only testing notes
+TESTING.md

devsper-3.0.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: devsper
+Version: 3.0.0
+Summary: Devsper runtime CLI — self-evolving AI workflow engine
+License: Apache-2.0
+Keywords: AI,agents,runtime,swarm,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: keyring>=24
+Requires-Dist: rich>=13
+Provides-Extra: eval
+Requires-Dist: openai>=1.0; extra == 'eval'
+Requires-Dist: openevals>=0.1; extra == 'eval'
+Requires-Dist: trulens>=1.0; extra == 'eval'
+Provides-Extra: tui
+Requires-Dist: textual>=0.80; extra == 'tui'

devsper-3.0.0/devsper/__init__.py

@@ -0,0 +1,2 @@
+"""Devsper runtime — Python CLI/TUI wrapper."""
+__version__ = "2.9.0"

devsper-3.0.0/devsper/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m devsper` invocation."""
+from devsper.cli import main
+
+if __name__ == "__main__":
+    main()

devsper-3.0.0/devsper/auth/github.py

@@ -0,0 +1,100 @@
+"""GitHub device flow authentication."""
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+CLIENT_ID_ENV = "DEVSPER_GITHUB_CLIENT_ID"
+DEVICE_CODE_URL = "https://github.com/login/device/code"
+TOKEN_URL = "https://github.com/login/oauth/access_token"
+SCOPE = "read:user"
+TIMEOUT_SECONDS = 900  # 15 minutes
+
+console = Console()
+
+
+def _post_json(url: str, data: dict) -> dict:
+    """POST URL-encoded data, return JSON response."""
+    encoded = urllib.parse.urlencode(data).encode()
+    req = urllib.request.Request(
+        url,
+        data=encoded,
+        headers={"Accept": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read().decode())
+
+
+def login() -> str:
+    """Run GitHub device flow, return access token.
+
+    Raises:
+        click.ClickException: if CLIENT_ID_ENV is not set or flow fails.
+    """
+    client_id = os.environ.get(CLIENT_ID_ENV)
+    if not client_id:
+        raise click.ClickException(
+            f"{CLIENT_ID_ENV} not set.\n"
+            "Register a GitHub OAuth App at https://github.com/settings/developers\n"
+            f"then set: export {CLIENT_ID_ENV}=<your-client-id>"
+        )
+
+    # Request device + user codes
+    device_data = _post_json(DEVICE_CODE_URL, {"client_id": client_id, "scope": SCOPE})
+
+    user_code: str = device_data["user_code"]
+    verification_uri: str = device_data["verification_uri"]
+    device_code: str = device_data["device_code"]
+    interval: int = int(device_data.get("interval", 5))
+    expires_in: int = int(device_data.get("expires_in", TIMEOUT_SECONDS))
+
+    console.print(
+        Panel(
+            f"[bold]Open this URL in your browser:[/bold]\n\n"
+            f"  [cyan]{verification_uri}[/cyan]\n\n"
+            f"[bold]Enter this code:[/bold]\n\n"
+            f"  [bold yellow]{user_code}[/bold yellow]",
+            title="GitHub Login",
+            expand=False,
+        )
+    )
+
+    deadline = time.monotonic() + expires_in
+    with console.status("[dim]Waiting for GitHub authorization...[/dim]"):
+        while time.monotonic() < deadline:
+            time.sleep(interval)
+            token_data = _post_json(
+                TOKEN_URL,
+                {
+                    "client_id": client_id,
+                    "device_code": device_code,
+                    "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+                },
+            )
+
+            error = token_data.get("error")
+            if error == "authorization_pending":
+                continue
+            elif error == "slow_down":
+                interval += 5
+                continue
+            elif error == "expired_token":
+                raise click.ClickException("Device code expired. Run the command again.")
+            elif error == "access_denied":
+                raise click.ClickException("Authorization was denied.")
+            elif error:
+                raise click.ClickException(f"GitHub authorization error: {error}")
+
+            access_token = token_data.get("access_token")
+            if access_token:
+                return access_token
+
+    raise click.ClickException("Timed out waiting for GitHub authorization. Run the command again.")

devsper-3.0.0/devsper/cli.py

@@ -0,0 +1,362 @@
+"""Thin CLI wrapper — finds and execs the Rust devsper binary."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import shutil
+import pathlib
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from devsper.credentials.inject import inject_credentials
+from devsper.credentials import providers as cred_providers
+from devsper.credentials import store as cred_store
+from devsper.auth import github as github_auth
+
+console = Console()
+
+
+def find_binary() -> str:
+    """Find the devsper Rust binary.
+
+    Search order:
+    1. devsper-runtime on PATH (installed wheel)
+    2. devsper on PATH
+    3. Alongside this package (bundled wheel)
+    4. Cargo build output (dev mode)
+    """
+    for name in ("devsper-runtime", "devsper"):
+        binary = shutil.which(name)
+        if binary and _is_rust_binary(binary):
+            return binary
+
+    pkg_dir = pathlib.Path(__file__).parent
+    repo_root = pkg_dir.parent.parent
+
+    candidates = [
+        pkg_dir / "bin" / "devsper",
+        pkg_dir / "bin" / "devsper.exe",
+        repo_root / "target" / "release" / "devsper",
+        repo_root / "target" / "debug" / "devsper",
+    ]
+    for c in candidates:
+        if c.exists() and os.access(c, os.X_OK):
+            return str(c)
+
+    click.echo(
+        "Error: devsper Rust binary not found.\n"
+        "\n"
+        "Build with:   cargo build --release -p devsper-bin\n"
+        "Or install:   pip install devsper[runtime]\n",
+        err=True,
+    )
+    sys.exit(1)
+
+
+def _is_rust_binary(path: str) -> bool:
+    """Heuristic: not this Python script."""
+    return not path.endswith(".py")
+
+
+@click.group(invoke_without_command=True, context_settings={"ignore_unknown_options": True})
+@click.pass_context
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+def main(ctx: click.Context, args: tuple) -> None:
+    """Devsper — self-evolving AI workflow engine.
+
+    \b
+    Commands are passed directly to the Rust runtime:
+      devsper run workflow.devsper
+      devsper compile workflow.devsper
+      devsper peer --listen 0.0.0.0:7000
+      devsper inspect <run-id>
+
+    \b
+    Interactive UI:
+      devsper tui
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if args and args[0] == "tui":
+        _launch_tui(list(args[1:]))
+        return
+
+    # Pass-through to Rust binary
+    binary = find_binary()
+    inject_credentials()
+    os.execv(binary, [binary] + list(args))
+
+
+@main.command(name="tui")
+@click.argument("run_id", required=False, default=None)
+def tui_command(run_id: str | None) -> None:
+    """Launch the interactive TUI (requires 'devsper[tui]' extras)."""
+    extra_args = ["--run-id", run_id] if run_id else []
+    _launch_tui(extra_args)
+
+
+def _launch_tui(args: list[str]) -> None:
+    """Start the Textual TUI application."""
+    try:
+        from devsper.tui.app import DevSperApp  # noqa: PLC0415
+    except ImportError:
+        click.echo(
+            "TUI requires optional dependencies:\n"
+            "  pip install 'devsper[tui]'\n",
+            err=True,
+        )
+        sys.exit(1)
+
+    app = DevSperApp(extra_args=args)
+    app.run()
+
+
+# ---------------------------------------------------------------------------
+# credentials group
+# ---------------------------------------------------------------------------
+
+
+@main.group()
+def credentials() -> None:
+    """Manage provider credentials stored in system keyring."""
+
+
+@credentials.command("set")
+@click.argument("provider", type=click.Choice(list(cred_providers.PROVIDERS.keys())))
+def credentials_set(provider: str) -> None:
+    """Store credentials for a provider in the system keyring."""
+    p = cred_providers.PROVIDERS[provider]
+    console.print(f"\n[bold]Configure {p.display_name}[/bold]\n")
+
+    for f in p.fields:
+        label = f.display_name
+        if f.optional:
+            default_hint = f.default or ""
+            label = f"{label} (optional, default: {default_hint})" if default_hint else f"{label} (optional)"
+
+        if f.secret:
+            value = click.prompt(label, hide_input=True, default="", show_default=False).strip()
+        else:
+            value = click.prompt(label, default=f.default or "", show_default=bool(f.default)).strip()
+
+        if value:
+            cred_store.set(provider, f.name, value)
+        elif f.optional and f.default:
+            # Don't store the default — inject.py handles defaults at runtime
+            pass
+
+    console.print(f"\n[green]Credentials for [bold]{p.display_name}[/bold] saved.[/green]\n")
+
+
+@credentials.command("list")
+def credentials_list() -> None:
+    """Show configured providers."""
+    table = Table(title="Configured Providers", show_lines=True)
+    table.add_column("Provider", style="bold")
+    table.add_column("Status")
+    table.add_column("Fields configured")
+
+    for provider_name, provider in cred_providers.PROVIDERS.items():
+        field_statuses: list[str] = []
+        any_configured = False
+
+        for f in provider.fields:
+            env_val = os.environ.get(f.env_var) if f.env_var else None
+            keyring_val = cred_store.get(provider_name, f.name)
+
+            if env_val:
+                display = "[green]set[/green] (env)"
+                any_configured = True
+            elif keyring_val:
+                display = "[green]set[/green] (keyring)"
+                any_configured = True
+            elif f.default:
+                display = f"[dim]default ({f.default})[/dim]"
+            else:
+                display = "[dim]not set[/dim]"
+
+            field_statuses.append(f"{f.display_name}: {display}")
+
+        status = "[green]configured[/green]" if any_configured else "[dim]not configured[/dim]"
+        table.add_row(provider.display_name, status, "\n".join(field_statuses))
+
+    console.print(table)
+
+
+@credentials.command("remove")
+@click.argument("provider", type=click.Choice(list(cred_providers.PROVIDERS.keys())))
+def credentials_remove(provider: str) -> None:
+    """Remove stored credentials for a provider."""
+    p = cred_providers.PROVIDERS[provider]
+    if not click.confirm(f"Remove all stored credentials for {p.display_name}?"):
+        console.print("[dim]Aborted.[/dim]")
+        return
+
+    for f in p.fields:
+        cred_store.delete(provider, f.name)
+
+    console.print(f"[green]Credentials for [bold]{p.display_name}[/bold] removed.[/green]")
+
+
+# ---------------------------------------------------------------------------
+# auth group
+# ---------------------------------------------------------------------------
+
+
+@main.group()
+def auth() -> None:
+    """Authentication commands."""
+
+
+@auth.command("github")
+def auth_github() -> None:
+    """Login to GitHub via device flow to use GitHub Models."""
+    token = github_auth.login()
+    cred_store.set("github", "token", token)
+    console.print("\n[green]GitHub authentication successful. Token stored in keyring.[/green]\n")
+
+
+@auth.command("status")
+def auth_status() -> None:
+    """Show authentication status for all providers."""
+    table = Table(title="Authentication Status", show_lines=True)
+    table.add_column("Provider", style="bold")
+    table.add_column("Authenticated")
+    table.add_column("Source")
+
+    for provider_name, provider in cred_providers.PROVIDERS.items():
+        authenticated = False
+        source = ""
+
+        for f in provider.fields:
+            if f.env_var and os.environ.get(f.env_var):
+                authenticated = True
+                source = "env"
+                break
+            if cred_store.get(provider_name, f.name):
+                authenticated = True
+                source = "keyring"
+                break
+
+        auth_cell = "[green]yes[/green]" if authenticated else "[dim]no[/dim]"
+        source_cell = source if authenticated else ""
+        table.add_row(provider.display_name, auth_cell, source_cell)
+
+    console.print(table)
+
+
+# ---------------------------------------------------------------------------
+# eval group
+# ---------------------------------------------------------------------------
+
+
+@main.group()
+def eval() -> None:
+    """Evaluate workflows against datasets."""
+
+
+@eval.command("run")
+@click.argument("workflow", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--dataset", "-d",
+    required=True,
+    type=click.Path(exists=True, path_type=Path),
+    help="JSONL dataset file",
+)
+@click.option(
+    "--metrics", "-m",
+    default="",
+    help="Comma-separated metrics: relevance,correctness,groundedness",
+)
+@click.option(
+    "--output", "-o",
+    default="eval_results.jsonl",
+    type=click.Path(),
+    help="Output JSONL path",
+)
+@click.option(
+    "--score/--no-score",
+    default=True,
+    help="Run LLM-as-judge scoring (requires devsper[eval])",
+)
+def eval_run(workflow: Path, dataset: Path, metrics: str, output: str, score: bool) -> None:
+    """Run a workflow against a dataset and score outputs."""
+    from devsper.eval.runner import load_dataset, run_case, save_results  # noqa: PLC0415
+
+    binary = find_binary()
+    inject_credentials()
+    cases = load_dataset(dataset)
+
+    console.print(f"\n[bold]Running {len(cases)} eval cases...[/bold]\n")
+
+    results: list[dict] = []
+    with console.status("Running cases...") as status:
+        for i, case in enumerate(cases, 1):
+            status.update(f"Case {i}/{len(cases)}")
+            inputs = case.get("inputs", {"query": case.get("input", "")})
+            r = run_case(binary, workflow, inputs)
+            if "expected" in case:
+                r["expected"] = case["expected"]
+            results.append(r)
+            icon = "[green]✓[/green]" if r["success"] else "[red]✗[/red]"
+            console.print(f"  {icon} Case {i}: {r['latency_ms']}ms")
+
+    if score and metrics:
+        metric_list = [m.strip() for m in metrics.split(",") if m.strip()]
+        console.print(f"\n[bold]Scoring with: {', '.join(metric_list)}[/bold]")
+        try:
+            from devsper.eval.scoring import score_results  # noqa: PLC0415
+            results = score_results(results, metric_list)
+        except ImportError as e:
+            console.print(f"[yellow]Scoring skipped: {e}[/yellow]")
+
+    save_results(results, Path(output))
+
+    passed = sum(1 for r in results if r["success"])
+    console.print(f"\n[bold]Results:[/bold] {passed}/{len(results)} passed → {output}\n")
+
+
+@eval.command("report")
+@click.option(
+    "--input", "-i",
+    "input_file",
+    default="eval_results.jsonl",
+    type=click.Path(exists=True),
+)
+@click.option("--last", default=0, help="Show last N results only")
+def eval_report(input_file: str, last: int) -> None:
+    """Show eval results as a table."""
+    results: list[dict] = []
+    with open(input_file) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                results.append(json.loads(line))
+
+    if last:
+        results = results[-last:]
+
+    table = Table(title=f"Eval Results: {input_file}", show_lines=True)
+    table.add_column("#", style="dim")
+    table.add_column("Status")
+    table.add_column("Input")
+    table.add_column("Latency")
+    table.add_column("Scores")
+
+    for i, r in enumerate(results, 1):
+        status = "[green]pass[/green]" if r.get("success") else "[red]fail[/red]"
+        inputs = r.get("inputs", {})
+        input_str = list(inputs.values())[0][:60] if inputs else ""
+        latency = f"{r.get('latency_ms', 0)}ms"
+        scores = r.get("scores", {})
+        score_str = (
+            ", ".join(f"{k}: {v:.2f}" for k, v in scores.items()) if scores else "-"
+        )
+        table.add_row(str(i), status, input_str, latency, score_str)
+
+    console.print(table)

devsper-3.0.0/devsper/credentials/inject.py

@@ -0,0 +1,19 @@
+"""Inject stored credentials as environment variables before Rust exec."""
+from __future__ import annotations
+
+import os
+
+from devsper.credentials.providers import PROVIDERS
+from devsper.credentials import store
+
+
+def inject_credentials() -> None:
+    """Read credentials from keyring, set missing env vars. Env vars take priority."""
+    for provider in PROVIDERS.values():
+        for field in provider.fields:
+            if field.env_var and field.env_var not in os.environ:
+                value = store.get(provider.name, field.name)
+                if value is None and field.default is not None:
+                    value = field.default
+                if value:
+                    os.environ[field.env_var] = value

devsper-3.0.0/devsper/credentials/providers.py

@@ -0,0 +1,107 @@
+"""Provider definitions for credential management."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Field:
+    """A single credential field for a provider."""
+
+    name: str
+    display_name: str
+    env_var: str
+    secret: bool = True
+    optional: bool = False
+    default: str | None = None
+
+
+@dataclass
+class Provider:
+    """A credential provider definition."""
+
+    name: str
+    display_name: str
+    fields: list[Field] = field(default_factory=list)
+
+
+PROVIDERS: dict[str, Provider] = {
+    "anthropic": Provider(
+        name="anthropic",
+        display_name="Anthropic",
+        fields=[Field("api_key", "API Key", env_var="ANTHROPIC_API_KEY", secret=True)],
+    ),
+    "openai": Provider(
+        name="openai",
+        display_name="OpenAI",
+        fields=[Field("api_key", "API Key", env_var="OPENAI_API_KEY", secret=True)],
+    ),
+    "github": Provider(
+        name="github",
+        display_name="GitHub Models",
+        fields=[Field("token", "Token", env_var="GITHUB_TOKEN", secret=True)],
+    ),
+    "zai": Provider(
+        name="zai",
+        display_name="ZAI (z.ai)",
+        fields=[
+            Field("api_key", "API Key", env_var="ZAI_API_KEY", secret=True),
+            Field(
+                "base_url",
+                "Base URL",
+                env_var="ZAI_BASE_URL",
+                secret=False,
+                optional=True,
+                default="https://api.z.ai/v1",
+            ),
+        ],
+    ),
+    "azure-openai": Provider(
+        name="azure-openai",
+        display_name="Azure OpenAI",
+        fields=[
+            Field("api_key", "API Key", env_var="AZURE_OPENAI_API_KEY", secret=True),
+            Field("endpoint", "Endpoint", env_var="AZURE_OPENAI_ENDPOINT", secret=False),
+            Field("deployment", "Deployment Name", env_var="AZURE_OPENAI_DEPLOYMENT", secret=False),
+            Field(
+                "api_version",
+                "API Version",
+                env_var="AZURE_OPENAI_API_VERSION",
+                secret=False,
+                optional=True,
+                default="2024-02-01",
+            ),
+        ],
+    ),
+    "azure-foundry": Provider(
+        name="azure-foundry",
+        display_name="Azure AI Foundry (Anthropic)",
+        fields=[
+            Field("api_key", "API Key", env_var="AZURE_FOUNDRY_API_KEY", secret=True),
+            Field("endpoint", "Endpoint", env_var="AZURE_FOUNDRY_ENDPOINT", secret=False),
+            Field("deployment", "Deployment Name", env_var="AZURE_FOUNDRY_DEPLOYMENT", secret=False),
+        ],
+    ),
+    "litellm": Provider(
+        name="litellm",
+        display_name="LiteLLM Proxy",
+        fields=[
+            Field("base_url", "Base URL", env_var="LITELLM_BASE_URL", secret=False),
+            Field("api_key", "API Key", env_var="LITELLM_API_KEY", secret=True, optional=True),
+        ],
+    ),
+    "ollama": Provider(
+        name="ollama",
+        display_name="Ollama",
+        fields=[
+            Field(
+                "base_url",
+                "Base URL",
+                env_var="OLLAMA_HOST",
+                secret=False,
+                optional=True,
+                default="http://localhost:11434",
+            ),
+        ],
+    ),
+}

devsper-3.0.0/devsper/credentials/store.py

@@ -0,0 +1,41 @@
+"""Keyring-backed credential store for Devsper providers."""
+from __future__ import annotations
+
+import keyring
+
+from devsper.credentials.providers import PROVIDERS
+
+_SERVICE = "devsper"
+
+
+def _key(provider: str, field: str) -> str:
+    return f"{provider}:{field}"
+
+
+def set(provider: str, field: str, value: str) -> None:
+    """Store a credential value in the system keyring."""
+    keyring.set_password(_SERVICE, _key(provider, field), value)
+
+
+def get(provider: str, field: str) -> str | None:
+    """Retrieve a credential value from the system keyring. Returns None if not found."""
+    return keyring.get_password(_SERVICE, _key(provider, field))
+
+
+def delete(provider: str, field: str) -> None:
+    """Remove a credential value from the system keyring."""
+    try:
+        keyring.delete_password(_SERVICE, _key(provider, field))
+    except keyring.errors.PasswordDeleteError:
+        pass
+
+
+def list_configured() -> list[str]:
+    """Return provider names that have at least one field stored in the keyring."""
+    configured = []
+    for provider_name, provider in PROVIDERS.items():
+        for f in provider.fields:
+            if keyring.get_password(_SERVICE, _key(provider_name, f.name)) is not None:
+                configured.append(provider_name)
+                break
+    return configured