sourcerykit 1.0.0b1__py3-none-any.whl

sourcerykit/__init__.py

@@ -0,0 +1,31 @@
+from sourcerykit.bootstrap import bootstrap_system
+from sourcerykit.errors import (
+    SourceryKitBootstrapError,
+    SourceryKitConfigError,
+    SourceryKitError,
+    SourceryKitStorageError,
+    SourceryKitTrustError,
+)
+from sourcerykit.evaluator import evaluate_handoff
+from sourcerykit.handoff import build_handoff_payload
+from sourcerykit.intercept import async_intercept_context, take_last_intercept_row_id
+from sourcerykit.schemas import SourceryKitAgentResponse, VerificationMode
+from sourcerykit.trusted_endpoints import insert_trusted_endpoint
+
+__all__ = [
+    "bootstrap_system",
+    "evaluate_handoff",
+    "build_handoff_payload",
+    "async_intercept_context",
+    "take_last_intercept_row_id",
+    "insert_trusted_endpoint",
+    # Types
+    "VerificationMode",
+    "SourceryKitAgentResponse",
+    # Exceptions
+    "SourceryKitError",
+    "SourceryKitConfigError",
+    "SourceryKitBootstrapError",
+    "SourceryKitStorageError",
+    "SourceryKitTrustError",
+]

sourcerykit/bootstrap/__init__.py

@@ -0,0 +1,3 @@
+from sourcerykit.bootstrap.bootstrap import bootstrap_system
+
+__all__ = ["bootstrap_system"]

sourcerykit/bootstrap/_cache.py

@@ -0,0 +1,118 @@
+"""Provably bootstrap: middleware + database + collection + integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from uuid import UUID
+
+from sourcerykit.config import Settings
+from sourcerykit.db._engine import ConnectionInfo, get_connection_info
+from sourcerykit.errors import SourceryKitBootstrapError, SourceryKitError
+from sourcerykit.logger import get_logger
+from sourcerykit.provably._errors import ProvablyError
+from sourcerykit.provably.service import service
+
+_log = get_logger(__name__)
+
+
+@dataclass
+class ProvablyBootstrapCache:
+    """Holds the resolved Provably resource IDs cached for the process lifetime."""
+
+    middleware_id: UUID | None = field(default=None)
+    database_id: UUID | None = field(default=None)
+    schema_id: UUID | None = field(default=None)
+    table_id: UUID | None = field(default=None)
+    collection_id: UUID | None = field(default=None)
+    integration_key: str | None = field(default=None)
+    collection_name: str | None = field(default=None)
+
+    def load_from(self, settings: Settings) -> None:
+        """Populate cache from pre-resolved settings."""
+        self.middleware_id = settings.middleware_id
+        self.database_id = settings.database_id
+        self.schema_id = settings.schema_id
+        self.table_id = settings.table_id
+        self.collection_id = settings.collection_id
+        self.integration_key = settings.integration_key
+        self.collection_name = settings.project_name or None
+
+    async def run_handshake(self, project_name: str) -> None:
+        """Resolve or create all required Provably resources."""
+        try:
+            self.middleware_id = await self._resolve_middleware()
+
+            connection_info = get_connection_info()
+            self.database_id = await self._resolve_database(connection_info)
+
+            ids = await service.get_database_schema_id_and_table_id(self.middleware_id, connection_info)
+            self.schema_id = ids["schema_id"]
+            self.table_id = ids["table_id"]
+
+            self.collection_name = project_name
+            self.collection_id = await self._resolve_collection(project_name)
+            self.integration_key = await self._resolve_integration_key()
+        except SourceryKitError:
+            raise
+        except Exception as e:
+            _log.error("handshake_failed_unexpected", error=str(e))
+            raise SourceryKitBootstrapError("Unexpected error during Provably handshake") from e
+
+    async def _resolve_middleware(self) -> UUID:
+        try:
+            return await service.get_middleware_id()
+        except ProvablyError:
+            _log.info("middleware_not_found_creating_new")
+            try:
+                return await service.create_middleware()
+            except Exception as e:
+                _log.error("middleware_creation_failed", error=str(e))
+                raise
+
+    async def _resolve_database(self, database: ConnectionInfo) -> UUID:
+        if self.middleware_id is None:
+            raise SourceryKitBootstrapError("middleware_id is not set; run_handshake() must be called first")
+        try:
+            return await service.get_database_id(self.middleware_id, database)
+        except ProvablyError:
+            _log.info("database_not_found_creating_new")
+            try:
+                return await service.create_database(self.middleware_id, database)
+            except Exception as e:
+                _log.error("database_creation_failed", error=str(e))
+                raise
+
+    async def _resolve_collection(self, project_name: str) -> UUID:
+        if self.middleware_id is None or self.database_id is None or self.schema_id is None or self.table_id is None:
+            raise SourceryKitBootstrapError(
+                "middleware_id, database_id, schema_id, and table_id must all be resolved before creating a collection"
+            )
+        try:
+            return await service.get_collection_id(name=project_name)
+        except (ProvablyError, ValueError):
+            _log.info("collection_not_found_creating_new")
+            try:
+                columns = await service.get_columns_from_database(
+                    self.middleware_id, self.database_id, self.schema_id, self.table_id
+                )
+                return await service.create_collection(
+                    self.middleware_id,
+                    self.database_id,
+                    self.schema_id,
+                    self.table_id,
+                    columns,
+                    name=project_name,
+                )
+            except Exception as e:
+                _log.error("collection_creation_failed", error=str(e))
+                raise
+
+    async def _resolve_integration_key(self) -> str:
+        if self.collection_id is None:
+            raise SourceryKitBootstrapError("collection_id is not set; _resolve_collection() must succeed first")
+        _, key = await service.create_integration(self.collection_id)
+        return key
+
+
+# Module-level singleton.
+_BOOTSTRAP_INSTANCE = ProvablyBootstrapCache()

sourcerykit/bootstrap/bootstrap.py

@@ -0,0 +1,46 @@
+from sourcerykit.bootstrap._cache import _BOOTSTRAP_INSTANCE, ProvablyBootstrapCache
+from sourcerykit.config import get_settings
+from sourcerykit.db._engine import get_engine
+from sourcerykit.db._schema import ensure_schema
+from sourcerykit.errors import (
+    SourceryKitConfigError,
+    SourceryKitStorageError,
+)
+from sourcerykit.intercept.interceptor import init_interceptor
+from sourcerykit.logger import get_logger
+
+_log = get_logger(__name__)
+
+
+async def bootstrap_system() -> None:
+    """System entry point called exactly once during container/server startup."""
+    _log.info("system_bootstrap_started")
+
+    # Validate configuration
+    settings = get_settings()
+
+    if not settings.postgres_url:
+        raise SourceryKitConfigError("SOURCERYKIT_POSTGRES_URL is required. Run 'sourcerykit init' first.")
+
+    # Initialize database schemas
+    try:
+        await ensure_schema(get_engine())
+    except Exception as e:
+        _log.error("bootstrap_db_schema_failed", error=str(e))
+        raise SourceryKitStorageError("Failed to create database schema during bootstrap") from e
+
+    # Populate from cached settings or run handshake
+    if settings.has_bootstrap_ids:
+        _log.info("bootstrap_using_cached_ids")
+        _BOOTSTRAP_INSTANCE.load_from(settings)
+    else:
+        _log.info("bootstrap_running_handshake")
+        await _BOOTSTRAP_INSTANCE.run_handshake(project_name=settings.project_name)
+
+    init_interceptor()
+    _log.info("system_bootstrap_completed")
+
+
+def get_bootstrap() -> ProvablyBootstrapCache:
+    """Synchronous gateway to access resolved IDs."""
+    return _BOOTSTRAP_INSTANCE

sourcerykit/cli/config.py

@@ -0,0 +1,136 @@
+import re
+
+import questionary
+import typer
+
+from sourcerykit.cli.init import clear_auth_caches, create_db_tables, run_provably_handshake, save_bootstrap_ids
+from sourcerykit.cli.utils import (
+    console,
+    mask_postgres_url,
+    mask_secret,
+    prompt_postgres_url_with_retry,
+    prompt_project_name,
+    require_settings,
+)
+from sourcerykit.config import get_settings, load_local_env, save_app_dir_config, save_local_env
+
+config = typer.Typer(no_args_is_help=True)
+
+
+@config.command()
+def list(show_key: bool = typer.Option(False, "--show-key", help="show secrets in clear text")) -> None:
+    """Pretty print the active configuration (global + local)."""
+    settings = require_settings()
+
+    api_key_display = settings.api_key if show_key else mask_secret(settings.api_key)
+    console.print("\n📋 [bold]Global Config[/bold] \n")
+    console.print(f"[cyan]PROVABLY_API_KEY[/cyan]       = [yellow]'{api_key_display}'[/yellow]")
+
+    pg_display = settings.postgres_url if show_key else mask_postgres_url(settings.postgres_url)
+
+    console.print("\n📋 [bold]Local Config[/bold] (.env)\n")
+    console.print(f"[cyan]SOURCERYKIT_POSTGRES_URL[/cyan]  = [yellow]'{pg_display}'[/yellow]")
+    console.print(f"[cyan]SOURCERYKIT_PROJECT_NAME[/cyan]  = [yellow]'{settings.project_name}'[/yellow]")
+
+    console.print()
+
+
+@config.command()
+def set() -> None:
+    """Interactively set or update configuration variables."""
+    console.print("\n⚙️  [bold]SourceryKit Configuration Setup[/bold]\n")
+
+    choices = questionary.checkbox(
+        "Which configuration variables would you like to update?",
+        choices=[
+            questionary.Choice("PROVABLY_API_KEY (global)", checked=False),
+            questionary.Choice("SOURCERYKIT_POSTGRES_URL (local)", checked=False),
+            questionary.Choice("SOURCERYKIT_PROJECT_NAME (local)", checked=False),
+        ],
+    ).ask()
+
+    if not choices:
+        console.print("[yellow]No variables selected. Configuration unchanged.[/yellow]")
+        return
+
+    # --- Collect inputs ---
+
+    api_key = None
+    if "PROVABLY_API_KEY (global)" in choices:
+        api_key = questionary.password("Enter your PROVABLY_API_KEY:").ask()
+        if api_key is not None:
+            api_key = api_key.strip()
+            if not api_key:
+                console.print("[red]❌ API key cannot be empty.[/red]")
+                api_key = None
+            elif not re.fullmatch(r"zk-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", api_key):
+                console.print("[red]❌ API key must match format zk-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx[/red]")
+                api_key = None
+
+    postgres_url = None
+    postgres_changed = False
+    if "SOURCERYKIT_POSTGRES_URL (local)" in choices:
+        local_env = load_local_env()
+        current_url = local_env.get("SOURCERYKIT_POSTGRES_URL", "")
+        result = prompt_postgres_url_with_retry()
+        if result and result != current_url:
+            postgres_url = result
+            postgres_changed = True
+        elif result == current_url:
+            console.print("[yellow]Same URL — no change.[/yellow]")
+
+    project_name = None
+    project_changed = False
+    if "SOURCERYKIT_PROJECT_NAME (local)" in choices:
+        local_env = load_local_env()
+        current_name = local_env.get("SOURCERYKIT_PROJECT_NAME", "")
+        result = prompt_project_name(current=current_name)
+        if result and result != current_name:
+            project_name = result
+            project_changed = True
+        elif result == current_name:
+            console.print("[yellow]Same name — no change.[/yellow]")
+
+    # --- Save config ---
+
+    if api_key:
+        save_app_dir_config(api_key=api_key)
+
+    local_updates: dict[str, str] = {}
+    if postgres_url:
+        local_updates["SOURCERYKIT_POSTGRES_URL"] = postgres_url
+    if project_name:
+        local_updates["SOURCERYKIT_PROJECT_NAME"] = project_name
+    if local_updates:
+        save_local_env(**local_updates)
+
+    # --- Re-bootstrap if needed ---
+
+    if postgres_changed or project_changed:
+        settings = get_settings()
+        name = settings.project_name
+
+        clear_auth_caches()
+
+        if postgres_changed:
+            console.print("\n🔧 [bold]Re-bootstrapping (DB + Provably)...[/bold]")
+            try:
+                create_db_tables()
+                console.print("  ✅ Database tables created")
+            except Exception as e:
+                console.print(f"  [red]❌ DB tables failed: {e}[/red]")
+                return
+        else:
+            console.print("\n🔧 [bold]Re-running Provably handshake (new collection name)...[/bold]")
+
+        try:
+            run_provably_handshake(name)
+            console.print("  ✅ Provably handshake completed")
+        except Exception as e:
+            console.print(f"  [red]❌ Handshake failed: {e}[/red]")
+            return
+
+        save_bootstrap_ids()
+        console.print("  ✅ Bootstrap IDs saved\n")
+
+    console.print("[bold green]✨ Configuration updated.[/bold green]")

sourcerykit/cli/doctor.py

@@ -0,0 +1,184 @@
+"""Doctor command — validate configuration and connectivity."""
+
+import asyncio
+import dataclasses
+from collections.abc import Callable
+
+from sourcerykit.cli.init import run_full_bootstrap
+from sourcerykit.cli.utils import console, run_connectivity_check
+from sourcerykit.config import Settings, get_settings
+from sourcerykit.db._engine import get_connection_info
+from sourcerykit.provably._errors import ProvablyConnectionError, ProvablyUnauthorizedError
+from sourcerykit.provably.auth_service import auth_service
+from sourcerykit.provably.service import service
+
+
+def _check_api_key_and_org(settings: Settings) -> tuple[bool, str]:
+    """Validate API key and org_id in one call (list_organizations uses API key)."""
+    if not settings.api_key:
+        return False, "PROVABLY_API_KEY is missing — run 'sourcerykit init'"
+
+    try:
+        orgs = asyncio.run(auth_service.list_organizations())
+    except ProvablyUnauthorizedError:
+        return False, "API key is invalid or expired — run 'sourcerykit init'"
+    except ProvablyConnectionError:
+        return False, "Cannot reach Provably API (network error)"
+    except Exception as e:
+        return False, f"API key check failed: {e}"
+
+    org_ids = [str(o.get("id", "")) for o in orgs]
+    if str(settings.org_id) not in org_ids:
+        return False, f"Org ID {settings.org_id} not found — run 'sourcerykit init'"
+
+    return True, f"API key valid, org found ({len(orgs)} org(s))"
+
+
+def _check_postgres(settings: Settings) -> tuple[bool, str]:
+    """Validate postgres_url connectivity."""
+    if not settings.postgres_url:
+        return False, "SOURCERYKIT_POSTGRES_URL is missing — run 'sourcerykit init'"
+
+    if run_connectivity_check(settings.postgres_url, quiet=True):
+        return True, "PostgreSQL connection successful"
+    return False, "PostgreSQL connection failed — check your SOURCERYKIT_POSTGRES_URL"
+
+
+def _check_project_name(settings: Settings) -> tuple[bool, str]:
+    """Validate project_name is set."""
+    if settings.project_name:
+        return True, f"'{settings.project_name}'"
+    return False, "SOURCERYKIT_PROJECT_NAME is missing — run 'sourcerykit init'"
+
+
+def _check_bootstrap_ids(settings: Settings) -> tuple[bool, str]:
+    """Validate all bootstrap resource IDs are present."""
+    if settings.has_bootstrap_ids:
+        return True, "All bootstrap IDs present"
+
+    missing = [
+        f.name
+        for f in dataclasses.fields(settings)
+        if (f.name.endswith("_id") or f.name == "integration_key") and not getattr(settings, f.name)
+    ]
+    return False, f"Missing: {', '.join(missing)} — run 'sourcerykit doctor --fix'"
+
+
+# --- Deep checks — verify IDs exist in Provably backend ---
+async def _deep_check_collection_and_ids(settings: Settings) -> tuple[bool, str]:
+    """Verify Provably resources match local config using the same calls as bootstrap."""
+    if not settings.has_bootstrap_ids or settings.middleware_id is None:
+        return False, "Bootstrap IDs missing — run 'sourcerykit doctor --fix'"
+
+    remote_mw = await service.get_middleware_id()
+    if remote_mw != settings.middleware_id:
+        return False, f"Middleware mismatch (local={settings.middleware_id}, remote={remote_mw})"
+
+    connection_info = get_connection_info()
+    remote_db = await service.get_database_id(settings.middleware_id, connection_info)
+    if remote_db != settings.database_id:
+        return False, f"Database mismatch (local={settings.database_id}, remote={remote_db})"
+
+    ids = await service.get_database_schema_id_and_table_id(settings.middleware_id, connection_info)
+    if ids["schema_id"] != settings.schema_id:
+        return False, f"Schema mismatch (local={settings.schema_id}, remote={ids['schema_id']})"
+    if ids["table_id"] != settings.table_id:
+        return False, f"Table mismatch (local={settings.table_id}, remote={ids['table_id']})"
+
+    remote_col = await service.get_collection_id(settings.project_name)
+    if remote_col != settings.collection_id:
+        return False, f"Collection mismatch (local={settings.collection_id}, remote={remote_col})"
+
+    return True, f"Collection '{settings.project_name}' verified (middleware, db, schema, table, collection)"
+
+
+async def _deep_check_integration(settings: Settings) -> tuple[bool, str]:
+    """Verify integration_key has the expected format (API key, not UUID)."""
+    if not settings.integration_key:
+        return False, "SOURCERYKIT_INTEGRATION_KEY is missing — run 'sourcerykit doctor --fix'"
+
+    if not settings.integration_key.startswith("i-"):
+        return False, f"SOURCERYKIT_INTEGRATION_KEY has unexpected format: {settings.integration_key!r}"
+
+    return True, "Integration key format valid"
+
+
+def _run_deep_check_collection_and_ids(settings: Settings) -> tuple[bool, str]:
+    try:
+        return asyncio.run(_deep_check_collection_and_ids(settings))
+    except ProvablyUnauthorizedError:
+        return False, "API key expired — run 'sourcerykit init'"
+    except ProvablyConnectionError:
+        return False, "Cannot reach Provably API (network error)"
+    except Exception as e:
+        return False, f"Collection check failed: {e}"
+
+
+def _run_deep_check_integration(settings: Settings) -> tuple[bool, str]:
+    try:
+        return asyncio.run(_deep_check_integration(settings))
+    except ProvablyUnauthorizedError:
+        return False, "API key expired — run 'sourcerykit init'"
+    except ProvablyConnectionError:
+        return False, "Cannot reach Provably API (network error)"
+    except Exception as e:
+        return False, f"Integration check failed: {e}"
+
+
+def run_doctor(fix: bool = False) -> None:
+    """Validate global config, local config, and connectivity."""
+    console.print("\n🩺 [bold]SourceryKit Doctor[/bold]\n")
+
+    try:
+        settings = get_settings()
+    except Exception as e:
+        console.print(f"[red]❌ Cannot load settings: {e}[/red]")
+        console.print("\n[bold yellow]Run 'sourcerykit init' to configure[/bold yellow]\n")
+        return
+
+    checks: list[tuple[str, Callable[[], tuple[bool, str]]]] = [
+        ("API key + org", lambda: _check_api_key_and_org(settings)),
+        ("PostgreSQL", lambda: _check_postgres(settings)),
+        ("Project name", lambda: _check_project_name(settings)),
+        ("Bootstrap IDs", lambda: _check_bootstrap_ids(settings)),
+        ("Collection + IDs", lambda: _run_deep_check_collection_and_ids(settings)),
+        ("Integration", lambda: _run_deep_check_integration(settings)),
+    ]
+
+    passed = 0
+    total = len(checks)
+    failed_indices: list[int] = []
+
+    for i, (label, check_fn) in enumerate(checks):
+        ok, detail = check_fn()
+        icon = "[green]✅[/green]" if ok else "[red]❌[/red]"
+        console.print(f"  {icon} {label}: {detail}")
+        if ok:
+            passed += 1
+        else:
+            failed_indices.append(i)
+
+    # --fix: attempt to create missing bootstrap IDs
+    if fix and failed_indices:
+        console.print("\n  🔧 [bold]Running bootstrap handshake...[/bold]", end=" ")
+        try:
+            if run_full_bootstrap(settings.project_name):
+                console.print("[green]DONE ✅[/green]")
+                get_settings.cache_clear()
+                settings = get_settings()
+                for i in failed_indices:
+                    label, check_fn = checks[i]
+                    ok, detail = check_fn()
+                    icon = "[green]✅[/green]" if ok else "[red]❌[/red]"
+                    console.print(f"  {icon} {label}: {detail}")
+                    if ok:
+                        passed += 1
+            else:
+                console.print("[red]FAILED ❌[/red]")
+        except Exception as e:
+            console.print(f"[red]FAILED ❌[/red]\n   {e}")
+
+    if passed == total:
+        console.print(f"\n[bold green]All {total} checks passed![/bold green]\n")
+    else:
+        console.print(f"\n[bold yellow]{passed}/{total} checks passed — run 'sourcerykit init' to fix[/bold yellow]\n")

sourcerykit/cli/endpoints.py

@@ -0,0 +1,56 @@
+import asyncio
+
+import questionary
+import typer
+from rich.table import Table
+
+from sourcerykit.cli.utils import console, require_settings
+from sourcerykit.errors import SourceryKitTrustError
+from sourcerykit.trusted_endpoints import service
+from sourcerykit.trusted_endpoints.service import sanitize_and_extract_trusted_url
+
+endpoints = typer.Typer(no_args_is_help=True)
+
+
+@endpoints.command()
+def add(url: str, label: str | None = typer.Option(None, "--label", "-l", help="optional display label")) -> None:
+    require_settings()
+    try:
+        sanitize_and_extract_trusted_url(url)
+    except SourceryKitTrustError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(code=1)
+    asyncio.run(service.insert_trusted_endpoint(url=url, display_label=label))
+    console.print(f"[bold green]✅ Endpoint added:[/bold green] {url}" + (f" ({label})" if label else ""))
+
+
+@endpoints.command()
+def list() -> None:
+    require_settings()
+    rows = asyncio.run(service.list_all_trusted_endpoints_detailed())
+
+    if not rows:
+        console.print("[yellow]No trusted endpoints found.[/yellow]")
+        return
+
+    table = Table(title="Trusted Endpoints")
+    table.add_column("URL", style="cyan")
+    table.add_column("Label", style="white")
+    table.add_column("Policy", style="dim")
+    table.add_column("Created by", style="dim")
+
+    for ep in rows:
+        table.add_row(ep["url"], ep["label"], ep["policy_version"], ep["created_by"])
+
+    console.print(table)
+
+
+@endpoints.command()
+def remove(url: str) -> None:
+    require_settings()
+    confirm = questionary.confirm(f"Remove endpoint '{url}'?", default=False).ask()
+    if not confirm:
+        console.print("[yellow]Cancelled.[/yellow]")
+        return
+    asyncio.run(service.remove_trusted_endpoint(url=url))
+    console.print(f"[bold green]✅ Endpoint removed:[/bold green] {url}")

sourcerykit/cli/feedback.py

@@ -0,0 +1,57 @@
+import asyncio
+from pathlib import Path
+
+import questionary
+import typer
+
+from sourcerykit.cli.utils import console, require_settings
+from sourcerykit.provably.service import ProvablyService
+
+service = ProvablyService()
+
+
+def send_feedback() -> None:
+    """Submit interactive feedback or bug reports."""
+    require_settings()
+    console.print("\n📣 [bold]Send Feedback to SourceryKit[/bold]\n")
+
+    # read description
+    description = questionary.text("Please provide a description of your feedback/issue:", multiline=True).ask()
+
+    if not description or not description.strip():
+        console.print("[yellow]⚠️  Feedback description cannot be empty. Aborting.[/yellow]")
+        raise typer.Exit(code=1)
+
+    # read file
+    attach_file = questionary.confirm(
+        "Would you like to attach a file (e.g., a log or screenshot)?", default=False
+    ).ask()
+
+    file_bytes = b""
+    if attach_file:
+        file_path_str = questionary.text("Enter the path to the file you want to attach:").ask()
+
+        if file_path_str:
+            path = Path(file_path_str.strip()).expanduser().resolve()
+
+            if not path.exists() or not path.is_file():
+                console.print(f"[red]❌ Error: File not found at '{path}'[/red]")
+                raise typer.Exit(code=1)
+
+            try:
+                # Read the file directly into raw bytes
+                file_bytes = path.read_bytes()
+                console.print(f"[green]✓ Attached '{path.name}' ({len(file_bytes)} bytes)[/green]")
+            except PermissionError:
+                console.print(f"[red]❌ Permission denied when reading '{path}'[/red]")
+                raise typer.Exit(code=1)
+
+    console.print("\n🚀 Sending feedback...")
+
+    # send feedback
+    try:
+        asyncio.run(service.create_feedback(description.strip(), file_bytes))
+        console.print("\n✨ [bold green]Success![/bold green] Thank you for your feedback.")
+    except Exception as e:
+        console.print(f"\n[red]❌ Failed to submit feedback: {e}[/red]")
+        raise typer.Exit(code=1)