doushi-cli 0.1.0__py3-none-any.whl

doushi/commands/predict.py

@@ -0,0 +1,226 @@
+"""Prediction and inference command for Doushi CLI (predict)."""
+
+import csv
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import typer
+from rich.table import Table
+
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.ui import (
+    console,
+    err_console,
+    print_error_panel,
+    print_json,
+    print_success,
+)
+
+predict_app = typer.Typer(help="Run live inference on trained Doushi AI models.")
+
+
+def load_batch_file(file_path: Path) -> List[Dict[str, Any]]:
+    """Load sample records from various file formats (.json, .parquet, .xls, .xlsx, .csv, .tsv)."""
+    ext = file_path.suffix.lower()
+
+    # 1. JSON
+    if ext == ".json":
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if isinstance(data, list):
+                return data
+            elif isinstance(data, dict):
+                return [data]
+            raise ValueError("JSON file must contain an array of sample objects or a single sample object.")
+
+    # 2. Parquet
+    elif ext == ".parquet":
+        try:
+            import pandas as pd
+            df = pd.read_parquet(file_path)
+            return df.to_dict(orient="records")
+        except ImportError:
+            try:
+                import pyarrow.parquet as pq
+                table = pq.read_table(file_path)
+                return table.to_pylist()
+            except ImportError:
+                raise ImportError(
+                    "To read .parquet files, please install pandas or pyarrow: pip install pandas pyarrow"
+                )
+
+    # 3. Excel (.xls, .xlsx)
+    elif ext in [".xls", ".xlsx"]:
+        try:
+            import pandas as pd
+            df = pd.read_excel(file_path)
+            return df.to_dict(orient="records")
+        except ImportError:
+            raise ImportError(
+                "To read Excel files (.xls, .xlsx), please install pandas and openpyxl: pip install pandas openpyxl"
+            )
+
+    # 4. Delimited Text (CSV, TSV, TXT)
+    else:
+        delimiter = "\t" if ext == ".tsv" else ","
+        samples: List[Dict[str, Any]] = []
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            sample_header = f.read(2048)
+            f.seek(0)
+            if ext != ".tsv" and ";" in sample_header and "," not in sample_header:
+                delimiter = ";"
+            
+            reader = csv.DictReader(f, delimiter=delimiter)
+            for row in reader:
+                parsed_row = {}
+                for k, v in row.items():
+                    if v is None or v == "":
+                        parsed_row[k] = None
+                    else:
+                        try:
+                            parsed_row[k] = float(v) if "." in v else int(v)
+                        except ValueError:
+                            parsed_row[k] = v
+                samples.append(parsed_row)
+        return samples
+
+
+@predict_app.command(name="predict")
+def predict(
+    project_id: str = typer.Argument(..., help="Unique ID of the trained project"),
+    data: Optional[str] = typer.Option(
+        None,
+        "--data",
+        "-d",
+        help="JSON string of feature inputs (e.g. '{\"age\": 30, \"tenure\": 12}')",
+    ),
+    file_path: Optional[Path] = typer.Option(
+        None,
+        "--file",
+        "-f",
+        help="Path to CSV, JSON, Parquet, or Excel file containing batch samples for inference",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+    ),
+    output: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Path to save prediction outputs (.csv or .json)",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output predictions as raw JSON",
+    ),
+) -> None:
+    """Run live prediction using inline JSON, a CSV/JSON/Parquet/Excel file, or piped stdin."""
+    client = DoushiClient()
+    client.check_auth_or_exit()
+
+    payload_data = None
+
+    # 1. Check direct CLI JSON argument
+    if data:
+        try:
+            payload_data = json.loads(data)
+        except json.JSONDecodeError:
+            print_error_panel(
+                "Invalid JSON",
+                f"Could not parse --data as valid JSON: {data}",
+                remedy="Ensure proper quoting: --data '{\"feature_1\": 10, \"feature_2\": 20}'"
+            )
+            raise typer.Exit(code=1)
+
+    # 2. Check file input
+    elif file_path:
+        try:
+            payload_data = load_batch_file(file_path)
+        except Exception as e:
+            print_error_panel("File Loading Error", str(e))
+            raise typer.Exit(code=1)
+
+    # 3. Check stdin pipe
+    elif not sys.stdin.isatty():
+        stdin_content = sys.stdin.read().strip()
+        if stdin_content:
+            try:
+                payload_data = json.loads(stdin_content)
+            except json.JSONDecodeError:
+                # Try parsing as CSV
+                import io
+                reader = csv.DictReader(io.StringIO(stdin_content))
+                samples = [row for row in reader]
+                if samples:
+                    payload_data = samples
+                else:
+                    print_error_panel("Invalid Stdin Input", "Could not parse standard input as JSON or CSV.")
+                    raise typer.Exit(code=1)
+
+    if payload_data is None:
+        print_error_panel(
+            "Missing Input Data",
+            "No prediction data provided.",
+            remedy="Provide data using:\n  • --data '{\"feature\": 12}'\n  • --file test_data.csv\n  • cat test_data.csv | doushi predict <id>"
+        )
+        raise typer.Exit(code=1)
+
+    # Execute Prediction
+    is_interactive = sys.stdout.isatty() and not json_output
+    if is_interactive:
+        with console.status(f"[bold cyan]Computing prediction for project {project_id}...[/bold cyan]"):
+            try:
+                result = client.predict(project_id, payload_data)
+            except DoushiAPIError as e:
+                print_error_panel("Inference Failed", e.message, status_code=e.status_code)
+                raise typer.Exit(code=1)
+    else:
+        try:
+            result = client.predict(project_id, payload_data)
+        except DoushiAPIError as e:
+            err_console.print(f"Error: {e.message}")
+            raise typer.Exit(code=1)
+
+    # Output handling
+    if output:
+        if output.suffix.lower() == ".json":
+            with open(output, "w", encoding="utf-8") as f:
+                json.dump(result, f, indent=2)
+        else:
+            # Write CSV
+            predictions = result.get("prediction") or result.get("predictions")
+            if isinstance(predictions, list):
+                with open(output, "w", encoding="utf-8", newline="") as f:
+                    writer = csv.writer(f)
+                    writer.writerow(["prediction"])
+                    for p in predictions:
+                        writer.writerow([p])
+            else:
+                with open(output, "w", encoding="utf-8") as f:
+                    f.write(str(predictions))
+        print_success(f"Predictions saved to {output}")
+        return
+
+    if json_output or not sys.stdout.isatty():
+        print_json(result)
+        return
+
+    # Formatted Rich Output
+    pred = result.get("prediction") if "prediction" in result else result.get("predictions")
+    latency = result.get("latency_ms", "-")
+
+    table = Table(title=f"Prediction Result (Latency: {latency}ms)", border_style="green")
+    table.add_column("Sample #", style="dim", justify="right")
+    table.add_column("Prediction", style="bold green")
+
+    if isinstance(pred, list):
+        for i, val in enumerate(pred[:50]):
+            table.add_row(str(i + 1), str(val))
+        if len(pred) > 50:
+            table.add_row("...", f"[dim]and {len(pred) - 50} more samples[/dim]")
+    else:
+        table.add_row("1", str(pred))
+
+    console.print(table)

doushi/commands/projects.py

@@ -0,0 +1,125 @@
+"""Project management commands for Doushi CLI (list, view, delete, init)."""
+
+from typing import Optional
+import typer
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Prompt, Confirm
+
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.ui import (
+    console,
+    err_console,
+    print_error_panel,
+    print_info,
+    print_json,
+    print_projects_table,
+    print_success,
+    print_warning,
+)
+
+projects_app = typer.Typer(help="Manage and inspect your Doushi AI projects.")
+
+
+@projects_app.command(name="list")
+@projects_app.command(name="ls")
+def list_projects(
+    json_output: bool = typer.Option(False, "--json", help="Output list as JSON"),
+) -> None:
+    """List all AI projects in your organization."""
+    client = DoushiClient()
+    with console.status("[bold cyan]Fetching projects...[/bold cyan]"):
+        try:
+            projects = client.list_projects()
+        except DoushiAPIError as e:
+            print_error_panel("Failed to List Projects", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(projects)
+        return
+
+    print_projects_table(projects)
+
+
+@projects_app.command(name="view")
+def view_project(
+    project_id: str = typer.Argument(..., help="Unique ID of the project"),
+    json_output: bool = typer.Option(False, "--json", help="Output details as JSON"),
+) -> None:
+    """View detailed metrics, hyperparameters, and status for a project."""
+    client = DoushiClient()
+    with console.status(f"[bold cyan]Fetching project {project_id}...[/bold cyan]"):
+        try:
+            p = client.get_project(project_id)
+        except DoushiAPIError as e:
+            print_error_panel("Project Not Found", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    if json_output:
+        print_json(p)
+        return
+
+    status = str(p.get("status", "unknown")).upper()
+    name = p.get("name", "Untitled")
+
+    console.print(f"\n[bold white]Project:[/bold white] [bold cyan]{name}[/bold cyan] ([dim]{project_id}[/dim])")
+    console.print(f"[bold white]Status:[/bold white] [bold]{status}[/bold]\n")
+
+    # Overview table
+    table = Table(title="Project Details", border_style="dim")
+    table.add_column("Property", style="bold white")
+    table.add_column("Value", style="cyan")
+
+    table.add_row("ID", str(p.get("id", "-")))
+    table.add_row("Name", name)
+    table.add_row("Status", status)
+    table.add_row("Prompt Goal", str(p.get("prompt", "-")))
+    table.add_row("Dataset Path", str(p.get("dataset_path", "-")))
+    table.add_row("Model Provider", str(p.get("provider", "gemini")))
+    table.add_row("Current Iteration", str(p.get("current_iteration", 0)))
+    table.add_row("Created At", str(p.get("created_at", "-")))
+
+    console.print(table)
+
+    # Metrics section
+    metrics = p.get("metrics")
+    if metrics and isinstance(metrics, dict):
+        m_table = Table(title="Model Evaluation Metrics", border_style="green")
+        m_table.add_column("Metric", style="bold white")
+        m_table.add_column("Score", style="bold green")
+        for k, v in metrics.items():
+            if isinstance(v, (int, float)):
+                m_table.add_row(k.upper(), f"{v:.4f}")
+            else:
+                m_table.add_row(k.upper(), str(v))
+        console.print(m_table)
+
+    # Error section
+    error = p.get("error")
+    if error:
+        print_error_panel("Model Failure Error", str(error))
+
+
+@projects_app.command(name="delete")
+def delete_project(
+    project_id: str = typer.Argument(..., help="Unique ID of the project to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+) -> None:
+    """Delete a project and its associated artifacts."""
+    client = DoushiClient()
+
+    if not yes:
+        confirm = Confirm.ask(f"[bold yellow]Are you sure you want to permanently delete project '{project_id}'?[/bold yellow]")
+        if not confirm:
+            print_info("Deletion cancelled.")
+            return
+
+    with console.status(f"[bold red]Deleting project {project_id}...[/bold red]"):
+        try:
+            client.delete_project(project_id)
+        except DoushiAPIError as e:
+            print_error_panel("Deletion Failed", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    print_success(f"Project '{project_id}' successfully deleted.")

doushi/commands/train.py

@@ -0,0 +1,198 @@
+"""Model training and creation command for Doushi CLI (train / create)."""
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+import typer
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Prompt
+
+from doushi.client import DoushiClient, DoushiAPIError
+from doushi.ui import (
+    console,
+    err_console,
+    print_banner,
+    print_error_panel,
+    print_info,
+    print_json,
+    print_success,
+    print_warning,
+)
+
+train_app = typer.Typer(help="Train and build autonomous ML models from datasets.")
+
+
+@train_app.command(name="train")
+@train_app.command(name="create")
+def train(
+    dataset_file: Path = typer.Argument(
+        ...,
+        help="Path to local dataset file (.csv, .parquet, .xlsx, .tsv, .json)",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+    ),
+    goal: Optional[str] = typer.Option(
+        None,
+        "--goal",
+        "-g",
+        help="Natural language prediction goal (e.g. 'Predict customer churn probability')",
+    ),
+    name: Optional[str] = typer.Option(
+        None,
+        "--name",
+        "-n",
+        help="Project name (defaults to dataset filename)",
+    ),
+    follow: bool = typer.Option(
+        True,
+        "--follow/--no-follow",
+        "-f/-F",
+        help="Stream agent progress until model training completes.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output created project details as JSON",
+    ),
+) -> None:
+    """Upload dataset and train an autonomous ML model with agent self-healing."""
+    client = DoushiClient()
+    client.check_auth_or_exit()
+
+    # 1. Fetch user account info for tier limit verification
+    with console.status("[bold cyan]Checking account quotas & tier limits...[/bold cyan]"):
+        try:
+            whoami_data = client.get_whoami()
+            org = whoami_data.get("organization") or {}
+            tier = str(org.get("tier", "free")).lower()
+        except Exception:
+            tier = "free"
+
+    # 2. Local Pre-flight check on dataset size
+    client.check_file_limits(dataset_file, tier=tier)
+
+    # 3. Prompt for goal if missing
+    if not goal:
+        print_banner()
+        console.print(f"\n[bold white]Dataset:[/bold white] [bold cyan]{dataset_file.name}[/bold cyan]")
+        console.print(f"[bold white]Size:[/bold white]    [dim]{dataset_file.stat().st_size / (1024*1024):.2f} MB[/dim]\n")
+        goal = Prompt.ask(
+            "[bold green]🎯 What is your prediction goal for this dataset?[/bold green]\n"
+            "[dim](e.g. 'Predict customer churn', 'Forecast monthly revenue', 'Classify spam')[/dim]"
+        )
+        if not goal or not goal.strip():
+            print_error_panel("Goal Required", "A prediction goal is required for the autonomous agent to build the model.")
+            raise typer.Exit(code=1)
+
+    project_name = name or dataset_file.stem.replace("_", " ").replace("-", " ").title()
+
+    # 4. Create Project
+    with console.status(f"[bold cyan]Initializing project '{project_name}'...[/bold cyan]"):
+        try:
+            proj_data = client.create_project(name=project_name)
+            project_id = proj_data.get("project_id") or proj_data.get("id")
+        except DoushiAPIError as e:
+            print_error_panel("Project Creation Failed", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    # 5. Request S3 presigned URL
+    file_size = dataset_file.stat().st_size
+    with console.status("[bold cyan]Requesting secure storage upload URL...[/bold cyan]"):
+        try:
+            upload_info = client.request_upload_url(
+                project_id=project_id,
+                filename=dataset_file.name,
+                file_size=file_size,
+            )
+            presigned_url = upload_info["url"]
+        except DoushiAPIError as e:
+            print_error_panel("Upload Request Failed", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    # 6. Stream upload file to S3
+    client.upload_file_to_s3(presigned_url, dataset_file)
+    print_success(f"Dataset '{dataset_file.name}' uploaded successfully.")
+
+    # 7. Start Agent Pipeline
+    with console.status("[bold cyan]Dispatching autonomous agent pipeline...[/bold cyan]"):
+        try:
+            client.start_pipeline(project_id=project_id, prompt=goal)
+        except DoushiAPIError as e:
+            print_error_panel("Agent Dispatch Failed", e.message, status_code=e.status_code)
+            raise typer.Exit(code=1)
+
+    print_success(f"Autonomous agent started for project [bold cyan]{project_id}[/bold cyan].")
+
+    if json_output:
+        print_json({
+            "project_id": project_id,
+            "name": project_name,
+            "goal": goal,
+            "dataset": dataset_file.name,
+            "status": "queued"
+        })
+        return
+
+    if not follow:
+        console.print(f"\n👉 Track status: [bold cyan]doushi view {project_id}[/bold cyan]")
+        console.print(f"👉 Stream logs:  [bold cyan]doushi logs {project_id} -f[/bold cyan]\n")
+        return
+
+    # 8. Follow / Stream agent progress
+    console.print("\n[bold white]Watching Autonomous Agent Execution[/bold white] [dim](Press Ctrl+C to detach)[/dim]\n")
+
+    last_status = None
+    with console.status("[bold yellow]Agent analyzing dataset schema & selecting ML strategy...[/bold yellow]") as status_spinner:
+        for _ in range(120):  # Wait up to 10 minutes
+            time.sleep(5)
+            try:
+                p = client.get_project(project_id)
+            except Exception:
+                continue
+
+            current_status = str(p.get("status", "pending")).lower()
+
+            if current_status != last_status:
+                last_status = current_status
+                if current_status in ["queued", "pending"]:
+                    status_spinner.update("[bold blue]Job queued in compute worker...[/bold blue]")
+                elif current_status in ["running", "training"]:
+                    status_spinner.update("[bold yellow]Agent executing sandbox code & optimizing hyperparameters...[/bold yellow]")
+                elif current_status == "success":
+                    break
+                elif current_status == "failed":
+                    break
+
+        if current_status == "success":
+            console.print("\n")
+            print_success(f"Model successfully trained and ready for inference!")
+            
+            metrics = p.get("metrics") or {}
+            if isinstance(metrics, dict) and metrics:
+                m_table = Table(title="Model Evaluation Performance", border_style="green")
+                m_table.add_column("Metric", style="bold white")
+                m_table.add_column("Score", style="bold green")
+                for k, v in metrics.items():
+                    val_str = f"{v:.4f}" if isinstance(v, (int, float)) else str(v)
+                    m_table.add_row(k.upper(), val_str)
+                console.print(m_table)
+
+            console.print("\n[bold green]✦ Next Steps:[/bold green]")
+            console.print(f"  • Run live prediction:   [bold cyan]doushi predict {project_id} --data '{{...}}'[/bold cyan]")
+            console.print(f"  • Export model & code:   [bold cyan]doushi export {project_id} --out ./model-bundle/[/bold cyan]")
+            console.print(f"  • Inspect project:       [bold cyan]doushi view {project_id}[/bold cyan]\n")
+
+        elif current_status == "failed":
+            console.print("\n")
+            err_msg = p.get("error") or "Unknown error occurred during agent training."
+            print_error_panel(
+                title="Model Training Failed",
+                message=str(err_msg),
+                remedy=f"View full agent traceback with: doushi logs {project_id}"
+            )
+            raise typer.Exit(code=1)

doushi/config.py

@@ -0,0 +1,111 @@
+"""Configuration and credential management for Doushi CLI."""
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+DEFAULT_API_URL = "https://api.doushi.ai"
+DEFAULT_DASHBOARD_URL = "https://doushi.ai"
+
+DOUSHI_DIR = Path.home() / ".doushi"
+CREDENTIALS_FILE = DOUSHI_DIR / "credentials"
+CONFIG_FILE = DOUSHI_DIR / "config.json"
+
+
+def ensure_doushi_dir() -> None:
+    """Ensure ~/.doushi directory exists with secure permissions."""
+    DOUSHI_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(DOUSHI_DIR, stat.S_IRWXU)  # 0700
+    except Exception:
+        pass
+
+
+def get_api_url() -> str:
+    """Get active API endpoint from env, config file, or default."""
+    if os.getenv("DOUSHI_API_URL"):
+        return os.environ["DOUSHI_API_URL"].rstrip("/")
+    config = load_config()
+    return config.get("api_url", DEFAULT_API_URL).rstrip("/")
+
+
+def get_api_key() -> Optional[str]:
+    """Get active API key from env or credentials file."""
+    # 1. Environment variable override
+    if os.getenv("DOUSHI_API_KEY"):
+        return os.environ["DOUSHI_API_KEY"].strip()
+    
+    # 2. Stored credentials
+    creds = load_credentials()
+    current_context = creds.get("current_context", "default")
+    contexts = creds.get("contexts", {})
+    context_data = contexts.get(current_context, {})
+    return context_data.get("api_key")
+
+
+def load_credentials() -> Dict[str, Any]:
+    """Load credentials JSON from ~/.doushi/credentials."""
+    if not CREDENTIALS_FILE.exists():
+        return {"current_context": "default", "contexts": {}}
+    try:
+        with open(CREDENTIALS_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {"current_context": "default", "contexts": {}}
+
+
+def save_credentials(api_key: str, user_email: Optional[str] = None, org_name: Optional[str] = None, tier: Optional[str] = None, context: str = "default") -> None:
+    """Save credentials to ~/.doushi/credentials with secure 0600 permissions."""
+    ensure_doushi_dir()
+    creds = load_credentials()
+    if "contexts" not in creds:
+        creds["contexts"] = {}
+    
+    creds["current_context"] = context
+    creds["contexts"][context] = {
+        "api_key": api_key,
+        "user_email": user_email,
+        "org_name": org_name,
+        "tier": tier,
+    }
+    
+    with open(CREDENTIALS_FILE, "w", encoding="utf-8") as f:
+        json.dump(creds, f, indent=2)
+    
+    try:
+        os.chmod(CREDENTIALS_FILE, stat.S_IRUSR | stat.S_IWUSR)  # 0600
+    except Exception:
+        pass
+
+
+def delete_credentials() -> None:
+    """Remove stored credentials on logout."""
+    if CREDENTIALS_FILE.exists():
+        try:
+            CREDENTIALS_FILE.unlink()
+        except Exception:
+            pass
+
+
+def load_config() -> Dict[str, Any]:
+    """Load settings from ~/.doushi/config.json."""
+    if not CONFIG_FILE.exists():
+        return {
+            "api_url": DEFAULT_API_URL,
+            "output_format": "table",
+            "auto_open_browser": True
+        }
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {"api_url": DEFAULT_API_URL, "output_format": "table"}
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save settings to ~/.doushi/config.json."""
+    ensure_doushi_dir()
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)