drift-ml 0.1.1__tar.gz

drift_ml-0.1.1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: drift-ml
+Version: 0.1.1
+Summary: Terminal-first AutoML CLI - chat-based ML engineer
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.28.0

drift_ml-0.1.1/README.md

@@ -0,0 +1,186 @@
+# Intent2Model 🚀
+
+LLM-Guided AutoML Agent - Upload a CSV, chat with the AI, get a trained model.
+
+## ⚡ Quick Start (Easiest Way)
+
+```bash
+# Make scripts executable (first time only)
+chmod +x start.sh stop.sh
+
+# Start everything
+./start.sh
+```
+
+Then open **http://localhost:3000** in your browser!
+
+To stop: Press `Ctrl+C` or run `./stop.sh`
+
+---
+
+## 📖 How to Use
+
+### 1. Upload CSV
+- Drag & drop your CSV file or click "choose file"
+- System analyzes it automatically
+
+### 2. Train Model
+Just type a column name in the chat:
+- **"variety"** → trains model to predict "variety"
+- **"price"** → trains model to predict "price"
+- Or any column name from your dataset
+
+### 3. View Results
+- **"report"** → shows beautiful charts and metrics
+- **"show me results"** → displays model performance
+
+### 4. Make Predictions
+- **"predict"** or **"can you predict for me?"** → starts prediction flow
+- Provide feature values: **"sepal.length: 5.1, sepal.width: 3.5"**
+
+---
+
+## 💬 Example Conversation
+
+```
+You: [uploads iris.csv]
+AI: ✓ analyzed your dataset • 150 rows • 5 columns
+AI: suggested targets: variety, sepal.length, sepal.width
+
+You: variety
+AI: 🚀 training model to predict "variety"...
+AI: ✅ model trained successfully!
+AI: accuracy: 1.000 • best model: RandomForest
+AI: [shows charts]
+
+You: report
+AI: [shows detailed charts: metrics, feature importance, CV scores]
+
+You: predict
+AI: sure! i need: sepal.length, sepal.width, petal.length, petal.width
+
+You: sepal.length: 5.1, sepal.width: 3.5, petal.length: 1.4, petal.width: 0.2
+AI: 🎯 prediction: Setosa
+AI: probabilities: Setosa 99.8%, Versicolor 0.2%, Virginica 0.0%
+```
+
+---
+
+## 🛠️ Manual Setup (Alternative)
+
+### Backend
+**Important:** Always run uvicorn from inside the `backend/` folder. Running from project root will fail with "Could not import module main".
+
+```bash
+cd backend
+pip install -r ../requirements.txt
+# Optional: set API key in .env or export GEMINI_API_KEY=your_key
+python3 -m uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+Or use the helper script (from project root):
+```bash
+chmod +x backend/run.sh
+./backend/run.sh
+```
+
+**Backend nahi chal raha?**
+- **"Could not import module main"** → You're in the wrong folder. Run `cd backend` first, then `python3 -m uvicorn main:app --host 0.0.0.0 --port 8000`.
+- **"Address already in use" / port 8000** → Free the port: `lsof -ti:8000 | xargs kill -9`, then start again.
+- **Dependencies missing** → From project root: `pip install -r requirements.txt` (or use `./start.sh` — it creates a venv and installs deps).
+
+### Frontend (New Terminal)
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+Visit **http://localhost:3000**
+
+---
+
+## 🎨 Features
+
+- 📊 **Beautiful Charts**: Metrics, feature importance, CV scores
+- 🎨 **Extravagant UI**: Gradient colors, smooth animations
+- 🤖 **LLM-Powered**: Gemini AI generates optimal pipelines
+- 🔮 **Smart Predictions**: Chat-based prediction interface
+- 📈 **Model Comparison**: Tries multiple models, picks best
+- ⚡ **Auto-Detection**: Automatically detects task type and metrics
+
+---
+
+## 📝 Requirements
+
+- Python 3.10+
+- Node.js 18+
+- npm/yarn
+
+Install dependencies:
+```bash
+# Backend
+pip install -r requirements.txt
+
+# Frontend
+cd frontend
+npm install
+```
+
+---
+
+## 🐛 Troubleshooting
+
+**Services not starting?**
+- Check ports: `lsof -i :8000` and `lsof -i :3000`
+- Check logs: `tail -f backend.log` or `tail -f frontend.log`
+
+**Training errors?**
+- Make sure CSV has valid data
+- Check that target column exists
+- Try a different column name
+
+---
+
+## drift — Terminal-first CLI
+
+**drift** by Lakshit Sachdeva. Terminal-first, chat-based AutoML — same engine as the web UI. No commands to memorize.
+
+### Exactly what to do (any computer)
+
+1. **Install drift** (pick one):
+   ```bash
+   npm install -g drift-ml
+   ```
+   or:
+   ```bash
+   pipx install drift
+   ```
+
+2. **Run drift:**
+   ```bash
+   drift
+   ```
+   You’ll see the welcome and step-by-step instructions in the terminal.
+
+3. **Engine** — On first run the CLI downloads and starts the drift engine locally (or set `DRIFT_BACKEND_URL` to a running engine). You need an LLM: Gemini CLI, Ollama, or another local LLM.
+
+4. **In drift:** type `load path/to/your.csv`, then chat (e.g. `predict price`, `try something stronger`). Type `quit` to exit.
+
+drift shows you the rest when you run it.
+
+### Install (details)
+
+- **Local-first** — Same engine as the web app; planning and training run on your machine.
+- **Chat-based**: e.g. `load iris.csv`, `predict price`, `try something stronger`, `why is accuracy capped`.
+- **Engine** runs locally (CLI auto-starts it or use `DRIFT_BACKEND_URL`). Web UI can be hosted on Vercel.
+
+---
+
+## 📚 More Info
+
+See `HOW_TO_USE.md` for detailed instructions and examples.
+
+---
+
+**That's it! Just run `./start.sh` and start chatting! 🎉**

drift_ml-0.1.1/drift/__init__.py

@@ -0,0 +1,5 @@
+"""
+drift — terminal-first, chat-based CLI for the same AutoML planner + executor as the web app.
+"""
+
+__version__ = "0.1.0"

drift_ml-0.1.1/drift/__main__.py

@@ -0,0 +1,14 @@
+"""
+Entry point for `python -m drift` or `drift` command.
+Runs the chat-based REPL.
+"""
+
+from drift.cli.repl import run_repl
+
+
+def main() -> None:
+    run_repl()
+
+
+if __name__ == "__main__":
+    main()

drift_ml-0.1.1/drift/cli/__init__.py

@@ -0,0 +1,6 @@
+"""drift CLI: chat-based REPL and session state."""
+
+from drift.cli.session import SessionState
+from drift.cli.repl import run_repl
+
+__all__ = ["SessionState", "run_repl"]

drift_ml-0.1.1/drift/cli/client.py

@@ -0,0 +1,125 @@
+"""
+HTTP client for the existing backend API.
+Uses the same endpoints as the web app: upload, chat, session, runs, train.
+"""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+try:
+    import requests
+except ImportError:
+    requests = None  # type: ignore
+
+DEFAULT_BASE_URL = os.environ.get("DRIFT_BACKEND_URL", "http://localhost:8000")
+
+
+class BackendError(Exception):
+    """Raised when the backend returns an error or is unreachable."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, body: Any = None):
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+        super().__init__(message)
+
+
+class BackendClient:
+    """Client for backend upload, chat, session, runs, and train endpoints."""
+
+    def __init__(self, base_url: str = DEFAULT_BASE_URL, timeout: int = 300):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        if requests is None:
+            raise BackendError(
+                "The 'requests' library is required for the drift CLI. Install it with: pip install requests"
+            )
+
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def health(self) -> Dict[str, Any]:
+        """GET /health — check backend is up and LLM status."""
+        r = requests.get(self._url("/health"), timeout=10)
+        r.raise_for_status()
+        return r.json()
+
+    def upload_csv(self, file_path: str) -> Dict[str, Any]:
+        """
+        POST /upload — upload a local CSV and create a session.
+        Returns session_id, dataset_id, profile, initial_message.
+        """
+        path = Path(file_path).resolve()
+        if not path.exists():
+            raise BackendError(f"File not found: {path}")
+        with open(path, "rb") as f:
+            name = path.name
+            files = {"file": (name, f, "text/csv")}
+            r = requests.post(self._url("/upload"), files=files, timeout=60)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Upload failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def chat(self, session_id: str, message: str) -> Dict[str, Any]:
+        """
+        POST /session/{session_id}/chat — send a user message, get agent reply.
+        Returns chat_history, trigger_training.
+        """
+        r = requests.post(
+            self._url(f"/session/{session_id}/chat"),
+            json={"message": message},
+            timeout=120,
+        )
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Chat failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def get_session(self, session_id: str) -> Dict[str, Any]:
+        """GET /session/{session_id} — full session state (chat, model_state, current_run_id, etc.)."""
+        r = requests.get(self._url(f"/session/{session_id}"), timeout=30)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Get session failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def get_run_state(self, run_id: str) -> Dict[str, Any]:
+        """GET /runs/{run_id} — run state: status, current_step, progress, events[]."""
+        r = requests.get(self._url(f"/runs/{run_id}"), timeout=30)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Get run failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()
+
+    def train(self, session_id: str) -> Dict[str, Any]:
+        """
+        POST /session/{session_id}/train — run one training attempt (blocking).
+        Returns run_id, session_id, metrics, refused, refusal_reason, agent_message.
+        """
+        r = requests.post(self._url(f"/session/{session_id}/train"), timeout=self.timeout)
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+                detail = body.get("detail", str(r.text))
+            except Exception:
+                detail = r.text or str(r.status_code)
+            raise BackendError(f"Train failed: {detail}", status_code=r.status_code, body=r.text)
+        return r.json()

drift_ml-0.1.1/drift/cli/repl.py

@@ -0,0 +1,220 @@
+"""
+Chat-based CLI loop for drift.
+Natural language input; maintains session state; reuses backend planner + executor.
+"""
+
+import re
+import sys
+import threading
+import time
+from typing import Any, Dict, Optional
+
+from drift.cli.client import BackendClient, BackendError, DEFAULT_BASE_URL
+from drift.cli.session import SessionState
+
+
+PROMPT = "drift › "
+LOAD_PATTERN = re.compile(r"^\s*load\s+(.+)$", re.IGNORECASE)
+
+
+def run_repl(base_url: Optional[str] = None) -> None:
+    """Run the chat-based REPL. Uses backend at base_url (default from DRIFT_BACKEND_URL or localhost:8000)."""
+    try:
+        client = BackendClient(base_url=base_url or DEFAULT_BASE_URL)
+    except BackendError as e:
+        print(f"drift: {e.message}", file=sys.stderr)
+        sys.exit(1)
+    session = SessionState()
+    _print_banner(client)
+    while True:
+        try:
+            line = input(PROMPT).strip()
+        except EOFError:
+            print()
+            break
+        if not line:
+            continue
+        if line.lower() in ("quit", "exit", "q"):
+            break
+        try:
+            _handle_input(line, client, session)
+        except BackendError as e:
+            print(f"Error: {e.message}", file=sys.stderr)
+        except KeyboardInterrupt:
+            print("\nInterrupted. Type 'quit' to exit.")
+            continue
+
+
+def _print_banner(client: BackendClient) -> None:
+    _print_welcome()
+    engine_ok = False
+    llm_name = ""
+    try:
+        health = client.health()
+        engine_ok = (health.get("status") or "").lower() == "healthy"
+        llm_name = health.get("llm_provider") or health.get("current_model") or ""
+    except Exception:
+        pass
+    _print_status(engine_ok=engine_ok, llm_name=llm_name)
+    _print_examples()
+    print()
+
+
+def _print_welcome() -> None:
+    """drift by Lakshit Sachdeva. Local-first ML engineer."""
+    print()
+    print("  ----------------------------------------")
+    print("  drift by Lakshit Sachdeva")
+    print("  Local-first ML engineer.")
+    print("  Same engine as the web app.")
+    print("  No commands to memorize.")
+    print("  ----------------------------------------")
+    print()
+
+
+def _print_status(engine_ok: bool, llm_name: str) -> None:
+    """Engine running, LLM detected, Ready."""
+    if engine_ok:
+        print("  \u2713  Engine running")
+        if llm_name:
+            print(f"  \u2713  LLM detected ({llm_name})")
+        else:
+            print("  \u2713  LLM detected (Gemini CLI / Ollama / local)")
+        print("  \u2713  Ready")
+    else:
+        print("  \u2717  Engine not running")
+        print("      Start the engine or set DRIFT_BACKEND_URL to a running engine URL.")
+    print()
+
+
+def _print_examples() -> None:
+    """Examples: load, predict, try something stronger, quit."""
+    print("  Examples:")
+    print("    load data.csv")
+    print("    predict price")
+    print("    try something stronger")
+    print("    why is accuracy capped")
+    print("    quit")
+    print()
+
+
+def _handle_input(line: str, client: BackendClient, session: SessionState) -> None:
+    load_match = LOAD_PATTERN.match(line)
+    if load_match:
+        path = load_match.group(1).strip().strip('"\'')
+        _do_load(path, client, session)
+        return
+    if not session.has_session():
+        print("Load a dataset first: load path/to/file.csv")
+        return
+    _do_chat(line, client, session)
+
+
+def _do_load(path: str, client: BackendClient, session: SessionState) -> None:
+    out = client.upload_csv(path)
+    session.dataset_path = path
+    session.update_from_upload(
+        session_id=out["session_id"],
+        dataset_id=out["dataset_id"],
+        initial_message=out.get("initial_message"),
+    )
+    print("Dataset loaded.")
+    if out.get("initial_message"):
+        content = out["initial_message"].get("content") or ""
+        if content:
+            _print_message(content)
+    print()
+
+
+def _do_chat(message: str, client: BackendClient, session: SessionState) -> None:
+    sid = session.session_id
+    out = client.chat(sid, message)
+    chat_history = out.get("chat_history") or []
+    session.update_from_chat(chat_history)
+    # Show latest agent reply
+    for m in reversed(chat_history):
+        if m.get("role") == "agent" and m.get("content"):
+            _print_message(m["content"])
+            break
+    trigger = out.get("trigger_training") is True
+    if trigger:
+        _run_training_and_show(client, session)
+    print()
+
+
+def _run_training_and_show(client: BackendClient, session: SessionState) -> None:
+    sid = session.session_id
+    if not sid:
+        return
+    train_result: Optional[Dict[str, Any]] = None
+    train_error: Optional[Exception] = None
+
+    def do_train() -> None:
+        nonlocal train_result, train_error
+        try:
+            train_result = client.train(sid)
+        except Exception as e:
+            train_error = e
+
+    thread = threading.Thread(target=do_train, daemon=True)
+    thread.start()
+    print("Training started…")
+    run_id: Optional[str] = None
+    last_event_count = 0
+    poll_interval = 0.8
+    timeout_sec = 300
+    start = time.time()
+    while thread.is_alive() and (time.time() - start) < timeout_sec:
+        time.sleep(poll_interval)
+        try:
+            sess = client.get_session(sid)
+            run_id = sess.get("current_run_id")
+            if run_id:
+                break
+        except Exception:
+            pass
+    if run_id:
+        while thread.is_alive() and (time.time() - start) < timeout_sec:
+            time.sleep(poll_interval)
+            try:
+                run_state = client.get_run_state(run_id)
+                events = run_state.get("events") or []
+                for ev in events[last_event_count:]:
+                    msg = ev.get("message") or ev.get("step_name") or ""
+                    if msg:
+                        print(f"  {msg}")
+                last_event_count = len(events)
+                status = run_state.get("status")
+                if status in ("success", "failed", "refused"):
+                    break
+            except Exception:
+                pass
+    thread.join(timeout=1.0)
+    if train_error:
+        print(f"Training error: {train_error}", file=sys.stderr)
+        return
+    if train_result:
+        session.update_after_train(
+            run_id=train_result.get("run_id", ""),
+            metrics=train_result.get("metrics") or {},
+            agent_message=train_result.get("agent_message"),
+        )
+        agent_message = train_result.get("agent_message")
+        if agent_message:
+            _print_message(agent_message)
+        metrics = train_result.get("metrics") or {}
+        if metrics:
+            primary = metrics.get("primary_metric_value") or metrics.get("accuracy") or metrics.get("r2")
+            if primary is not None:
+                print(f"  Primary metric: {primary}")
+
+
+def _print_message(content: str) -> None:
+    """Print agent message; strip markdown bold for terminal if desired, keep newlines."""
+    text = content.strip()
+    if not text:
+        return
+    # Optional: replace **x** with x for readability in terminal
+    text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)
+    for line in text.split("\n"):
+        print(line)

drift_ml-0.1.1/drift/cli/session.py

@@ -0,0 +1,70 @@
+"""
+Session state for the drift CLI.
+Holds dataset ref, plan summary, last metrics, run_id, and chat history
+so the REPL can maintain context and the backend can be queried correctly.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class SessionState:
+    """In-memory CLI session: dataset, plan, run, metrics, chat."""
+
+    dataset_path: Optional[str] = None
+    dataset_id: Optional[str] = None
+    session_id: Optional[str] = None
+    run_id: Optional[str] = None
+    plan_summary: Optional[str] = None
+    last_metrics: Dict[str, Any] = field(default_factory=dict)
+    chat_history: List[Dict[str, Any]] = field(default_factory=list)
+
+    def has_session(self) -> bool:
+        return bool(self.session_id)
+
+    def has_dataset(self) -> bool:
+        return bool(self.dataset_id and self.session_id)
+
+    def clear_run(self) -> None:
+        self.run_id = None
+        self.last_metrics = {}
+
+    def update_from_upload(self, session_id: str, dataset_id: str, initial_message: Optional[Dict] = None) -> None:
+        self.session_id = session_id
+        self.dataset_id = dataset_id
+        self.run_id = None
+        self.last_metrics = {}
+        if initial_message:
+            self.chat_history = [initial_message]
+
+    def update_from_chat(self, chat_history: List[Dict[str, Any]], run_id: Optional[str] = None) -> None:
+        self.chat_history = chat_history or self.chat_history
+        if run_id is not None:
+            self.run_id = run_id
+
+    def update_from_session(self, session: Dict[str, Any]) -> None:
+        self.session_id = session.get("session_id") or self.session_id
+        self.dataset_id = session.get("dataset_id") or self.dataset_id
+        self.run_id = session.get("current_run_id") or self.run_id
+        self.chat_history = session.get("chat_history") or self.chat_history
+        ms = session.get("model_state") or {}
+        self.last_metrics = ms.get("metrics") or self.last_metrics
+        self.plan_summary = None
+        if session.get("structural_plan"):
+            self.plan_summary = _summarize_plan(session["structural_plan"])
+
+    def update_after_train(self, run_id: str, metrics: Dict[str, Any], agent_message: Optional[str] = None) -> None:
+        self.run_id = run_id
+        self.last_metrics = metrics or self.last_metrics
+        if agent_message and self.chat_history:
+            self.chat_history[-1]["content"] = agent_message
+
+
+def _summarize_plan(structural_plan: Dict[str, Any]) -> str:
+    """One-line summary of structural plan for display (StructuralPlan has inferred_target, task_type; no models)."""
+    if not structural_plan:
+        return ""
+    target = structural_plan.get("inferred_target") or structural_plan.get("target") or "?"
+    task = structural_plan.get("task_type") or "?"
+    return f"Target: {target}, task: {task}"

drift_ml-0.1.1/drift/llm_adapters/__init__.py

@@ -0,0 +1,9 @@
+"""
+Pluggable LLM adapters for drift CLI.
+Primary planning/execution uses the backend; these adapters support
+optional local processing (e.g. help, summaries) or future offline use.
+"""
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+__all__ = ["BaseLLMAdapter", "LLMResponse"]

drift_ml-0.1.1/drift/llm_adapters/base.py

@@ -0,0 +1,41 @@
+"""
+Base contract for drift LLM adapters.
+The CLI uses the backend as the planner/executor; adapters return
+structured ML intent, plan updates, and explanations when used locally.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class LLMResponse:
+    """Structured response from an LLM adapter: intent, plan updates, explanation."""
+
+    raw: str
+    intent: Optional[Dict[str, Any]] = None  # target, drop_columns, performance_mode, start_training
+    plan_summary: Optional[str] = None
+    explanation: Optional[str] = None
+
+
+class BaseLLMAdapter(ABC):
+    """
+    LLM adapter contract.
+    The LLM is the PLANNER, not the executor; it updates plans and explains outcomes.
+    Execution is assumed to happen automatically (backend).
+    """
+
+    @abstractmethod
+    def generate(self, user_message: str, system_prompt: Optional[str] = None, context: Optional[Dict[str, Any]] = None) -> LLMResponse:
+        """
+        Turn user message + optional context into a structured response.
+        Returns intent, plan summary, and explanation — never claims to edit files or execute.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Adapter identifier (e.g. gemini_cli, local_llm)."""
+        pass

drift_ml-0.1.1/drift/llm_adapters/gemini_cli.py

@@ -0,0 +1,65 @@
+"""
+Gemini CLI adapter — uses gemini CLI (default if available) for local LLM calls.
+Used when drift CLI runs in a mode that calls a local LLM instead of the backend.
+"""
+
+import os
+import re
+import subprocess
+from typing import Any, Dict, Optional
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+
+class GeminiCLIAdapter(BaseLLMAdapter):
+    """Adapter that shells out to gemini CLI (e.g. `gemini` or GEMINI_CLI_CMD)."""
+
+    def __init__(self, cmd: Optional[str] = None):
+        self.cmd = (cmd or os.environ.get("GEMINI_CLI_CMD", "gemini")).strip()
+
+    @property
+    def name(self) -> str:
+        return "gemini_cli"
+
+    def generate(
+        self,
+        user_message: str,
+        system_prompt: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> LLMResponse:
+        prompt = user_message
+        if system_prompt:
+            prompt = f"{system_prompt}\n\n---\n\n{prompt}"
+        if context:
+            prompt = f"Context: {context}\n\n{prompt}"
+        raw = self._call_cli(prompt)
+        intent = self._parse_intent(raw)
+        return LLMResponse(raw=raw, intent=intent, explanation=raw)
+
+    def _call_cli(self, prompt: str) -> str:
+        try:
+            proc = subprocess.run(
+                [self.cmd, "run", "-"],
+                input=prompt,
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            if proc.returncode != 0:
+                return f"[gemini CLI error: {proc.stderr or proc.stdout or 'unknown'}]"
+            return (proc.stdout or "").strip()
+        except FileNotFoundError:
+            return f"[gemini CLI not found: {self.cmd}]"
+        except subprocess.TimeoutExpired:
+            return "[gemini CLI timeout]"
+
+    def _parse_intent(self, raw: str) -> Optional[Dict[str, Any]]:
+        """Extract INTENT_JSON from response if present."""
+        match = re.search(r"INTENT_JSON:\s*(\{.*?\})\s*$", raw, re.DOTALL)
+        if not match:
+            return None
+        try:
+            import json
+            return json.loads(match.group(1).strip())
+        except Exception:
+            return None

drift_ml-0.1.1/drift/llm_adapters/local_llm.py

@@ -0,0 +1,65 @@
+"""
+Local LLM adapter — ollama / llama.cpp style.
+Used when drift CLI is configured to use a local model instead of the backend.
+"""
+
+import os
+import re
+from typing import Any, Dict, Optional
+
+from drift.llm_adapters.base import BaseLLMAdapter, LLMResponse
+
+
+class LocalLLMAdapter(BaseLLMAdapter):
+    """
+    Adapter for local LLM (e.g. Ollama, llama.cpp server).
+    Expects OLLAMA_BASE_URL or LOCAL_LLM_URL; model from OLLAMA_MODEL or LOCAL_LLM_MODEL.
+    """
+
+    def __init__(self, base_url: Optional[str] = None, model: Optional[str] = None):
+        self.base_url = (base_url or os.environ.get("OLLAMA_BASE_URL") or os.environ.get("LOCAL_LLM_URL", "http://localhost:11434")).rstrip("/")
+        self.model = model or os.environ.get("OLLAMA_MODEL") or os.environ.get("LOCAL_LLM_MODEL", "llama2")
+
+    @property
+    def name(self) -> str:
+        return "local_llm"
+
+    def generate(
+        self,
+        user_message: str,
+        system_prompt: Optional[str] = None,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> LLMResponse:
+        prompt = user_message
+        if system_prompt:
+            prompt = f"{system_prompt}\n\n---\n\n{prompt}"
+        if context:
+            prompt = f"Context: {context}\n\n{prompt}"
+        raw = self._call_api(prompt)
+        intent = self._parse_intent(raw)
+        return LLMResponse(raw=raw, intent=intent, explanation=raw)
+
+    def _call_api(self, prompt: str) -> str:
+        try:
+            import requests
+            r = requests.post(
+                f"{self.base_url}/api/generate",
+                json={"model": self.model, "prompt": prompt, "stream": False},
+                timeout=120,
+            )
+            if r.status_code >= 400:
+                return f"[Local LLM error: {r.status_code} {r.text[:200]}]"
+            data = r.json()
+            return (data.get("response") or "").strip()
+        except Exception as e:
+            return f"[Local LLM error: {e}]"
+
+    def _parse_intent(self, raw: str) -> Optional[Dict[str, Any]]:
+        match = re.search(r"INTENT_JSON:\s*(\{.*?\})\s*$", raw, re.DOTALL)
+        if not match:
+            return None
+        try:
+            import json
+            return json.loads(match.group(1).strip())
+        except Exception:
+            return None

drift_ml-0.1.1/drift_ml.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: drift-ml
+Version: 0.1.1
+Summary: Terminal-first AutoML CLI - chat-based ML engineer
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.28.0

drift_ml-0.1.1/drift_ml.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+drift/__init__.py
+drift/__main__.py
+drift/cli/__init__.py
+drift/cli/client.py
+drift/cli/repl.py
+drift/cli/session.py
+drift/llm_adapters/__init__.py
+drift/llm_adapters/base.py
+drift/llm_adapters/gemini_cli.py
+drift/llm_adapters/local_llm.py
+drift_ml.egg-info/PKG-INFO
+drift_ml.egg-info/SOURCES.txt
+drift_ml.egg-info/dependency_links.txt
+drift_ml.egg-info/entry_points.txt
+drift_ml.egg-info/requires.txt
+drift_ml.egg-info/top_level.txt

drift_ml-0.1.1/drift_ml.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

drift_ml-0.1.1/drift_ml.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+drift = drift.__main__:main

drift_ml-0.1.1/drift_ml.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

drift_ml-0.1.1/drift_ml.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+drift
+drift-npm

drift_ml-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "drift-ml"
+version = "0.1.1"
+description = "Terminal-first AutoML CLI - chat-based ML engineer"
+requires-python = ">=3.10"
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.scripts]
+drift = "drift.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["drift*"]

drift_ml-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+