doushi-cli 0.1.0__py3-none-any.whl

doushi/__init__.py

@@ -0,0 +1,4 @@
+"""Doushi CLI - Instant Autonomous ML Modeling from your Terminal."""
+
+__version__ = "1.0.0"
+__app_name__ = "doushi"

doushi/client.py

@@ -0,0 +1,255 @@
+"""HTTP API Client for interacting with Doushi.ai backend."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+import httpx
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
+
+from doushi.config import get_api_key, get_api_url
+from doushi.ui import print_error_panel, print_tier_limit_error
+
+# Platform tier dataset upload limits (Bytes, Label, MB)
+TIER_LIMITS: Dict[str, Tuple[int, str, float]] = {
+    "free": (25 * 1024 * 1024, "25 MB", 25.0),
+    "starter": (150 * 1024 * 1024, "150 MB", 150.0),
+    "pro": (2 * 1024 * 1024 * 1024, "2 GB", 2048.0),
+    "growth": (5 * 1024 * 1024 * 1024, "5 GB", 5120.0),
+    "team": (5 * 1024 * 1024 * 1024, "5 GB", 5120.0),
+    "scale": (5 * 1024 * 1024 * 1024, "5 GB", 5120.0),
+    "enterprise": (20 * 1024 * 1024 * 1024, "20 GB", 20480.0),
+}
+
+
+class DoushiAPIError(Exception):
+    """Custom exception for Doushi API errors with status and details."""
+    def __init__(self, message: str, status_code: Optional[int] = None, details: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.details = details or {}
+
+
+ALLOWED_DATASET_EXTENSIONS = {".csv", ".parquet", ".xlsx", ".xls", ".json", ".tsv"}
+
+
+class DoushiClient:
+    """Synchronous HTTP client for Doushi backend."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: Optional[str] = None, timeout: float = 60.0):
+        self.api_key = api_key or get_api_key()
+        self.base_url = (base_url or get_api_url()).rstrip("/")
+        self.timeout = timeout
+
+    def _get_headers(self) -> Dict[str, str]:
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": "doushi-cli/0.1.0",
+        }
+        if self.api_key:
+            headers["x-api-key"] = self.api_key
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+    def _handle_response(self, response: httpx.Response) -> Dict[str, Any]:
+        """Validate response status and return parsed JSON."""
+        try:
+            data = response.json()
+        except Exception:
+            data = {"detail": response.text}
+
+        if response.is_success:
+            return data
+
+        detail = data.get("detail") if isinstance(data, dict) else str(data)
+        if not detail:
+            detail = response.reason_phrase
+
+        if response.status_code == 401:
+            raise DoushiAPIError(
+                message="Authentication failed. Please configure a valid API key with `doushi configure` or `doushi login`.",
+                status_code=401,
+                details=data
+            )
+        elif response.status_code == 403:
+            raise DoushiAPIError(
+                message=f"Access denied: {detail}",
+                status_code=403,
+                details=data
+            )
+        elif response.status_code == 413:
+            raise DoushiAPIError(
+                message=f"Payload limit exceeded: {detail}",
+                status_code=413,
+                details=data
+            )
+        elif response.status_code == 404:
+            raise DoushiAPIError(
+                message=f"Resource not found: {detail}",
+                status_code=404,
+                details=data
+            )
+        else:
+            raise DoushiAPIError(
+                message=f"API Error ({response.status_code}): {detail}",
+                status_code=response.status_code,
+                details=data
+            )
+
+    def check_auth_or_exit(self) -> str:
+        """Ensure API key exists, or display helpful error and exit."""
+        if not self.api_key:
+            print_error_panel(
+                title="Authentication Required",
+                message="No Doushi API Key found. You must configure your credentials before running this command.",
+                remedy="Run `doushi configure` or `doushi login` to set up your API Key,\nor export DOUSHI_API_KEY='dsh_live_...'"
+            )
+            sys.exit(1)
+        return self.api_key
+
+    def get_whoami(self) -> Dict[str, Any]:
+        """Fetch current user and organization details."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.get(f"{self.base_url}/api/users/sync", headers=self._get_headers())
+            return self._handle_response(resp)
+
+    def list_projects(self) -> List[Dict[str, Any]]:
+        """List all projects for current organization."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.get(f"{self.base_url}/api/projects", headers=self._get_headers())
+            data = self._handle_response(resp)
+            if isinstance(data, list):
+                return data
+            return data.get("projects", [])
+
+    def get_project(self, project_id: str) -> Dict[str, Any]:
+        """Fetch details of a single project."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.get(f"{self.base_url}/api/projects/{project_id}", headers=self._get_headers())
+            return self._handle_response(resp)
+
+    def create_project(self, name: str, provider: str = "gemini", api_key_override: Optional[str] = None) -> Dict[str, Any]:
+        """Create a new project record in database."""
+        self.check_auth_or_exit()
+        payload = {
+            "name": name,
+            "llm_provider": provider,
+            "api_key": api_key_override or "default"
+        }
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.post(f"{self.base_url}/api/projects", json=payload, headers=self._get_headers())
+            return self._handle_response(resp)
+
+    def delete_project(self, project_id: str) -> Dict[str, Any]:
+        """Delete a project."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.delete(f"{self.base_url}/api/projects/{project_id}", headers=self._get_headers())
+            return self._handle_response(resp)
+
+    def check_file_limits(self, file_path: Path, tier: str = "free") -> None:
+        """Pre-flight check on dataset size and format against active tier limit."""
+        if not file_path.exists():
+            raise FileNotFoundError(f"Dataset file '{file_path}' does not exist.")
+            
+        file_size_bytes = file_path.stat().st_size
+        if file_size_bytes == 0:
+            raise ValueError(f"Dataset file '{file_path.name}' is empty (0 bytes).")
+
+        ext = file_path.suffix.lower()
+        if ext not in ALLOWED_DATASET_EXTENSIONS:
+            allowed_list = ", ".join(sorted(ALLOWED_DATASET_EXTENSIONS))
+            raise ValueError(
+                f"Unsupported file format '{ext}'. Supported dataset formats: {allowed_list}"
+            )
+
+        normalized_tier = tier.lower()
+        max_bytes, limit_label, max_mb = TIER_LIMITS.get(normalized_tier, TIER_LIMITS["free"])
+        
+        file_size_mb = file_size_bytes / (1024 * 1024)
+        if file_size_bytes > max_bytes:
+            print_tier_limit_error(file_path.name, file_size_mb, normalized_tier, max_mb)
+            sys.exit(1)
+
+    def request_upload_url(self, project_id: str, filename: str, file_size: int) -> Dict[str, Any]:
+        """Request S3 presigned upload URL from backend."""
+        self.check_auth_or_exit()
+        payload = {
+            "project_id": project_id,
+            "filename": filename,
+            "file_size": file_size
+        }
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.post(f"{self.base_url}/api/upload-url", json=payload, headers=self._get_headers())
+            return self._handle_response(resp)
+
+    def upload_file_to_s3(self, presigned_url: str, file_path: Path) -> None:
+        """Upload dataset directly to S3 with live transfer progress bar."""
+        file_size = file_path.stat().st_size
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold cyan]Uploading dataset[/bold cyan] {task.fields[filename]}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+        ) as progress:
+            task_id = progress.add_task("upload", filename=file_path.name, total=file_size)
+            
+            with open(file_path, "rb") as f:
+                content = f.read()
+                
+            headers = {"Content-Type": "application/octet-stream"}
+            with httpx.Client(timeout=120.0) as client:
+                resp = client.put(presigned_url, content=content, headers=headers)
+                if not resp.is_success:
+                    raise DoushiAPIError(
+                        f"Failed to upload dataset to storage: {resp.status_code} {resp.text}",
+                        status_code=resp.status_code
+                    )
+            progress.update(task_id, completed=file_size)
+
+    def start_pipeline(self, project_id: str, prompt: str) -> Dict[str, Any]:
+        """Dispatch autonomous agent training pipeline."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.post(
+                f"{self.base_url}/api/predict-goal",
+                data={"project_id": project_id, "prompt": prompt},
+                headers=self._get_headers()
+            )
+            return self._handle_response(resp)
+
+    def predict(self, project_id: str, data: Any) -> Dict[str, Any]:
+        """Send inference request to project model."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            if isinstance(data, list):
+                # Batch prediction
+                resp = client.post(
+                    f"{self.base_url}/api/projects/{project_id}/predict-batch",
+                    json={"data": data},
+                    headers=self._get_headers()
+                )
+            else:
+                resp = client.post(
+                    f"{self.base_url}/api/projects/{project_id}/predict",
+                    json={"data": data},
+                    headers=self._get_headers()
+                )
+            return self._handle_response(resp)
+
+    def chat(self, project_id: str, message: str) -> Dict[str, Any]:
+        """Send chat message to project agent."""
+        self.check_auth_or_exit()
+        with httpx.Client(timeout=self.timeout) as client:
+            resp = client.post(
+                f"{self.base_url}/api/projects/{project_id}/chat",
+                json={"message": message},
+                headers=self._get_headers()
+            )
+            return self._handle_response(resp)

doushi/commands/__init__.py

@@ -0,0 +1 @@
+"""Doushi CLI Subcommands."""

doushi/commands/auth.py

@@ -0,0 +1,166 @@
+"""Authentication commands for Doushi CLI (configure, login, whoami, logout)."""
+
+import sys
+import webbrowser
+from typing import Optional
+import typer
+from rich.prompt import Prompt
+from rich.panel import Panel
+from rich.table import Table
+
+from doushi.config import (
+    DEFAULT_DASHBOARD_URL,
+    delete_credentials,
+    get_api_key,
+    load_credentials,
+    save_credentials,
+)
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.ui import (
+    console,
+    err_console,
+    print_banner,
+    print_error_panel,
+    print_info,
+    print_json,
+    print_success,
+)
+
+auth_app = typer.Typer(help="Manage authentication and API credentials.")
+
+
+@auth_app.command(name="configure")
+@auth_app.command(name="login")
+def configure(
+    key: Optional[str] = typer.Option(
+        None,
+        "--key",
+        "-k",
+        help="Doushi API Key (dsh_live_...)",
+    ),
+    no_browser: bool = typer.Option(
+        False,
+        "--no-browser",
+        help="Do not automatically open the browser to the API keys page.",
+    ),
+) -> None:
+    """Configure your Doushi API Key to authenticate the CLI."""
+    print_banner()
+    console.print("\n[bold white]Authenticate with Doushi.ai[/bold white]\n")
+
+    api_keys_url = f"{DEFAULT_DASHBOARD_URL}/settings/api-keys"
+
+    if not key:
+        if not no_browser:
+            console.print(f"👉 Opening your browser to generate or copy an API Key:\n   [bold cyan underline]{api_keys_url}[/bold cyan underline]\n")
+            try:
+                webbrowser.open(api_keys_url)
+            except Exception:
+                pass
+        else:
+            console.print(f"👉 Visit your dashboard to generate or copy an API Key:\n   [bold cyan underline]{api_keys_url}[/bold cyan underline]\n")
+
+        key = Prompt.ask(
+            "[bold green]🔑 Paste your Doushi API Key[/bold green] (starts with 'dsh_live_')",
+            password=True,
+        )
+
+    key = key.strip()
+    if not key:
+        print_error_panel(
+            title="Invalid Key",
+            message="No API Key provided. Authentication aborted."
+        )
+        raise typer.Exit(code=1)
+
+    # Validate against backend API
+    with console.status("[bold cyan]Verifying API Key with Doushi.ai...[/bold cyan]"):
+        client = DoushiClient(api_key=key)
+        try:
+            user_data = client.get_whoami()
+        except DoushiAPIError as e:
+            print_error_panel(
+                title="Authentication Failed",
+                message=f"The provided API Key could not be verified: {e.message}",
+                remedy="Double check the key in your dashboard at https://doushi.ai/settings/api-keys"
+            )
+            raise typer.Exit(code=1)
+        except Exception as e:
+            print_error_panel(
+                title="Connection Error",
+                message=f"Could not reach Doushi backend: {str(e)}",
+                remedy="Check your internet connection or backend status."
+            )
+            raise typer.Exit(code=1)
+
+    user_email = user_data.get("email") or user_data.get("id", "Unknown User")
+    org = user_data.get("organization") or {}
+    org_name = org.get("name", "Personal Workspace")
+    tier = str(org.get("tier", "free")).capitalize()
+
+    save_credentials(
+        api_key=key,
+        user_email=user_email,
+        org_name=org_name,
+        tier=tier
+    )
+
+    console.print("\n")
+    print_success("Successfully authenticated with Doushi.ai!")
+    
+    table = Table(show_header=False, border_style="green", box=None)
+    table.add_row("[bold white]User Account:[/bold white]", f"[cyan]{user_email}[/cyan]")
+    table.add_row("[bold white]Organization:[/bold white]", f"[white]{org_name}[/white]")
+    table.add_row("[bold white]Active Plan:[/bold white]", f"[bold yellow]{tier}[/bold yellow]")
+    table.add_row("[bold white]Credentials Saved:[/bold white]", "[dim]~/.doushi/credentials (mode 0600)[/dim]")
+    
+    console.print(Panel(table, title="[bold green]✦ Authentication Active ✦[/bold green]", border_style="green"))
+    console.print("\n[dim]Ready! Run `doushi train <dataset.csv>` or `doushi demo` to start building models.[/dim]\n")
+
+
+@auth_app.command(name="whoami")
+def whoami(
+    json_output: bool = typer.Option(False, "--json", help="Output information as JSON"),
+) -> None:
+    """View active authenticated user, organization, and tier quota."""
+    client = DoushiClient()
+    client.check_auth_or_exit()
+
+    with console.status("[bold cyan]Fetching account details...[/bold cyan]"):
+        try:
+            data = client.get_whoami()
+        except DoushiAPIError as e:
+            print_error_panel("Account Verification Error", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(data)
+        return
+
+    user_email = data.get("email") or data.get("id", "Unknown")
+    org = data.get("organization") or {}
+    org_name = org.get("name", "Personal")
+    tier = str(org.get("tier", "free")).capitalize()
+    
+    projects_count = data.get("projects_count", "-")
+    max_projects = data.get("max_projects", 3 if tier.lower() == "free" else 15 if tier.lower() == "starter" else 100)
+
+    table = Table(title="Doushi.ai Account Information", border_style="cyan")
+    table.add_column("Property", style="bold white")
+    table.add_column("Value", style="cyan")
+
+    table.add_row("User Email", user_email)
+    table.add_row("User ID", str(data.get("id", "-")))
+    table.add_row("Organization", org_name)
+    table.add_row("Plan Tier", f"[bold yellow]{tier}[/bold yellow]")
+    table.add_row("Projects", f"{projects_count} / {max_projects}")
+    table.add_row("API Key Preview", f"...{client.api_key[-8:]}" if client.api_key else "None")
+
+    console.print(table)
+
+
+@auth_app.command(name="logout")
+def logout() -> None:
+    """Log out and remove local credentials."""
+    delete_credentials()
+    print_success("Logged out. Local credentials removed from ~/.doushi/credentials.")

doushi/commands/demo.py

@@ -0,0 +1,79 @@
+"""Demo command providing sample datasets for instant onboarding."""
+
+import tempfile
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.prompt import Prompt
+
+from doushi.commands.train import train
+from doushi.ui import console, print_banner, print_info
+
+demo_app = typer.Typer(help="Spin up instant demo models with bundled datasets.")
+
+SAMPLE_CHURN_CSV = """customer_id,credit_score,country,gender,age,tenure,balance,num_of_products,has_cr_card,is_active_member,estimated_salary,churn
+15634602,619,France,Female,42,2,0.0,1,1,1,101348.88,1
+15647311,608,Spain,Female,41,1,83807.86,1,0,1,112542.58,0
+15619304,502,France,Female,42,8,159660.8,3,1,0,113931.57,1
+15701354,699,France,Female,39,1,0.0,2,0,0,93826.63,0
+15737888,850,Spain,Female,43,2,125510.82,1,1,1,79084.1,0
+15574012,645,Spain,Male,44,8,113755.78,2,1,0,149756.71,1
+15592531,822,France,Male,50,7,0.0,2,1,1,10062.8,0
+15656148,376,Germany,Female,29,4,115046.74,4,1,0,119346.88,1
+15792365,501,France,Male,44,4,142051.07,2,0,1,74940.5,0
+15592389,684,France,Male,27,2,134603.88,1,1,1,71725.73,0
+15767821,528,France,Male,31,6,102016.72,2,0,0,80181.12,0
+15737173,497,Spain,Male,24,3,0.0,2,1,0,76390.01,0
+15632264,476,France,Female,34,10,0.0,2,1,0,26260.98,0
+15691483,549,France,Female,25,5,0.0,0,0,0,190857.79,0
+15600882,635,Spain,Female,35,7,0.0,2,1,1,65951.65,0
+15643966,616,Germany,Male,45,3,143129.41,2,0,1,6432.82,0
+15738191,653,Germany,Male,58,1,132602.88,1,1,0,5097.67,1
+15788295,549,Spain,Female,24,9,0.0,2,1,1,14408.85,0
+15661507,587,Spain,Male,45,6,0.0,1,0,0,158684.81,0
+15594720,678,France,Female,60,10,0.0,2,0,1,180749.43,0
+15577657,732,France,Male,41,8,0.0,2,1,1,170886.17,0
+15597945,636,Spain,Female,32,8,0.0,2,1,0,138555.46,0
+15699309,510,Spain,Female,38,4,0.0,1,1,0,118913.53,1
+15579769,669,France,Male,46,3,0.0,2,0,1,8487.75,0
+15625047,846,France,Female,38,5,0.0,1,1,1,187616.16,0
+15738198,577,France,Female,25,3,0.0,2,0,1,124508.29,0
+15736816,756,Germany,Male,36,2,136815.6,1,1,0,170041.95,0
+15700772,570,France,Female,44,9,0.0,1,1,1,40410.42,0
+15728693,574,Germany,Female,43,3,141349.43,1,0,1,100187.43,0
+15733883,411,France,Male,29,0,59697.17,2,1,1,53483.21,0
+"""
+
+
+@demo_app.command(name="demo")
+def run_demo(
+    save_local: bool = typer.Option(
+        False,
+        "--save-local",
+        help="Save demo CSV to current working directory as 'sample_customer_churn.csv'",
+    ),
+) -> None:
+    """Run an instant autonomous ML training demo using a sample customer churn dataset."""
+    print_banner()
+    console.print("\n[bold white]🚀 Doushi Instant 30-Second Demo[/bold white]\n")
+    print_info("Creating temporary sample dataset: Customer Churn (30 records, 12 features)...")
+
+    if save_local:
+        demo_file = Path("./sample_customer_churn.csv")
+    else:
+        temp_dir = tempfile.mkdtemp()
+        demo_file = Path(temp_dir) / "sample_customer_churn.csv"
+
+    with open(demo_file, "w", encoding="utf-8") as f:
+        f.write(SAMPLE_CHURN_CSV.strip())
+
+    console.print(f"[dim]Dataset written to {demo_file}[/dim]\n")
+
+    # Delegate to train command
+    train(
+        dataset_file=demo_file,
+        goal="Predict if a banking customer will churn based on credit score, age, and balance",
+        name="Demo Customer Churn Predictor",
+        follow=True,
+        json_output=False,
+    )

doushi/commands/export.py

@@ -0,0 +1,76 @@
+"""Export command for Doushi CLI (export)."""
+
+import json
+from pathlib import Path
+import typer
+
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.templates import (
+    DOCKERFILE_TEMPLATE,
+    FASTAPI_SERVE_TEMPLATE,
+    REQUIREMENTS_TXT_TEMPLATE,
+    generate_export_readme,
+)
+from doushi.ui import (
+    console,
+    print_error_panel,
+    print_success,
+)
+
+export_app = typer.Typer(help="Export model artifacts and standalone Python serving code.")
+
+
+@export_app.command(name="export")
+def export_model(
+    project_id: str = typer.Argument(..., help="Unique ID of the project to export"),
+    out_dir: Path = typer.Option(
+        Path("./doushi-model-bundle"),
+        "--out",
+        "-o",
+        help="Directory where export artifacts will be saved",
+    ),
+) -> None:
+    """Download project code, metadata, Dockerfile, and FastAPI microservice."""
+    client = DoushiClient()
+    client.check_auth_or_exit()
+
+    with console.status(f"[bold cyan]Exporting project {project_id}...[/bold cyan]"):
+        try:
+            p = client.get_project(project_id)
+        except DoushiAPIError as e:
+            print_error_panel("Export Failed", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    project_name = p.get("name", "Doushi Project")
+
+    # 1. Metadata and training pipeline
+    with open(out_dir / "metadata.json", "w", encoding="utf-8") as f:
+        json.dump(p, f, indent=2, default=str)
+
+    code_content = p.get("generated_code") or p.get("code") or "# Training pipeline code generated by Doushi\n"
+    with open(out_dir / "pipeline.py", "w", encoding="utf-8") as f:
+        f.write(code_content)
+
+    # 2. Serving microservice & deployment files
+    with open(out_dir / "serve.py", "w", encoding="utf-8") as f:
+        f.write(FASTAPI_SERVE_TEMPLATE)
+
+    with open(out_dir / "Dockerfile", "w", encoding="utf-8") as f:
+        f.write(DOCKERFILE_TEMPLATE)
+
+    with open(out_dir / "requirements.txt", "w", encoding="utf-8") as f:
+        f.write(REQUIREMENTS_TXT_TEMPLATE)
+
+    # 3. Local deployment README
+    with open(out_dir / "README.md", "w", encoding="utf-8") as f:
+        f.write(generate_export_readme(project_id=project_id, project_name=project_name))
+
+    console.print("\n")
+    print_success(f"Project exported successfully to [bold cyan]{out_dir}[/bold cyan]!")
+    console.print("\n[dim]Files created:[/dim]")
+    console.print(f"  ├── {out_dir}/pipeline.py")
+    console.print(f"  ├── {out_dir}/serve.py")
+    console.print(f"  ├── {out_dir}/Dockerfile")
+    console.print(f"  ├── {out_dir}/requirements.txt")
+    console.print(f"  └── {out_dir}/metadata.json\n")

doushi/commands/logs.py

@@ -0,0 +1,85 @@
+"""Log streaming and inspection commands for Doushi CLI (logs)."""
+
+import time
+from typing import Optional
+import typer
+from rich.panel import Panel
+
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.ui import (
+    console,
+    err_console,
+    print_error_panel,
+    print_info,
+    print_json,
+)
+
+logs_app = typer.Typer(help="Stream and inspect agent execution and self-healing logs.")
+
+
+@logs_app.command(name="logs")
+def logs(
+    project_id: str = typer.Argument(..., help="Unique ID of the project"),
+    follow: bool = typer.Option(
+        False,
+        "--follow",
+        "-f",
+        help="Continuously stream new logs until execution finishes",
+    ),
+    raw: bool = typer.Option(
+        False,
+        "--raw",
+        help="Print raw unformatted logs",
+    ),
+) -> None:
+    """View training agent logs, sandbox execution, and self-healing tracebacks."""
+    client = DoushiClient()
+    client.check_auth_or_exit()
+
+    last_logs = ""
+
+    while True:
+        try:
+            p = client.get_project(project_id)
+        except DoushiAPIError as e:
+            print_error_panel("Failed to Fetch Logs", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+        project_logs = p.get("logs") or ""
+        error = p.get("error")
+        status = str(p.get("status", "pending")).lower()
+
+        if project_logs and project_logs != last_logs:
+            # Print only new log lines if following
+            if last_logs and project_logs.startswith(last_logs):
+                new_part = project_logs[len(last_logs):]
+            else:
+                new_part = project_logs
+
+            if raw:
+                print(new_part, end="")
+            else:
+                for line in new_part.splitlines():
+                    if "ERROR" in line or "Traceback" in line or "Exception" in line:
+                        console.print(f"[bold red]{line}[/bold red]")
+                    elif "WARNING" in line:
+                        console.print(f"[bold yellow]{line}[/bold yellow]")
+                    elif "INFO" in line or "Success" in line:
+                        console.print(f"[bold green]{line}[/bold green]")
+                    else:
+                        console.print(f"[dim]{line}[/dim]")
+
+            last_logs = project_logs
+
+        if not follow:
+            if not project_logs:
+                console.print(f"[dim]No logs available yet for project {project_id}. Status: {status}[/dim]")
+            if error:
+                print_error_panel("Project Error", str(error))
+            break
+
+        if status in ["success", "failed"]:
+            console.print(f"\n[bold]Execution finished with status: [/bold]{status.upper()}")
+            break
+
+        time.sleep(3)