simplicio-sprint 1.0.0__py3-none-any.whl

sendsprint/__init__.py

@@ -0,0 +1,10 @@
+"""SendSprint — autonomous sprint-to-PR delivery agent.
+
+The agent (Claude, driving this package) reads a sprint from Jira / Azure
+DevOps / GitHub Issues, hands each task to simplicio-cli for the code edit,
+captures evidence, and opens a draft PR for review. simplicio-cli is the
+executor; SendSprint owns the flow start to finish.
+"""
+
+__version__ = "3.0.0"
+__all__ = ["__version__"]

sendsprint/bootstrap.py

@@ -0,0 +1,170 @@
+"""Keep the external simplicio tools current.
+
+``sendsprint update`` (and, per the runtime profile, the start of ``run`` /
+``watch``) pulls the latest simplicio-cli (pip), the simplicio-prompt kernel
+(git), and optionally simplicio-mapper (git). Everything here is best-effort: a
+stale or missing tool degrades to a skipped/failed :class:`UpdateResult`, never
+an aborted run. Network can be disabled with ``SENDSPRINT_NO_UPDATE=1``.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+Runner = Callable[..., subprocess.CompletedProcess[str]]
+
+SIMPLICIO_PROMPT_REPO = "https://github.com/wesleysimplicio/simplicio-prompt"
+SIMPLICIO_MAPPER_REPO = "https://github.com/wesleysimplicio/simplicio-mapper"
+PROMPT_KERNEL_REL = Path("kernel/subagent_runtime.py")
+DEFAULT_TIMEOUT_S = 300
+
+
+def cache_dir() -> Path:
+    """Where SendSprint caches git-cloned tools (override: ``SENDSPRINT_CACHE_DIR``)."""
+    return Path(os.environ.get("SENDSPRINT_CACHE_DIR", "~/.cache/sendsprint")).expanduser()
+
+
+def default_prompt_kernel() -> Path:
+    """Conventional path to the simplicio-prompt kernel inside the cache."""
+    return cache_dir() / "simplicio-prompt" / PROMPT_KERNEL_REL
+
+
+@dataclass
+class UpdateResult:
+    """Outcome of one tool update / check."""
+
+    name: str
+    status: str  # "ok" | "skipped" | "failed"
+    detail: str = ""
+
+    def line(self) -> str:
+        return f"{self.name}: {self.status}" + (f" — {self.detail}" if self.detail else "")
+
+
+@dataclass
+class StartupReport:
+    """Aggregated results of an update/startup pass."""
+
+    results: list[UpdateResult] = field(default_factory=list)
+
+    @property
+    def ok(self) -> bool:
+        return all(r.status != "failed" for r in self.results)
+
+
+class Updater:
+    """Run the tool updates. Subprocess calls go through an injectable runner."""
+
+    def __init__(
+        self,
+        *,
+        runner: Runner = subprocess.run,
+        python: str = sys.executable,
+        cache: Path | None = None,
+        timeout_s: int = DEFAULT_TIMEOUT_S,
+    ) -> None:
+        self._runner = runner
+        self.python = python
+        self.cache = Path(cache) if cache is not None else cache_dir()
+        self.timeout_s = timeout_s
+
+    def _run(self, argv: list[str]) -> subprocess.CompletedProcess[str]:
+        return self._runner(argv, capture_output=True, text=True, timeout=self.timeout_s)
+
+    # -- individual tools ---------------------------------------------------
+
+    def update_simplicio_cli(self) -> UpdateResult:
+        try:
+            proc = self._run([self.python, "-m", "pip", "install", "-U", "simplicio-cli"])
+        except (FileNotFoundError, subprocess.SubprocessError) as exc:
+            return UpdateResult("simplicio-cli", "failed", str(exc))
+        if proc.returncode != 0:
+            return UpdateResult("simplicio-cli", "failed", (proc.stderr or "").strip()[:200])
+        return UpdateResult("simplicio-cli", "ok", "pip install -U")
+
+    def update_simplicio_prompt(self) -> UpdateResult:
+        dest = self.cache / "simplicio-prompt"
+        res = self._git_sync("simplicio-prompt", SIMPLICIO_PROMPT_REPO, dest)
+        if res.status == "ok":
+            kernel = dest / PROMPT_KERNEL_REL
+            res.detail = f"{res.detail}; kernel at {kernel}"
+            os.environ.setdefault("SIMPLICIO_PROMPT_KERNEL", str(kernel))
+        return res
+
+    def update_simplicio_mapper(self) -> UpdateResult:
+        dest = self.cache / "simplicio-mapper"
+        return self._git_sync("simplicio-mapper", SIMPLICIO_MAPPER_REPO, dest)
+
+    # -- batches ------------------------------------------------------------
+
+    def update_all(
+        self, *, cli: bool = True, prompt: bool = True, mapper: bool = True
+    ) -> StartupReport:
+        report = StartupReport()
+        if cli:
+            report.results.append(self.update_simplicio_cli())
+        if prompt:
+            report.results.append(self.update_simplicio_prompt())
+        if mapper:
+            report.results.append(self.update_simplicio_mapper())
+        return report
+
+    def run_startup(self, profile: object) -> StartupReport:
+        """Run only the passes enabled by the runtime profile flags."""
+        runtime = getattr(profile, "runtime", None)
+        report = StartupReport()
+        if getattr(runtime, "verify_dependencies_on_start", False):
+            report.results.extend(self.verify_dependencies())
+        if getattr(runtime, "update_simplicio_prompt_on_start", False):
+            report.results.append(self.update_simplicio_prompt())
+        if getattr(runtime, "update_llm_project_mapper_on_start", False):
+            report.results.append(self.update_simplicio_mapper())
+        return report
+
+    def verify_dependencies(self) -> list[UpdateResult]:
+        results = [
+            _which("simplicio", "not installed (pip install simplicio-cli)"),
+            _which("git", "git not found on PATH", fail=True),
+        ]
+        kernel = Path(os.getenv("SIMPLICIO_PROMPT_KERNEL") or default_prompt_kernel())
+        results.append(
+            UpdateResult(
+                "simplicio-prompt kernel",
+                "ok" if kernel.exists() else "skipped",
+                str(kernel),
+            )
+        )
+        return results
+
+    # -- internals ----------------------------------------------------------
+
+    def _git_sync(self, name: str, repo_url: str, dest: Path) -> UpdateResult:
+        dest = Path(dest)
+        try:
+            if (dest / ".git").exists():
+                proc = self._run(["git", "-C", str(dest), "pull", "--ff-only"])
+                action = "pulled"
+            else:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                proc = self._run(["git", "clone", "--depth", "1", repo_url, str(dest)])
+                action = "cloned"
+        except (FileNotFoundError, subprocess.SubprocessError) as exc:
+            return UpdateResult(name, "failed", str(exc))
+        if proc.returncode != 0:
+            return UpdateResult(name, "failed", (proc.stderr or "").strip()[:200])
+        return UpdateResult(name, "ok", action)
+
+
+def _which(binary: str, missing_detail: str, *, fail: bool = False) -> UpdateResult:
+    if shutil.which(binary):
+        return UpdateResult(binary, "ok", "on PATH")
+    return UpdateResult(binary, "failed" if fail else "skipped", missing_detail)

sendsprint/cli.py

@@ -0,0 +1,333 @@
+"""SendSprint CLI — read a sprint, let simplicio-cli execute, ship draft PRs.
+
+SendSprint is the agent that owns the flow; simplicio-cli is the executor it
+calls per task. Commands:
+
+    sendsprint version
+    sendsprint login   jira|azuredevops|github
+    sendsprint logout  jira|azuredevops|github
+    sendsprint run     <source> <sprint> --repo PATH --scope mine
+    sendsprint watch   <source> <sprint> --repo PATH --once   # unattended trigger
+"""
+
+# ruff: noqa: B008 - Typer's documented API uses Option/Argument call in defaults.
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from sendsprint import __version__
+from sendsprint import credentials as creds
+from sendsprint.flow import RepoTarget, SprintFlow
+from sendsprint.models import ScopeConfig
+from sendsprint.operators import (
+    AzureDevopsOperator,
+    BaseOperator,
+    GitHubIssuesOperator,
+    JiraOperator,
+)
+from sendsprint.prompt import PromptFanout
+from sendsprint.scope import build_scope
+from sendsprint.watch import Watcher
+
+app = typer.Typer(add_completion=False, help="Autonomous sprint-to-PR delivery.")
+console = Console()
+logger = logging.getLogger("sendsprint.cli")
+
+SOURCES = ("jira", "azuredevops", "github")
+
+
+@app.callback()
+def _main(
+    log_level: str = typer.Option("INFO", "--log-level", help="DEBUG | INFO | WARNING | ERROR"),
+    log_file: Path | None = typer.Option(None, "--log-file", help="Override the log file path"),
+    log_json: bool = typer.Option(False, "--log-json", help="Write logs as JSON lines"),
+) -> None:
+    """Configure logging for every command (logs capture every step to a file)."""
+    from sendsprint.logging_setup import configure
+
+    path = configure(level=log_level, log_file=log_file, json_lines=log_json)
+    logger.debug("sendsprint %s — logging to %s", __version__, path)
+
+
+@app.command()
+def version() -> None:
+    """Print the SendSprint version."""
+    console.print(f"SendSprint {__version__}")
+
+
+@app.command()
+def login(provider: str) -> None:
+    """Store credentials for a source in the OS keyring (one-time)."""
+    provider = provider.lower()
+    if provider == "jira":
+        creds.get_or_prompt("jira", "JIRA_EMAIL", "JIRA_API_TOKEN", account_label="email")
+    elif provider == "azuredevops":
+        creds.get_or_prompt(
+            "azuredevops", "AZURE_DEVOPS_ORG", "AZURE_DEVOPS_PAT", account_label="organization"
+        )
+    elif provider == "github":
+        typer.echo("github uses the GITHUB_TOKEN environment variable; no keyring entry needed.")
+    else:
+        raise typer.BadParameter(f"provider must be one of {SOURCES}")
+
+
+@app.command()
+def logout(provider: str, account: str) -> None:
+    """Delete a stored credential."""
+    creds.delete_secret(provider, account)  # type: ignore[arg-type]
+    console.print(f"removed {provider} credential for {account}")
+
+
+@app.command()
+def update(
+    cli: bool = typer.Option(True, help="Upgrade simplicio-cli via pip"),
+    prompt: bool = typer.Option(True, help="Sync the simplicio-prompt kernel via git"),
+    mapper: bool = typer.Option(True, help="Sync simplicio-mapper via git"),
+) -> None:
+    """Pull the latest of simplicio-cli / simplicio-prompt / simplicio-mapper."""
+    from sendsprint.bootstrap import Updater
+
+    report = Updater().update_all(cli=cli, prompt=prompt, mapper=mapper)
+    for result in report.results:
+        console.print(f"  {result.line()}")
+    raise typer.Exit(code=0 if report.ok else 1)
+
+
+@app.command()
+def install(
+    target: list[str] = typer.Option(
+        [], "--target", "-t", help="Agent(s) to install for; repeatable"
+    ),
+    all_: bool = typer.Option(False, "--all", help="Install for every supported agent"),
+    repo: Path = typer.Option(Path("."), help="Target project directory"),
+) -> None:
+    """Install the SendSprint skill into each agent's convention (Cursor, Claude, ...)."""
+    from sendsprint.installer import TARGETS
+    from sendsprint.installer import install as do_install
+
+    names = sorted(TARGETS) if all_ or not target else target
+    try:
+        results = do_install(repo, names)
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
+    for result in results:
+        console.print(f"  {result.line()}")
+
+
+@app.command()
+def run(
+    source: str = typer.Argument(..., help="jira | azuredevops | github"),
+    sprint: str = typer.Argument(..., help="Jira sprint id, ADO iteration path, or GH milestone"),
+    repo: Path = typer.Option(Path("."), help="Path to the target git repo"),
+    scope: str = typer.Option("mine", help="mine | all"),
+    pr_provider: str = typer.Option("github", help="github | azuredevops"),
+    repo_slug: str = typer.Option("", help="owner/repo (github) or repository id (ado)"),
+    base: str = typer.Option("develop", help="PR target branch"),
+    tech: str | None = typer.Option(None, help="Override detected stack for simplicio --stack"),
+    test_command: str | None = typer.Option(None, help="Command to run for test evidence"),
+    frontend_url: str | None = typer.Option(None, help="URL to screenshot for screen evidence"),
+    draft: bool = typer.Option(True, help="Open PRs as drafts pending your review"),
+    specs: bool = typer.Option(True, help="Write simplicio-mapper .specs/ task files per card"),
+    fanout: bool = typer.Option(False, help="Run a simplicio-prompt subagent fan-out per card"),
+    fanout_subagents: int = typer.Option(600, help="Subagents per fan-out"),
+    fanout_provider: str = typer.Option("deepseek", help="simplicio-prompt provider"),
+    fanout_dry_run: bool = typer.Option(False, help="Run the fan-out offline (no key/network)"),
+    no_update: bool = typer.Option(False, help="Skip the start-up tool update (profile-driven)"),
+    output: Path | None = typer.Option(None, "-o", "--output", help="Write RunReport JSON"),
+) -> None:
+    """Deliver a sprint: each card → simplicio task → evidence → draft PR."""
+    _startup(no_update)
+    operator = _build_operator(source)
+    flow = _build_flow(
+        operator,
+        source=source,
+        repo=repo,
+        scope_mode=scope,
+        pr_provider=pr_provider,
+        repo_slug=repo_slug,
+        base=base,
+        tech=tech,
+        test_command=test_command,
+        frontend_url=frontend_url,
+        draft=draft,
+        write_specs=specs,
+        fanout=fanout,
+        fanout_subagents=fanout_subagents,
+        fanout_provider=fanout_provider,
+        fanout_dry_run=fanout_dry_run,
+    )
+    report = flow.run(**_read_kwargs(source, sprint, flow.scope))
+    console.print(f"[bold]{report.summary}[/bold]")
+    for pr in report.prs:
+        console.print(f"  PR: {pr.url or pr.number} ({pr.state})")
+    _archive_report(report)
+    if output:
+        output.write_text(report.model_dump_json(indent=2), encoding="utf-8")
+        console.print(f"report written to {output}")
+    raise typer.Exit(code=1 if report.failed else 0)
+
+
+@app.command()
+def watch(
+    source: str = typer.Argument(..., help="jira | azuredevops | github"),
+    sprint: str = typer.Argument(..., help="Jira sprint id, ADO iteration path, or GH milestone"),
+    repo: Path = typer.Option(Path("."), help="Path to the target git repo"),
+    pr_provider: str = typer.Option("github", help="github | azuredevops"),
+    repo_slug: str = typer.Option("", help="owner/repo (github) or repository id (ado)"),
+    base: str = typer.Option("develop", help="PR target branch"),
+    tech: str | None = typer.Option(None, help="Override detected stack"),
+    test_command: str | None = typer.Option(None, help="Command to run for test evidence"),
+    interval: int = typer.Option(15, help="Minutes between cycles in loop mode"),
+    once: bool = typer.Option(False, help="Run a single cycle and exit (for cron/CI triggers)"),
+    max_per_cycle: int = typer.Option(1, help="Max cards delivered per cycle"),
+    no_update: bool = typer.Option(False, help="Skip the start-up tool update (profile-driven)"),
+) -> None:
+    """Unattended trigger: finish cards assigned to me, scoped with --scope mine."""
+    _startup(no_update)
+    operator = _build_operator(source)
+    flow = _build_flow(
+        operator,
+        source=source,
+        repo=repo,
+        scope_mode="mine",
+        pr_provider=pr_provider,
+        repo_slug=repo_slug,
+        base=base,
+        tech=tech,
+        test_command=test_command,
+        frontend_url=None,
+        draft=True,
+    )
+    watcher = Watcher(flow, interval_minutes=interval, max_per_cycle=max_per_cycle)
+    read_kwargs = _read_kwargs(source, sprint, flow.scope)
+    if once:
+        report = watcher.run_once(**read_kwargs)
+        console.print(f"[bold]{report.summary}[/bold]")
+        raise typer.Exit(code=1 if report.failed else 0)
+    console.print(f"watching {source} {sprint} every {interval}m (scope=mine). Ctrl-C to stop.")
+    watcher.loop(**read_kwargs)
+
+
+# -- builders ---------------------------------------------------------------
+
+
+def _startup(skip: bool) -> None:
+    """Run the profile-driven tool update before a delivery. Never fatal."""
+    if skip or os.getenv("SENDSPRINT_NO_UPDATE") == "1":
+        return
+    try:
+        from sendsprint import profile as profile_mod
+        from sendsprint.bootstrap import Updater
+
+        report = Updater().run_startup(profile_mod.load())
+        for result in report.results:
+            console.print(f"  [dim]{result.line()}[/dim]")
+    except Exception as exc:  # noqa: BLE001 — startup updates are best-effort
+        logger.warning("startup update skipped: %s", exc)
+
+
+def _archive_report(report: object) -> None:
+    """Persist the run report JSON next to the logs. Best-effort."""
+    try:
+        from datetime import UTC, datetime
+
+        from sendsprint.logging_setup import log_dir
+
+        stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+        path = log_dir() / f"run-{stamp}.report.json"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(report.model_dump_json(indent=2), encoding="utf-8")  # type: ignore[attr-defined]
+        console.print(f"[dim]run report archived to {path}[/dim]")
+    except Exception as exc:  # noqa: BLE001 — archiving is best-effort
+        logger.warning("could not archive run report: %s", exc)
+
+
+def _build_operator(source: str) -> BaseOperator:
+    source = source.lower()
+    if source == "jira":
+        return JiraOperator()
+    if source == "azuredevops":
+        return AzureDevopsOperator()
+    if source == "github":
+        return GitHubIssuesOperator()
+    raise typer.BadParameter(f"source must be one of {SOURCES}")
+
+
+def _build_flow(
+    operator: BaseOperator,
+    *,
+    source: str,
+    repo: Path,
+    scope_mode: str,
+    pr_provider: str,
+    repo_slug: str,
+    base: str,
+    tech: str | None,
+    test_command: str | None,
+    frontend_url: str | None,
+    draft: bool,
+    write_specs: bool = True,
+    fanout: bool = False,
+    fanout_subagents: int = 600,
+    fanout_provider: str = "deepseek",
+    fanout_dry_run: bool = False,
+) -> SprintFlow:
+    target = RepoTarget(
+        path=repo,
+        name=repo_slug or repo.name,
+        tech=tech,
+        test_command=test_command,
+        base_branch=base,
+        pr_provider=pr_provider,
+        repo_slug=repo_slug,
+        frontend_url=frontend_url,
+    )
+    scope = _build_scope(operator, scope_mode)
+    fan = (
+        PromptFanout(provider=fanout_provider, subagents=fanout_subagents, dry_run=fanout_dry_run)
+        if fanout
+        else None
+    )
+    return SprintFlow(
+        operator, target, scope=scope, draft_prs=draft, write_specs=write_specs, fanout=fan
+    )
+
+
+def _build_scope(operator: BaseOperator, mode: str) -> ScopeConfig:
+    if mode != "mine":
+        return build_scope(mode="all")
+    user = operator.current_user() if hasattr(operator, "current_user") else {}
+    return build_scope(
+        mode="mine",
+        user_email=user.get("emailAddress") or user.get("email"),
+        user_account_id=user.get("accountId"),
+        user_descriptor=user.get("descriptor"),
+        user_display_name=user.get("displayName") or user.get("name") or user.get("login"),
+    )
+
+
+def _read_kwargs(source: str, sprint: str, scope: ScopeConfig | None) -> dict[str, object]:
+    source = source.lower()
+    if source == "jira":
+        return {"sprint_id": sprint}
+    if source == "azuredevops":
+        return {"iteration_path": sprint}
+    # github: milestone + assignee login when scoping to me
+    kwargs: dict[str, object] = {"sprint_id": sprint}
+    if scope and scope.mode == "mine" and scope.user_display_name:
+        kwargs["assignee"] = scope.user_display_name
+    return kwargs
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

sendsprint/credentials.py

@@ -0,0 +1,132 @@
+"""Persistent credential store backed by the OS keyring.
+
+First call to :func:`get_or_prompt` asks the user once; the value is then
+stored in macOS Keychain / Linux Secret Service / Windows Credential Manager
+via the ``keyring`` library and returned silently on subsequent calls.
+
+No secret ever touches disk in plaintext. Profile metadata (non-secret prefs
+like default provider / sprint id) lives in :mod:`sendsprint.profile`.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+from typing import Literal
+
+logger = logging.getLogger(__name__)
+
+SERVICE = "sendsprint"
+Provider = Literal["jira", "azuredevops"]
+_VOLATILE_SECRETS: dict[str, str] = {}
+
+
+class CredentialError(RuntimeError):
+    """Raised when credentials cannot be read or written."""
+
+
+def _keyring():
+    try:
+        import keyring  # type: ignore[import-not-found]
+    except ImportError as exc:
+        raise CredentialError(
+            "keyring not installed. run: pip install 'sendsprint[keyring]'"
+        ) from exc
+    return keyring
+
+
+def _username(provider: Provider, account: str) -> str:
+    return f"{provider}:{account}"
+
+
+def _cache_key(provider: Provider, account: str) -> str:
+    return _username(provider, account.strip())
+
+
+def get_secret(provider: Provider, account: str) -> str | None:
+    """Return the stored secret for ``provider:account`` or ``None``."""
+    normalized = account.strip()
+    if not normalized:
+        return None
+    kr = _keyring()
+    try:
+        secret = kr.get_password(SERVICE, _username(provider, normalized))
+    except Exception as exc:  # pragma: no cover - keyring backend errors
+        logger.warning("keyring read failed: %s", exc)
+        secret = None
+    if secret:
+        _VOLATILE_SECRETS[_cache_key(provider, normalized)] = secret
+        return secret
+    return _VOLATILE_SECRETS.get(_cache_key(provider, normalized))
+
+
+def set_secret(provider: Provider, account: str, secret: str) -> None:
+    """Persist ``secret`` for ``provider:account`` in the OS keyring."""
+    normalized = account.strip()
+    if not normalized:
+        raise CredentialError("account is required")
+    _VOLATILE_SECRETS[_cache_key(provider, normalized)] = secret
+    kr = _keyring()
+    try:
+        kr.set_password(SERVICE, _username(provider, normalized), secret)
+    except Exception as exc:
+        raise CredentialError(f"keyring write failed: {exc}") from exc
+
+
+def delete_secret(provider: Provider, account: str) -> None:
+    """Remove the stored secret. No-op if absent."""
+    normalized = account.strip()
+    if normalized:
+        _VOLATILE_SECRETS.pop(_cache_key(provider, normalized), None)
+    kr = _keyring()
+    with contextlib.suppress(Exception):  # pragma: no cover - already gone
+        kr.delete_password(SERVICE, _username(provider, normalized))
+
+
+def get_or_prompt(
+    provider: Provider,
+    account_env: str,
+    secret_env: str,
+    *,
+    account_label: str = "email/org",
+    secret_label: str = "API token",
+    interactive: bool = True,
+) -> tuple[str, str]:
+    """Resolve ``(account, secret)`` from env, then keyring, then prompt.
+
+    Lookup order:
+      1. ``os.environ[account_env]`` + ``os.environ[secret_env]`` - used as-is,
+         and (if both present) persisted to keyring for next time.
+      2. Keyring entry for ``provider`` keyed by the env-var account.
+      3. Interactive prompt (only when ``interactive`` is true). Both values
+         are written to keyring on success.
+
+    Raises :class:`CredentialError` when non-interactive and nothing found.
+    """
+    account = os.environ.get(account_env)
+    secret_from_env = os.environ.get(secret_env)
+
+    if account and secret_from_env:
+        set_secret(provider, account, secret_from_env)
+        return account, secret_from_env
+
+    if account:
+        stored = get_secret(provider, account)
+        if stored:
+            return account, stored
+
+    if not interactive:
+        raise CredentialError(
+            f"missing credentials for {provider}: set {account_env} + {secret_env}"
+            f" or run 'sendsprint login {provider}' once."
+        )
+
+    import typer
+
+    if not account:
+        account = typer.prompt(f"{provider} {account_label}")
+    secret = typer.prompt(f"{provider} {secret_label}", hide_input=True)
+    set_secret(provider, account, secret)
+    typer.echo(f"saved {provider} credentials to keyring (account={account})")
+    return account, secret

sendsprint/delivery/__init__.py

@@ -0,0 +1,20 @@
+"""Delivery layer: worktree isolation, commits, evidence, pull requests.
+
+SendSprint owns this whole layer. simplicio-cli only edits the working tree;
+everything here — branching, committing, capturing evidence, opening the PR and
+driving the review loop — is the agent's job.
+"""
+
+from sendsprint.delivery.evidence import EvidenceCollector
+from sendsprint.delivery.git_ops import GitError, GitOps
+from sendsprint.delivery.pr import PullRequestManager
+from sendsprint.delivery.worktree import WorktreeError, WorktreeManager
+
+__all__ = [
+    "EvidenceCollector",
+    "GitError",
+    "GitOps",
+    "PullRequestManager",
+    "WorktreeError",
+    "WorktreeManager",
+]