devsper 2.1.6__py3-none-any.whl

devsper/credentials/cli.py

@@ -0,0 +1,197 @@
+"""CLI for credential management: set, list, delete, migrate, export."""
+
+import getpass
+import sys
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from devsper.credentials import (
+    delete_credential,
+    get_credential,
+    list_credentials,
+    set_credential,
+)
+from devsper.credentials.migration import migrate_from_config
+
+KNOWN_CREDENTIALS = {
+    "openai": ["api_key"],
+    "anthropic": ["api_key"],
+    "github": ["token"],
+    "gemini": ["api_key"],
+    "azure": ["endpoint", "api_key", "deployment", "api_version"],
+    "azure_anthropic": ["endpoint", "api_key", "deployment"],
+}
+
+# Keys that must never be shown in list (only "(stored)"); all others can show value
+SENSITIVE_KEYS = {"api_key", "token"}
+
+# (provider, key) -> env var name for export
+PROVIDER_KEY_TO_ENV: dict[tuple[str, str], str] = {
+    ("openai", "api_key"): "OPENAI_API_KEY",
+    ("anthropic", "api_key"): "ANTHROPIC_API_KEY",
+    ("github", "token"): "GITHUB_TOKEN",
+    ("gemini", "api_key"): "GEMINI_API_KEY",
+    ("azure", "endpoint"): "AZURE_OPENAI_ENDPOINT",
+    ("azure", "api_key"): "AZURE_OPENAI_API_KEY",
+    ("azure", "deployment"): "AZURE_OPENAI_DEPLOYMENT_NAME",
+    ("azure", "api_version"): "AZURE_OPENAI_API_VERSION",
+    ("azure_anthropic", "endpoint"): "AZURE_ANTHROPIC_ENDPOINT",
+    ("azure_anthropic", "api_key"): "AZURE_ANTHROPIC_API_KEY",
+    ("azure_anthropic", "deployment"): "AZURE_ANTHROPIC_DEPLOYMENT_NAME",
+}
+
+
+def _env_escape(value: str) -> str:
+    """Escape value for .env / export format: double-quote and escape internal quotes."""
+    return '"' + value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n") + '"'
+
+
+def _run_credentials_export(provider: str) -> int:
+    """Print provider's credentials in env format (KEY=value, one per line)."""
+    if provider not in KNOWN_CREDENTIALS:
+        print(f"Unknown provider: {provider}", file=sys.stderr)
+        return 1
+    lines: list[str] = []
+    for key in KNOWN_CREDENTIALS[provider]:
+        env_var = PROVIDER_KEY_TO_ENV.get((provider, key))
+        if not env_var:
+            continue
+        val = get_credential(provider, key)
+        if val is not None:
+            lines.append(f"{env_var}={_env_escape(val)}")
+    if not lines:
+        print(f"No credentials stored for provider: {provider}", file=sys.stderr)
+        return 1
+    for line in lines:
+        print(line)
+    return 0
+
+
+def _run_credentials_set(provider: str, key: str, value: str | None = None) -> int:
+    """Store credential. Value can be passed inline, read from stdin, or prompted interactively."""
+    if provider not in KNOWN_CREDENTIALS:
+        print(f"Unknown provider: {provider}", file=sys.stderr)
+        return 1
+    if key not in KNOWN_CREDENTIALS[provider]:
+        print(f"Unknown key for {provider}: {key}", file=sys.stderr)
+        return 1
+
+    if value is not None and value.strip():
+        # Inline value from CLI
+        pass
+    elif not sys.stdin.isatty():
+        # Piped input: echo "val" | devsper credentials set ...
+        try:
+            value = sys.stdin.read().strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\nCancelled.", file=sys.stderr)
+            return 130
+    else:
+        # Interactive prompt
+        try:
+            if key in SENSITIVE_KEYS:
+                value = getpass.getpass(f"Enter value for {provider}/{key}: ")
+            else:
+                value = input(f"Enter value for {provider}/{key}: ")
+        except (KeyboardInterrupt, EOFError):
+            print("\nCancelled.", file=sys.stderr)
+            return 130
+
+    if not value or not value.strip():
+        print("Empty value, not stored.", file=sys.stderr)
+        return 1
+    set_credential(provider, key, value.strip())
+    print(f"Stored {provider}/{key}")
+    return 0
+
+
+def _run_credentials_list() -> int:
+    """List credentials as table (provider, key, value). Secret keys show '(stored)', others show value."""
+    creds = list_credentials()
+    if not creds:
+        print("No credentials stored.")
+        return 0
+    table = Table(title="Stored credentials")
+    table.add_column("Provider", style="cyan")
+    table.add_column("Key", style="green")
+    table.add_column("Value", style="dim")
+    for c in creds:
+        p, k = c["provider"], c["key"]
+        if k in SENSITIVE_KEYS:
+            value = "(stored)"
+        else:
+            val = get_credential(p, k)
+            value = (val[:60] + "…") if val and len(val) > 60 else (val or "")
+        table.add_row(p, k, value)
+    console = Console()
+    console.print(table)
+    return 0
+
+
+def _run_credentials_delete(provider: str, key: str) -> int:
+    """Remove a credential."""
+    if provider not in KNOWN_CREDENTIALS:
+        print(f"Unknown provider: {provider}", file=sys.stderr)
+        return 1
+    if key not in KNOWN_CREDENTIALS[provider]:
+        print(f"Unknown key for {provider}: {key}", file=sys.stderr)
+        return 1
+    delete_credential(provider, key)
+    print(f"Deleted {provider}/{key}")
+    return 0
+
+
+def _run_credentials_migrate() -> int:
+    """Migrate credentials from TOML and env to store."""
+    from devsper.config.config_loader import project_config_paths
+
+    config_path = None
+    for p in project_config_paths():
+        if p.is_file():
+            config_path = p
+            break
+    if not config_path:
+        config_path = Path.cwd() / "devsper.toml"
+
+    migrated = migrate_from_config(config_path)
+    if not migrated:
+        print("No credentials found in env or TOML to migrate.")
+        return 0
+    print(f"Migrated {len(migrated)} credential(s):")
+    for item in migrated:
+        print(f"  - {item}")
+    print("\nYou can now remove these from devsper.toml and .env for better security.")
+    return 0
+
+
+def run_credentials(args: object) -> int:
+    """Dispatch credentials subcommand."""
+    sub = getattr(args, "credentials_subcommand", None)
+    provider = getattr(args, "provider", None)
+    key = getattr(args, "key", None)
+
+    if sub == "set":
+        if not provider or not key:
+            print("Usage: devsper credentials set <provider> <key> [value]", file=sys.stderr)
+            return 1
+        value = getattr(args, "value", None)
+        return _run_credentials_set(provider, key, value)
+    if sub == "list":
+        return _run_credentials_list()
+    if sub == "delete":
+        if not provider or not key:
+            print("Usage: devsper credentials delete <provider> <key>", file=sys.stderr)
+            return 1
+        return _run_credentials_delete(provider, key)
+    if sub == "migrate":
+        return _run_credentials_migrate()
+    if sub == "export":
+        if not provider:
+            print("Usage: devsper credentials export <provider>", file=sys.stderr)
+            return 1
+        return _run_credentials_export(provider)
+
+    print("Usage: devsper credentials set|list|delete|migrate|export", file=sys.stderr)
+    return 1

devsper/credentials/migration.py

@@ -0,0 +1,124 @@
+"""Migrate credentials from devsper.toml and env to the credential store."""
+
+import os
+from pathlib import Path
+
+from devsper.credentials import set_credential
+
+
+def _load_dotenv_for_config(config_path: Path) -> None:
+    """Load .env from config directory so env vars are available for migration."""
+    try:
+        from dotenv import load_dotenv
+
+        load_dotenv(config_path.parent / ".env")
+    except Exception:
+        pass
+
+# Env var -> (provider, key)
+_ENV_TO_CREDENTIAL: dict[str, tuple[str, str]] = {
+    "OPENAI_API_KEY": ("openai", "api_key"),
+    "ANTHROPIC_API_KEY": ("anthropic", "api_key"),
+    "GITHUB_TOKEN": ("github", "token"),
+    "GEMINI_API_KEY": ("gemini", "api_key"),
+    "GOOGLE_API_KEY": ("gemini", "api_key"),
+    "AZURE_OPENAI_API_KEY": ("azure", "api_key"),
+    "AZURE_OPENAI_ENDPOINT": ("azure", "endpoint"),
+    "AZURE_OPENAI_DEPLOYMENT_NAME": ("azure", "deployment"),
+    "AZURE_OPENAI_API_VERSION": ("azure", "api_version"),
+    "AZURE_ANTHROPIC_ENDPOINT": ("azure_anthropic", "endpoint"),
+    "AZURE_ANTHROPIC_API_KEY": ("azure_anthropic", "api_key"),
+    "AZURE_ANTHROPIC_DEPLOYMENT_NAME": ("azure_anthropic", "deployment"),
+}
+
+
+def migrate_from_config(config_path: Path) -> list[str]:
+    """
+    Scan TOML and env for known credentials, migrate to store.
+    Returns list of migrated items (e.g. ["openai/api_key", "azure/endpoint"]).
+    Does NOT delete from env — inform user they can remove them.
+    """
+    migrated: list[str] = []
+
+    # Load .env from config directory so all env vars are available
+    _load_dotenv_for_config(config_path)
+
+    # 1. Check env vars
+    for env_var, (provider, key) in _ENV_TO_CREDENTIAL.items():
+        val = os.environ.get(env_var)
+        if val and str(val).strip():
+            set_credential(provider, key, str(val).strip())
+            migrated.append(f"{provider}/{key}")
+
+    # 2. Check TOML
+    if config_path.is_file():
+        try:
+            import tomllib
+
+            with open(config_path, "rb") as f:
+                data = tomllib.load(f)
+        except Exception:
+            return migrated
+
+        # [providers.azure]
+        providers = data.get("providers") or {}
+        azure = providers.get("azure")
+        if isinstance(azure, dict):
+            for toml_key, cred_key in [
+                ("endpoint", "endpoint"),
+                ("api_key", "api_key"),
+                ("deployment", "deployment"),
+                ("api_version", "api_version"),
+            ]:
+                val = azure.get(toml_key)
+                if val is not None and str(val).strip():
+                    item = f"azure/{cred_key}"
+                    if item not in migrated:
+                        set_credential("azure", cred_key, str(val).strip())
+                        migrated.append(item)
+
+        # Legacy sections: [openai], [anthropic], [azure_openai], etc.
+        for section, (provider, key) in [
+            ("openai", ("openai", "api_key")),
+            ("anthropic", ("anthropic", "api_key")),
+            ("google", ("gemini", "api_key")),
+        ]:
+            block = data.get(section)
+            if isinstance(block, dict):
+                val = block.get("api_key")
+                if val is not None and str(val).strip():
+                    item = f"{provider}/{key}"
+                    if item not in migrated:
+                        set_credential(provider, key, str(val).strip())
+                        migrated.append(item)
+
+        azure_block = data.get("azure_openai")
+        if isinstance(azure_block, dict):
+            for toml_key, cred_key in [
+                ("endpoint", "endpoint"),
+                ("api_key", "api_key"),
+                ("deployment_name", "deployment"),
+                ("api_version", "api_version"),
+            ]:
+                val = azure_block.get(toml_key)
+                if val is not None and str(val).strip():
+                    item = f"azure/{cred_key}"
+                    if item not in migrated:
+                        set_credential("azure", cred_key, str(val).strip())
+                        migrated.append(item)
+
+        azure_anthropic_block = data.get("azure_anthropic")
+        if isinstance(azure_anthropic_block, dict):
+            for toml_key, cred_key in [
+                ("endpoint", "endpoint"),
+                ("api_key", "api_key"),
+                ("deployment_name", "deployment"),
+            ]:
+                val = azure_anthropic_block.get(toml_key)
+                if val is not None and str(val).strip():
+                    item = f"azure_anthropic/{cred_key}"
+                    if item not in migrated:
+                        set_credential("azure_anthropic", cred_key, str(val).strip())
+                        migrated.append(item)
+
+    return migrated

devsper/credentials/store.py

@@ -0,0 +1,142 @@
+"""Credential store: OS keychain (keyring) only."""
+
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+# (provider, key) -> env var name; used to inject keychain into env for providers (e.g. run_agent subprocess).
+_PROVIDER_KEY_TO_ENV: list[tuple[str, str, str]] = [
+    ("openai", "api_key", "OPENAI_API_KEY"),
+    ("anthropic", "api_key", "ANTHROPIC_API_KEY"),
+    ("github", "token", "GITHUB_TOKEN"),
+    ("gemini", "api_key", "GEMINI_API_KEY"),
+    ("gemini", "api_key", "GOOGLE_API_KEY"),
+    ("azure", "api_key", "AZURE_OPENAI_API_KEY"),
+    ("azure", "endpoint", "AZURE_OPENAI_ENDPOINT"),
+    ("azure", "deployment", "AZURE_OPENAI_DEPLOYMENT_NAME"),
+    ("azure", "api_version", "AZURE_OPENAI_API_VERSION"),
+    ("azure_anthropic", "api_key", "AZURE_ANTHROPIC_API_KEY"),
+    ("azure_anthropic", "endpoint", "AZURE_ANTHROPIC_ENDPOINT"),
+    ("azure_anthropic", "deployment", "AZURE_ANTHROPIC_DEPLOYMENT_NAME"),
+]
+
+SERVICE_NAME = "devsper"
+
+# Provider/key -> known keys for list_all
+KNOWN_CREDENTIALS = {
+    "openai": ["api_key"],
+    "anthropic": ["api_key"],
+    "github": ["token"],
+    "gemini": ["api_key"],
+    "azure": ["endpoint", "api_key", "deployment", "api_version"],
+    "azure_anthropic": ["endpoint", "api_key", "deployment"],
+}
+
+
+def _username(provider: str, key: str) -> str:
+    return f"{provider}/{key}"
+
+
+class CredentialStore:
+    """
+    Secure credential store using OS keychain (keyring) only.
+    Never logs credential values.
+    """
+
+    def get(self, provider: str, key: str) -> str | None:
+        """Get credential from keyring. Returns None if not found or keyring unavailable."""
+        username = _username(provider, key)
+        try:
+            import keyring
+            from keyring.errors import KeyringError
+
+            val = keyring.get_password(SERVICE_NAME, username)
+            if val is not None:
+                logger.debug("Credential %s/%s retrieved from keyring", provider, key)
+            return val
+        except KeyringError:
+            logger.debug("Keyring unavailable")
+            return None
+        except Exception as e:
+            logger.debug("Keyring error: %s", type(e).__name__)
+            return None
+
+    def set(self, provider: str, key: str, value: str) -> None:
+        """Store credential in keyring."""
+        username = _username(provider, key)
+        try:
+            import keyring
+            from keyring.errors import KeyringError
+
+            keyring.set_password(SERVICE_NAME, username, value)
+            logger.debug("Credential %s/%s stored in keyring", provider, key)
+        except KeyringError as e:
+            raise RuntimeError("Keyring unavailable; cannot store credentials") from e
+        except Exception as e:
+            raise RuntimeError(f"Keyring error: {e}") from e
+
+    def delete(self, provider: str, key: str) -> None:
+        """Delete credential from keyring."""
+        username = _username(provider, key)
+        try:
+            import keyring
+            keyring.delete_password(SERVICE_NAME, username)
+        except Exception:
+            pass
+
+    def list_all(self) -> list[dict]:
+        """List stored credentials: [{provider, key, source}]. Never returns values."""
+        result: list[dict] = []
+        try:
+            import keyring
+
+            for provider, keys in KNOWN_CREDENTIALS.items():
+                for k in keys:
+                    username = _username(provider, k)
+                    val = keyring.get_password(SERVICE_NAME, username)
+                    if val is not None:
+                        result.append({"provider": provider, "key": k, "source": "keyring"})
+        except Exception:
+            pass
+        return result
+
+
+_default_store: CredentialStore | None = None
+
+
+def _get_store() -> CredentialStore:
+    global _default_store
+    if _default_store is None:
+        _default_store = CredentialStore()
+    return _default_store
+
+
+def get_credential(provider: str, key: str) -> str | None:
+    """Get credential from store. Returns None if not found."""
+    return _get_store().get(provider, key)
+
+
+def set_credential(provider: str, key: str, value: str) -> None:
+    """Store credential in keyring."""
+    _get_store().set(provider, key, value)
+
+
+def delete_credential(provider: str, key: str) -> None:
+    """Remove credential from store."""
+    _get_store().delete(provider, key)
+
+
+def list_credentials() -> list[dict]:
+    """List stored credentials (provider, key, source). Never returns values."""
+    return _get_store().list_all()
+
+
+def inject_into_env() -> None:
+    """Set os.environ from keychain for each provider key that is not already set.
+    Call this at process startup (e.g. run_agent subprocess) so providers see credentials."""
+    for provider, key, env_var in _PROVIDER_KEY_TO_ENV:
+        if not os.environ.get(env_var):
+            val = get_credential(provider, key)
+            if val:
+                os.environ[env_var] = val

devsper/dashboard/__init__.py

@@ -0,0 +1,9 @@
+"""
+Swarm dashboard: view task DAG, replay, memory entries, telemetry.
+
+Terminal output via Rich. Use show_dashboard() for a combined view.
+"""
+
+from devsper.dashboard.dashboard import show_dashboard
+
+__all__ = ["show_dashboard"]

devsper/dashboard/dashboard.py

@@ -0,0 +1,87 @@
+"""
+Minimal visualization: task DAG, swarm replay, memory entries, telemetry.
+
+Uses Rich for terminal output when available; falls back to plain text.
+"""
+
+import os
+from pathlib import Path
+
+from devsper.swarm.scheduler import Scheduler
+from devsper.runtime.visualize import visualize_scheduler_dag
+from devsper.runtime.replay import replay_execution
+from devsper.runtime.telemetry import collect_telemetry, print_telemetry_summary
+from devsper.memory.memory_store import MemoryStore, get_default_store
+
+
+def _latest_log_path(events_folder: str = ".devsper/events") -> str | None:
+    if not os.path.isdir(events_folder):
+        return None
+    files = list(Path(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 show_dashboard(
+    scheduler: Scheduler | None = None,
+    log_path: str | None = None,
+    memory_store: MemoryStore | None = None,
+    events_folder: str = ".devsper/events",
+    memory_limit: int = 20,
+) -> str:
+    """
+    Print a combined dashboard: task DAG (if scheduler given), swarm replay and telemetry
+    (if log_path or latest log in events_folder), and recent memory entries (if store given).
+    Returns the full dashboard as a string.
+    """
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        use_rich = True
+    except ImportError:
+        use_rich = False
+
+    lines: list[str] = []
+
+    if scheduler is not None:
+        dag = visualize_scheduler_dag(scheduler)
+        lines.append("=== TASK DAG ===")
+        lines.append(dag)
+        lines.append("")
+
+    if log_path is None:
+        log_path = _latest_log_path(events_folder)
+    if log_path and os.path.exists(log_path):
+        lines.append("=== SWARM REPLAY ===")
+        lines.append(replay_execution(log_path))
+        lines.append("")
+        lines.append("=== TELEMETRY ===")
+        lines.append(print_telemetry_summary(log_path))
+        lines.append("")
+    else:
+        lines.append("=== SWARM REPLAY / TELEMETRY ===")
+        lines.append("(no event log found)")
+        lines.append("")
+
+    store = memory_store or get_default_store()
+    lines.append("=== MEMORY (recent) ===")
+    try:
+        records = store.list_memory(limit=memory_limit)
+        if not records:
+            lines.append("(no memory entries)")
+        else:
+            for r in records:
+                lines.append(f"  [{r.memory_type.value}] {r.id}: {r.content[:120]}{'...' if len(r.content) > 120 else ''}")
+    except Exception as e:
+        lines.append(f"(error listing memory: {e})")
+    lines.append("")
+
+    out = "\n".join(lines)
+    if use_rich:
+        console = Console()
+        console.print(Panel(out, title="Swarm Dashboard", border_style="blue"))
+    else:
+        print(out)
+    return out

devsper/dev/__init__.py

@@ -0,0 +1,25 @@
+"""
+Autonomous Application Builder: build working repos from app descriptions.
+
+Modules:
+- builder: orchestrates architecture → scaffold → implement → test → debug
+- scaffold: repo structure generation (backend, frontend, tests, docker)
+- sandbox: isolated execution with timeout and resource limits
+- debugger: test run → error detection → fix tasks → patch loop
+- repo_index: AST parsing, dependency graph, symbol search (code intelligence)
+- agents: dev-specific roles (architect, backend, frontend, test, review)
+"""
+
+from devsper.dev.builder import run_build
+from devsper.dev.scaffold import scaffold_repo
+from devsper.dev.sandbox import Sandbox
+from devsper.dev.debugger import debug_loop
+from devsper.dev.repo_index import RepoIndex
+
+__all__ = [
+    "run_build",
+    "scaffold_repo",
+    "Sandbox",
+    "debug_loop",
+    "RepoIndex",
+]