sage-ai-cli 1.0.0__tar.gz

sage_ai_cli-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: sage-ai-cli
+Version: 1.0.0
+Summary: Sage — a local-first AI coding CLI (like Claude Code, using free/open models)
+Author: Layne Faler
+License: MIT
+Project-URL: Repository, https://github.com/laynef/claude-ai-clone
+Keywords: ai,cli,llm,coding,local,gemini,gguf,llama
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: local
+Requires-Dist: llama-cpp-python>=0.2.90; extra == "local"
+Provides-Extra: server
+Requires-Dist: fastapi>=0.115.0; extra == "server"
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == "server"
+Requires-Dist: pydantic>=2.9.0; extra == "server"
+Requires-Dist: pydantic-settings>=2.5.0; extra == "server"
+Provides-Extra: all
+Requires-Dist: llama-cpp-python>=0.2.90; extra == "all"
+Requires-Dist: fastapi>=0.115.0; extra == "all"
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == "all"
+Requires-Dist: pydantic>=2.9.0; extra == "all"
+Requires-Dist: pydantic-settings>=2.5.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"

sage_ai_cli-1.0.0/README.md

@@ -0,0 +1,66 @@
+# Local AI Platform
+
+## File Structure
+
+```text
+ai-platform/
+├── backend/
+├── frontend/
+├── cli/
+├── models/
+└── config/
+```
+
+## Model Sources
+
+| Model | Runtime | Source | License | Approx Size | Suggested Hardware |
+|---|---|---|---|---|---|
+| Llama 3.2 3B Instruct GGUF Q4_K_M | llama.cpp | https://github.com/ggml-org/llama.cpp | Meta Llama 3.2 Community License | ~2.0 GB | 8 GB RAM CPU |
+| Qwen2.5 Coder 7B Instruct GGUF Q4_K_M | llama.cpp | https://github.com/QwenLM/Qwen2.5-Coder | Apache-2.0 | ~4.5 GB | 16 GB RAM CPU |
+| Mistral 7B Instruct v0.3 | transformers | https://github.com/mistralai/mistral-inference | Apache-2.0 | ~13 GB fp16 | 16+ GB VRAM or 32 GB RAM |
+
+## Quick Start
+
+1. Backend:
+```bash
+cd ai-platform
+python -m venv .venv
+source .venv/bin/activate
+pip install -r backend/requirements.txt
+cp .env.example .env
+PYTHONPATH=ai-platform uvicorn backend.app:app --host 0.0.0.0 --port 8090
+```
+
+2. Frontend:
+```bash
+cd ai-platform/frontend
+npm install
+npm run dev
+```
+
+3. CLI:
+```bash
+cd ai-platform/cli
+pip install .
+ai --host http://127.0.0.1:8090 list
+```
+
+## Model Download Examples
+
+```bash
+ai --host http://127.0.0.1:8090 download \
+  --model-id llama32-q4 \
+  --runtime llama_cpp \
+  --url https://github.com/abetlen/llama-cpp-python/releases/download/v0.2.90/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf
+```
+
+```bash
+ai --host http://127.0.0.1:8090 run llama32-q4 --threads 8
+ai --host http://127.0.0.1:8090 chat --model llama32-q4 --temperature 0.2 --max-tokens 512
+```
+
+## Privacy
+
+- All inference is local.
+- No telemetry is implemented.
+- After model download setup, inference requires no external API calls.

sage_ai_cli-1.0.0/backend/__init__.py

@@ -0,0 +1 @@
+

sage_ai_cli-1.0.0/backend/app.py

@@ -0,0 +1,346 @@
+import json
+import logging
+import os
+import uuid
+from dataclasses import asdict
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from .auto_updater import AutoUpdater
+from .config import runtime_defaults, settings
+from .conversations import ConversationStore
+from .github_client import discover_model_assets, parse_repo_url
+from .hardware import detect_hardware_summary
+from .model_catalog import filter_by_ram, get_recommended_models, list_catalog_models
+from .model_registry import ModelRegistry
+from .prompt_engine import build_messages
+from .runtime_manager import RuntimeManager
+from .schemas import (
+    AddSourceReq,
+    ChatMessage,
+    ChatReq,
+    CreateConversationReq,
+    DownloadModelReq,
+    ImportModelReq,
+    LoadModelReq,
+    SetActiveVersionReq,
+)
+
+settings.ensure_dirs()
+logging.basicConfig(level=getattr(logging, settings.log_level.upper(), logging.INFO))
+logger = logging.getLogger("ai-platform")
+
+app = FastAPI(title="Local AI Platform", version="3.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+registry = ModelRegistry()
+runtime_manager = RuntimeManager()
+conversation_store = ConversationStore()
+auto_updater = AutoUpdater(registry)
+
+
+# ── Health & Hardware ──────────────────────────────────────────
+
+
+@app.get("/health")
+def health():
+    return {
+        "ok": True,
+        "version": "3.0.0",
+        "loaded_model_id": runtime_manager.loaded_model_id,
+        "loaded_runtime": runtime_manager.loaded_runtime,
+    }
+
+
+@app.get("/hardware")
+def hardware():
+    return detect_hardware_summary()
+
+
+# ── Model Catalog (free models from GitHub) ────────────────────
+
+
+@app.get("/catalog")
+def catalog():
+    """Browse the curated catalog of free, open-weight models."""
+    return {"ok": True, "models": list_catalog_models()}
+
+
+@app.get("/catalog/recommended")
+def catalog_recommended():
+    """Get recommended starter models."""
+    return {"ok": True, "models": get_recommended_models()}
+
+
+@app.get("/catalog/fits-ram")
+def catalog_fits_ram(max_gb: float = 8.0):
+    """Get models that fit within a RAM budget."""
+    return {"ok": True, "models": filter_by_ram(max_gb)}
+
+
+# ── Models ─────────────────────────────────────────────────────
+
+
+@app.get("/models")
+def list_models():
+    return {"ok": True, "models": [m.model_dump() for m in registry.list_models()]}
+
+
+@app.get("/models/names")
+def model_names():
+    """Return all known model IDs (from registry + tracked sources) for autocomplete."""
+    ids = {m.model_id for m in registry.list_models()}
+    ids |= {s.model_id for s in auto_updater.list_sources()}
+    return {"ok": True, "names": sorted(ids)}
+
+
+@app.get("/models/{model_id}")
+def get_model(model_id: str):
+    try:
+        record = registry.get_model(model_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True, "model": record.model_dump()}
+
+
+@app.get("/models/{model_id}/versions")
+def list_versions(model_id: str):
+    try:
+        versions = registry.list_versions(model_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True, "versions": [v.model_dump() for v in versions]}
+
+
+@app.post("/models/download")
+def download_model(req: DownloadModelReq):
+    try:
+        record = registry.download_and_register(req)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {"ok": True, "model": record.model_dump()}
+
+
+@app.post("/models/import")
+def import_model(req: ImportModelReq):
+    try:
+        record = registry.import_local(req)
+    except (ValueError, FileNotFoundError) as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {"ok": True, "model": record.model_dump()}
+
+
+@app.post("/models/set-version")
+def set_version(req: SetActiveVersionReq):
+    try:
+        record = registry.set_active_version(req.model_id, req.version)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {"ok": True, "model": record.model_dump()}
+
+
+@app.post("/models/load")
+def load_model(req: LoadModelReq):
+    try:
+        record = registry.get_model(req.model_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+
+    if req.version:
+        version = next((v for v in record.versions if v.version == req.version), None)
+        if not version:
+            raise HTTPException(status_code=404, detail=f"Version {req.version} not found")
+    else:
+        version = record.active()
+
+    threads = req.threads or runtime_defaults.default_threads or None
+    runtime_manager.load(
+        record.runtime, req.model_id, version.file_path, threads=threads
+    )
+    return {
+        "ok": True,
+        "loaded_model_id": runtime_manager.loaded_model_id,
+        "loaded_runtime": runtime_manager.loaded_runtime,
+        "loaded_version": version.version,
+        "threads": threads,
+    }
+
+
+# ── Source Tracking ────────────────────────────────────────────
+
+
+@app.get("/sources")
+def list_sources():
+    sources = auto_updater.list_sources()
+    return {"ok": True, "sources": [asdict(s) for s in sources]}
+
+
+@app.post("/sources/add")
+def add_source(req: AddSourceReq):
+    try:
+        source = auto_updater.add_source(
+            repo_url=req.repo_url,
+            model_id=req.model_id,
+            runtime=req.runtime,
+            asset_pattern=req.asset_pattern,
+            license=req.license,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {"ok": True, "source": asdict(source)}
+
+
+@app.delete("/sources/{model_id}")
+def remove_source(model_id: str):
+    auto_updater.remove_source(model_id)
+    return {"ok": True}
+
+
+# ── Auto-Update ────────────────────────────────────────────────
+
+
+@app.post("/models/update")
+def check_all_updates():
+    """Check all tracked sources for new model releases."""
+    results = auto_updater.check_updates()
+    return {
+        "ok": True,
+        "results": [asdict(r) for r in results],
+    }
+
+
+@app.post("/models/update/{model_id}")
+def check_model_updates(model_id: str):
+    """Check a specific tracked source for new releases."""
+    try:
+        results = auto_updater.check_updates(model_id=model_id)
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    return {
+        "ok": True,
+        "results": [asdict(r) for r in results],
+    }
+
+
+# ── GitHub Discovery ──────────────────────────────────────────
+
+
+@app.get("/github/discover")
+def github_discover(repo_url: str):
+    """Discover model assets in a GitHub repository's releases."""
+    try:
+        owner, repo = parse_repo_url(repo_url)
+        assets = discover_model_assets(owner, repo)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return {"ok": True, "owner": owner, "repo": repo, "assets": assets}
+
+
+# ── Chat ───────────────────────────────────────────────────────
+
+
+@app.post("/chat")
+def chat(req: ChatReq):
+    runtime_manager.ensure_loaded()
+    if runtime_manager.loaded_model_id != req.model_id:
+        raise HTTPException(status_code=400, detail="Requested model is not loaded")
+
+    conv_id = req.conversation_id or str(uuid.uuid4())
+    for msg in req.messages:
+        conversation_store.append_message(conv_id, msg.role, msg.content)
+
+    # Inject system prompt — this is what makes it "your own" coding AI
+    has_system = any(m.role == "system" for m in req.messages)
+    full_messages = build_messages(
+        req.messages,
+        include_system=not has_system,
+        include_fewshot=False,
+    )
+
+    def stream():
+        chunks = []
+        for token in runtime_manager.runtime.stream_chat(
+            full_messages,
+            temperature=req.temperature,
+            max_tokens=req.max_tokens,
+        ):
+            chunks.append(token)
+            yield f"data: {json.dumps({'token': token})}\n\n"
+        final = "".join(chunks).strip()
+        conversation_store.append_message(conv_id, "assistant", final)
+        yield f"data: {json.dumps({'done': True, 'conversation_id': conv_id})}\n\n"
+
+    if req.stream:
+        return StreamingResponse(stream(), media_type="text/event-stream")
+
+    text = runtime_manager.runtime.chat(
+        full_messages,
+        temperature=req.temperature,
+        max_tokens=req.max_tokens,
+    )
+    conversation_store.append_message(conv_id, "assistant", text)
+    return {"ok": True, "output": text, "conversation_id": conv_id}
+
+
+# ── Conversations ──────────────────────────────────────────────
+
+
+@app.post("/conversations")
+def create_conversation(req: CreateConversationReq):
+    conv = conversation_store.create(req.title)
+    return {"ok": True, "conversation": conv}
+
+
+@app.get("/conversations")
+def list_conversations():
+    return {"ok": True, "conversations": conversation_store.list_all()}
+
+
+@app.get("/conversations/{conversation_id}")
+def get_conversation(conversation_id: str):
+    try:
+        conv = conversation_store.get(conversation_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Conversation not found")
+    return {"ok": True, "conversation": conv}
+
+
+@app.delete("/conversations/{conversation_id}")
+def delete_conversation(conversation_id: str):
+    conversation_store.delete(conversation_id)
+    return {"ok": True}
+
+
+# ── Static Frontend (production) ──────────────────────────────
+
+_FRONTEND_DIST = Path(__file__).resolve().parent.parent / "frontend" / "dist"
+if _FRONTEND_DIST.is_dir():
+    # Serve index.html for SPA routes (must come after API routes)
+    from fastapi.responses import FileResponse
+
+    @app.get("/app/{full_path:path}")
+    def spa_fallback(full_path: str):
+        return FileResponse(_FRONTEND_DIST / "index.html")
+
+    @app.get("/")
+    def root():
+        return FileResponse(_FRONTEND_DIST / "index.html")
+
+    app.mount("/", StaticFiles(directory=str(_FRONTEND_DIST), html=True), name="static")
+
+
+def main():
+    """Entry point for `ai-server` console script and direct execution."""
+    import uvicorn
+    port = int(os.environ.get("PORT", settings.port))
+    uvicorn.run(app, host=settings.host, port=port)

sage_ai_cli-1.0.0/backend/auto_updater.py

@@ -0,0 +1,210 @@
+"""Auto-update engine for model discovery and version tracking.
+
+Maintains a sources.json of tracked GitHub repositories.
+Periodically checks for new releases, compares against the local
+registry (by version tag + SHA256), and downloads only new versions.
+"""
+
+import fnmatch
+import json
+import logging
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .config import settings
+from .github_client import (
+    discover_model_assets,
+    extract_version_number,
+    parse_repo_url,
+)
+from .model_registry import ModelRegistry
+from .schemas import DownloadModelReq
+
+logger = logging.getLogger("ai-platform.updater")
+
+
+@dataclass
+class TrackedSource:
+    model_id: str
+    owner: str
+    repo: str
+    runtime: str = "llama_cpp"
+    asset_pattern: str = "*.gguf"  # glob pattern to filter assets
+    license: str | None = None
+    last_checked: str | None = None
+    auto_update: bool = True
+
+
+@dataclass
+class UpdateResult:
+    model_id: str
+    new_versions: list[str] = field(default_factory=list)
+    skipped_duplicate: int = 0
+    skipped_existing: int = 0
+    errors: list[str] = field(default_factory=list)
+
+
+class AutoUpdater:
+    def __init__(self, registry: ModelRegistry) -> None:
+        self.registry = registry
+        self.sources_path = settings.config_dir / "sources.json"
+        if not self.sources_path.exists():
+            self.sources_path.write_text("[]", encoding="utf-8")
+
+    # ── Source management ──────────────────────────────────────
+
+    def list_sources(self) -> list[TrackedSource]:
+        raw = json.loads(self.sources_path.read_text(encoding="utf-8"))
+        return [TrackedSource(**s) for s in raw]
+
+    def add_source(
+        self,
+        repo_url: str,
+        model_id: str,
+        runtime: str = "llama_cpp",
+        asset_pattern: str = "*.gguf",
+        license: str | None = None,
+    ) -> TrackedSource:
+        owner, repo = parse_repo_url(repo_url)
+
+        sources = self.list_sources()
+        for s in sources:
+            if s.model_id == model_id:
+                raise ValueError(f"Source already tracked: {model_id}")
+
+        source = TrackedSource(
+            model_id=model_id,
+            owner=owner,
+            repo=repo,
+            runtime=runtime,
+            asset_pattern=asset_pattern,
+            license=license,
+        )
+        sources.append(source)
+        self._save_sources(sources)
+        logger.info("Added source: %s/%s -> %s", owner, repo, model_id)
+        return source
+
+    def remove_source(self, model_id: str) -> None:
+        sources = self.list_sources()
+        sources = [s for s in sources if s.model_id != model_id]
+        self._save_sources(sources)
+        logger.info("Removed source: %s", model_id)
+
+    # ── Update checking ───────────────────────────────────────
+
+    def check_updates(self, model_id: str | None = None) -> list[UpdateResult]:
+        """Check one or all tracked sources for new releases."""
+        sources = self.list_sources()
+        if model_id:
+            sources = [s for s in sources if s.model_id == model_id]
+            if not sources:
+                raise KeyError(f"No tracked source: {model_id}")
+
+        results = []
+        for source in sources:
+            if not source.auto_update and model_id is None:
+                continue
+            result = self._check_source(source)
+            results.append(result)
+
+        # Update last_checked timestamps
+        all_sources = self.list_sources()
+        checked_ids = {r.model_id for r in results}
+        for s in all_sources:
+            if s.model_id in checked_ids:
+                s.last_checked = datetime.now(timezone.utc).isoformat()
+        self._save_sources(all_sources)
+
+        return results
+
+    def _check_source(self, source: TrackedSource) -> UpdateResult:
+        result = UpdateResult(model_id=source.model_id)
+
+        try:
+            assets = discover_model_assets(source.owner, source.repo)
+        except Exception as exc:
+            result.errors.append(f"Failed to query GitHub: {exc}")
+            return result
+
+        # Filter by asset pattern
+        matching = [
+            a for a in assets
+            if fnmatch.fnmatch(a["asset_name"].lower(), source.asset_pattern.lower())
+        ]
+
+        if not matching:
+            logger.info("No matching assets for %s (pattern: %s)", source.model_id, source.asset_pattern)
+            return result
+
+        # Get existing version tags and hashes for deduplication
+        existing_tags = set()
+        existing_hashes = set()
+        try:
+            record = self.registry.get_model(source.model_id)
+            for v in record.versions:
+                if v.source_url:
+                    existing_tags.add(self._tag_from_url_or_version(v))
+                if v.sha256:
+                    existing_hashes.add(v.sha256.lower())
+        except KeyError:
+            pass  # Model not yet registered
+
+        for asset in matching:
+            tag = asset["tag"]
+            normalized_tag = extract_version_number(tag)
+
+            # Dedup by version tag
+            if tag in existing_tags or normalized_tag in existing_tags:
+                result.skipped_existing += 1
+                logger.debug("Skipping existing tag %s for %s", tag, source.model_id)
+                continue
+
+            # Download and register
+            try:
+                req = DownloadModelReq(
+                    model_id=source.model_id,
+                    source_url=asset["download_url"],
+                    runtime=source.runtime,
+                    filename=asset["asset_name"],
+                    license=source.license,
+                    format=asset.get("format"),
+                )
+                record = self.registry.download_and_register(req)
+
+                # Check SHA256 dedup after download
+                latest = record.active()
+                if latest.sha256 and latest.sha256.lower() in existing_hashes:
+                    result.skipped_duplicate += 1
+                    logger.info(
+                        "Downloaded %s tag %s but SHA256 matches existing version (kept as new version entry)",
+                        source.model_id,
+                        tag,
+                    )
+                else:
+                    existing_hashes.add(latest.sha256.lower() if latest.sha256 else "")
+
+                existing_tags.add(tag)
+                existing_tags.add(normalized_tag)
+                result.new_versions.append(tag)
+                logger.info("Downloaded new version %s for %s", tag, source.model_id)
+            except Exception as exc:
+                result.errors.append(f"Failed to download {tag}: {exc}")
+                logger.error("Download failed for %s %s: %s", source.model_id, tag, exc)
+
+        return result
+
+    # ── Helpers ────────────────────────────────────────────────
+
+    def _tag_from_url_or_version(self, version) -> str:
+        """Extract a tag-like identifier from a version."""
+        if version.source_url and "/releases/download/" in version.source_url:
+            parts = version.source_url.split("/releases/download/")
+            if len(parts) > 1:
+                return parts[1].split("/")[0]
+        return f"v{version.version}"
+
+    def _save_sources(self, sources: list[TrackedSource]) -> None:
+        data = [asdict(s) for s in sources]
+        self.sources_path.write_text(json.dumps(data, indent=2), encoding="utf-8")

sage_ai_cli-1.0.0/backend/config.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+_BASE = Path(__file__).resolve().parent.parent
+
+
+class RuntimeConfig(BaseModel):
+    default_runtime: str = "llama_cpp"
+    default_threads: int = 0
+    default_temperature: float = 0.3
+    default_max_tokens: int = 512
+    default_top_p: float = 0.95
+
+
+class AppSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="AI_PLATFORM_", extra="ignore")
+    host: str = "0.0.0.0"
+    port: int = 8090
+    models_dir: Path = _BASE / "models"
+    config_dir: Path = _BASE / "config"
+    data_dir: Path = _BASE / "data"
+    log_level: str = "INFO"
+
+    def ensure_dirs(self) -> None:
+        self.models_dir.mkdir(parents=True, exist_ok=True)
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+
+settings = AppSettings()
+runtime_defaults = RuntimeConfig()