yagami 0.4.1__py3-none-any.whl

yagami/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.1"

yagami/api/config.py

@@ -0,0 +1,118 @@
+"""Read + write `config/yagami.toml` from the browser.
+
+GET returns the current config plus a `defaults` snapshot so the UI can
+show "reset to default" affordances. Secrets are never in this file (they
+live in the OS keyring) - there is nothing to redact, but if the config
+schema ever grows a secret-like field, redact it here before returning.
+
+PUT accepts a partial JSON patch (any subset of YagamiConfig fields).
+Validates against the full pydantic schema after merging. On success,
+writes the file, invalidates the get_config LRU cache, pushes the new
+effective RoutingConfig into the live RoutingPolicy (see set_policy /
+RoutingPolicy.update_config), and returns the new config. routing.* changes
+(default backend, spend cap, threshold, active profile) apply on the very
+next turn, no restart. Backend model/URL/API-key changes still need a
+process restart - those backends were constructed once at boot.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, ValidationError
+
+from ..config import YagamiConfig, effective_routing, get_config, write_config
+from ..router.policy import RoutingPolicy
+from ..router.prompts import PHI_MEDICAL_SYSTEM_PROMPT, PHI_SYSTEM_PROMPT
+
+router = APIRouter(prefix="/api/config", tags=["config"])
+
+# Set once at app startup (main.build_app) via set_policy() - same pattern as
+# sessions_api.set_store(). Lets a live PUT /api/config (including a profile
+# switch) take effect on the policy's next decide() call without a restart.
+_policy: RoutingPolicy | None = None
+
+
+def set_policy(policy: RoutingPolicy) -> None:
+    global _policy
+    _policy = policy
+
+
+def _config_payload() -> dict:
+    cfg = get_config()
+    return {
+        "config": cfg.model_dump(mode="json"),
+        "defaults": YagamiConfig().model_dump(mode="json"),
+        "prompts": {
+            "phi_default": PHI_SYSTEM_PROMPT,
+            "phi_medical_default": PHI_MEDICAL_SYSTEM_PROMPT,
+        },
+        "notes": {
+            "phi_must_be_local": (
+                "Locked on. Disabling would let PHI prompts reach cloud "
+                "backends - defeats the local-first guarantee."
+            ),
+            "live_reload": (
+                "Routing settings (default_backend, daily_spend_cap_usd, "
+                "long_message_token_threshold, active_profile) take effect on "
+                "the next turn. Backend model name / URL changes require "
+                "restarting uvicorn."
+            ),
+            "storage_encryption": (
+                "Yagami does not apply application-level database encryption. "
+                "Use BitLocker, FileVault, or full-disk encryption to protect "
+                "the local database and saved image attachments at rest."
+            ),
+        },
+    }
+
+
+@router.get("")
+async def get_config_endpoint() -> dict:
+    return _config_payload()
+
+
+class ConfigPatch(BaseModel):
+    """Loose patch shape - any field is optional. The server merges and
+    re-validates against the full YagamiConfig pydantic model before
+    persisting.
+
+    `profiles` is a shallow merge like every other section: PUT-ing
+    `{"profiles": {"work": {...}}}` replaces the *entire* "work" entry, it
+    doesn't deep-merge individual override fields into an existing one. Send
+    the full profile body each time.
+    """
+
+    ollama: dict | None = None
+    anthropic: dict | None = None
+    stability: dict | None = None
+    openai: dict | None = None
+    mistral: dict | None = None
+    groq: dict | None = None
+    openrouter: dict | None = None
+    gemini: dict | None = None
+    routing: dict | None = None
+    profiles: dict[str, dict] | None = None
+    privacy: dict | None = None
+
+
+@router.put("")
+async def put_config(patch: ConfigPatch) -> dict:
+    cfg = get_config()
+    merged = cfg.model_dump(mode="json")
+    for section, body in patch.model_dump(exclude_none=True).items():
+        merged.setdefault(section, {}).update(body)
+
+    # Always pin phi_must_be_local on - defense in depth in case the UI
+    # somehow PUTs it false despite the locked toggle. No profile can touch
+    # this either - see ProfileOverrides.
+    merged.setdefault("routing", {})["phi_must_be_local"] = True
+
+    try:
+        new_cfg = YagamiConfig.model_validate(merged)
+    except ValidationError as exc:
+        raise HTTPException(422, exc.errors())
+
+    path = write_config(new_cfg)
+    if _policy is not None:
+        _policy.update_config(effective_routing(new_cfg))
+    return {"ok": True, "path": str(path), **_config_payload()}

yagami/api/costs.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Query
+
+from ..config import effective_routing, get_config
+from ..telemetry.costs import spend_session_usd, spend_today_usd
+
+router = APIRouter(prefix="/api/costs", tags=["costs"])
+
+
+@router.get("")
+async def costs(session_id: str | None = Query(default=None)) -> dict:
+    today = await spend_today_usd()
+    session = await spend_session_usd(session_id) if session_id else 0.0
+    cap = effective_routing(get_config()).daily_spend_cap_usd
+    return {
+        "today_usd": round(today, 4),
+        "session_usd": round(session, 4),
+        "daily_cap_usd": cap,
+        "cap_remaining_usd": max(0.0, cap - today) if cap > 0 else None,
+        "cap_exceeded": cap > 0 and today >= cap,
+    }

yagami/api/decisions.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import re
+import time
+
+from fastapi import APIRouter, HTTPException, Query, Response
+from pydantic import BaseModel
+
+from ..storage.db import get_db
+from ..telemetry.decisions import export_decisions_csv, list_decisions
+
+router = APIRouter(prefix="/api/decisions", tags=["decisions"])
+
+
+@router.get("")
+async def get_decisions(
+    session_id: str | None = Query(default=None),
+    limit: int = Query(default=100, ge=1, le=1000),
+) -> dict:
+    rows = await list_decisions(session_id=session_id, limit=limit)
+    return {"decisions": rows, "count": len(rows)}
+
+
+@router.get("/export")
+async def export_decisions(
+    session_id: str | None = Query(default=None),
+    limit: int = Query(default=10_000, ge=1, le=100_000),
+) -> Response:
+    """Download the Privacy Ledger as CSV - see telemetry/decisions.py for
+    what's included. Same scrubbing as the UI ledger view; nothing extra
+    leaks through this export."""
+    csv_text = await export_decisions_csv(session_id=session_id, limit=limit)
+    # session_id is caller-supplied; never interpolate it into a header
+    # unsanitized. Session ids are uuid4().hex (see chat/session.py) - a
+    # non-matching value just falls back to the unscoped filename.
+    suffix = ""
+    if session_id and re.fullmatch(r"[a-f0-9]{8,64}", session_id):
+        suffix = f"-{session_id}"
+    filename = f"yagami-privacy-ledger{suffix}.csv"
+    return Response(
+        content=csv_text,
+        media_type="text/csv",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+class FeedbackPayload(BaseModel):
+    rating: int  # -1 (thumb down) or 1 (thumb up)
+
+
+@router.post("/{decision_id}/feedback")
+async def post_feedback(decision_id: int, payload: FeedbackPayload) -> dict:
+    if payload.rating not in (-1, 1):
+        raise HTTPException(400, "rating must be -1 or 1")
+    db = get_db()
+    async with db.execute("SELECT 1 FROM decisions WHERE id = ?", (decision_id,)) as cur:
+        if await cur.fetchone() is None:
+            raise HTTPException(404, f"decision {decision_id} not found")
+    # Latest feedback for a decision wins - overwrite any prior row so the
+    # user can flip their vote without leaving stale rating data.
+    await db.execute("DELETE FROM feedback WHERE decision_id = ?", (decision_id,))
+    await db.execute(
+        "INSERT INTO feedback (decision_id, rating, created_at) VALUES (?, ?, ?)",
+        (decision_id, payload.rating, int(time.time() * 1000)),
+    )
+    await db.commit()
+    return {"ok": True, "decision_id": decision_id, "rating": payload.rating}
+
+
+@router.delete("/{decision_id}/feedback")
+async def delete_feedback(decision_id: int) -> dict:
+    db = get_db()
+    async with db.execute("SELECT 1 FROM decisions WHERE id = ?", (decision_id,)) as cur:
+        if await cur.fetchone() is None:
+            raise HTTPException(404, f"decision {decision_id} not found")
+    cur = await db.execute("DELETE FROM feedback WHERE decision_id = ?", (decision_id,))
+    await db.commit()
+    return {"ok": True, "decision_id": decision_id, "deleted": cur.rowcount > 0}

yagami/api/ingest.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import base64
+
+from fastapi import APIRouter, File, HTTPException, UploadFile
+
+from ..ingest.extract import extract
+
+router = APIRouter(prefix="/api/ingest", tags=["ingest"])
+
+_MAX_BYTES = 20 * 1024 * 1024  # 20 MB hard cap
+_IMAGE_MIMES = {"image/png", "image/jpeg", "image/gif", "image/webp"}
+
+
+@router.post("")
+async def ingest(file: UploadFile = File(...)) -> dict:
+    # Read one byte past the limit so oversized uploads are rejected without
+    # first copying an arbitrarily large file into process memory.
+    blob = await file.read(_MAX_BYTES + 1)
+    if len(blob) > _MAX_BYTES:
+        raise HTTPException(413, f"file too large ({len(blob)} > {_MAX_BYTES} bytes)")
+
+    mime = file.content_type or ""
+    fname = file.filename or "upload"
+    low = fname.lower()
+    if mime in _IMAGE_MIMES or low.endswith((".png", ".jpg", ".jpeg", ".gif", ".webp")):
+        # Normalize mime if browser was vague
+        if low.endswith(".png"):
+            mime = "image/png"
+        elif low.endswith((".jpg", ".jpeg")):
+            mime = "image/jpeg"
+        elif low.endswith(".gif"):
+            mime = "image/gif"
+        elif low.endswith(".webp"):
+            mime = "image/webp"
+        return {
+            "kind": "image",
+            "filename": fname,
+            "media_type": mime,
+            "bytes": len(blob),
+            "data_b64": base64.b64encode(blob).decode("ascii"),
+        }
+
+    doc = extract(filename=fname, mime=mime, blob=blob)
+    if doc.error:
+        raise HTTPException(415, doc.error)
+    return {
+        "kind": "document",
+        "filename": doc.filename,
+        "mime": doc.mime,
+        "text": doc.text,
+        "truncated": doc.truncated,
+        "bytes": len(blob),
+        "chars": len(doc.text),
+    }

yagami/api/kb.py

@@ -0,0 +1,55 @@
+"""Folder-based document knowledge base admin: index a directory, list
+what's indexed, and remove a source. See memory/documents.py for the
+storage/search implementation and skills/kb_recall.py for how the LLM
+queries what's indexed here.
+
+Trust note: like `PUT /api/config` (arbitrary TOML rewrite) and the file
+ingest endpoint (arbitrary uploaded file content), this lets anyone who can
+reach the local API make the server read files from disk - `index_folder`
+takes a path and walks it recursively. That's consistent with Yagami's
+existing single-user local-app trust model (bind to 127.0.0.1, as the
+`yagami` CLI already defaults to), not a new category of exposure, but it's
+worth stating plainly: don't expose this port beyond localhost.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from ..config import get_config
+from ..memory import documents
+from ..memory.embedder import Embedder
+
+router = APIRouter(prefix="/api/kb", tags=["kb"])
+
+
+class IndexRequest(BaseModel):
+    path: str
+
+
+@router.post("/index")
+async def index_folder(req: IndexRequest) -> dict:
+    folder = Path(req.path).expanduser()
+    if not folder.exists() or not folder.is_dir():
+        raise HTTPException(400, f"not a directory: {folder}")
+    cfg = get_config()
+    embedder = Embedder(url=cfg.ollama.url, model=cfg.memory.embedding_model)
+    summary = await documents.index_folder(folder, embedder=embedder)
+    return {"ok": True, "folder": str(folder), **summary}
+
+
+@router.get("")
+async def list_indexed() -> dict:
+    sources = await documents.list_sources()
+    return {"sources": sources, "count": len(sources)}
+
+
+@router.delete("/source")
+async def delete_source(path: str) -> dict:
+    n = await documents.delete_source(path)
+    if n == 0:
+        raise HTTPException(404, f"no indexed chunks for {path!r}")
+    return {"ok": True, "source_path": path, "deleted_chunks": n}

yagami/api/mcp.py

@@ -0,0 +1,21 @@
+"""Read-only status for connected MCP servers. See skills/mcp_manager.py for
+the actual client/connection logic - this just reports what it found.
+Connection failures are logged at startup and don't crash boot (one bad
+server config shouldn't take down the app), so this endpoint is how you'd
+actually notice one didn't come up.
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from ..skills.mcp_manager import get_manager
+
+router = APIRouter(prefix="/api/mcp", tags=["mcp"])
+
+
+@router.get("")
+async def mcp_status() -> dict:
+    manager = get_manager()
+    tools = manager.status() if manager is not None else []
+    return {"connected": manager is not None, "tools": tools, "count": len(tools)}

yagami/api/memory.py

@@ -0,0 +1,124 @@
+"""Browser-facing endpoints for the cross-session memory store.
+
+GET  /api/memory                - list recent observations, paginated
+GET  /api/memory/search?q=...   - keyword search via FTS5 (no embed call needed)
+DELETE /api/memory/{id}         - remove a single observation + its vec row
+GET  /api/memory/stats          - counts by status, total bytes
+
+PHI rows are NOT redacted in this endpoint - the user is reviewing their
+OWN memory in their OWN browser, on-device. Surfacing PHI to the user
+is correct; surfacing it to a cloud-text turn is not (the retriever's
+PHI quarantine handles that).
+"""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query
+
+from ..memory import store as memory_store
+from ..storage.db import get_db
+
+router = APIRouter(prefix="/api/memory", tags=["memory"])
+
+
+@router.get("")
+async def list_observations(
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+) -> dict:
+    db = get_db()
+    async with db.execute(
+        """SELECT id, session_id, role, text, sensitivity, source_app,
+                  ttl_until, created_at, embedding_status, chunk_index, parent_id
+           FROM observations
+           ORDER BY id DESC
+           LIMIT ? OFFSET ?""",
+        (limit, offset),
+    ) as cur:
+        rows = await cur.fetchall()
+    return {
+        "observations": [
+            {
+                "id": int(r[0]),
+                "session_id": str(r[1]),
+                "role": str(r[2]),
+                "text": str(r[3]),
+                "sensitivity": str(r[4]),
+                "source_app": str(r[5]),
+                "ttl_until": r[6],
+                "created_at": int(r[7]),
+                "embedding_status": str(r[8]),
+                "chunk_index": int(r[9]),
+                "parent_id": r[10],
+            }
+            for r in rows
+        ],
+        "count": len(rows),
+    }
+
+
+@router.get("/search")
+async def search(
+    q: str = Query(min_length=1, max_length=500),
+    limit: int = Query(default=20, ge=1, le=100),
+) -> dict:
+    db = get_db()
+    cleaned = q.replace('"', "").strip()
+    if not cleaned:
+        return {"observations": [], "count": 0}
+    try:
+        async with db.execute(
+            """SELECT o.id, o.session_id, o.role, o.text, o.sensitivity,
+                      o.created_at, o.embedding_status
+               FROM observations_fts f
+               JOIN observations o ON o.id = f.rowid
+               WHERE f.text MATCH ?
+               ORDER BY rank
+               LIMIT ?""",
+            (cleaned, limit),
+        ) as cur:
+            rows = await cur.fetchall()
+    except Exception as exc:  # noqa: BLE001 - FTS MATCH parser is picky
+        raise HTTPException(400, f"search failed: {exc}")
+    return {
+        "observations": [
+            {
+                "id": int(r[0]),
+                "session_id": str(r[1]),
+                "role": str(r[2]),
+                "text": str(r[3]),
+                "sensitivity": str(r[4]),
+                "created_at": int(r[5]),
+                "embedding_status": str(r[6]),
+            }
+            for r in rows
+        ],
+        "count": len(rows),
+    }
+
+
+@router.delete("/{observation_id}")
+async def delete_observation(observation_id: int) -> dict:
+    db = get_db()
+    async with db.execute("SELECT 1 FROM observations WHERE id=?", (observation_id,)) as cur:
+        if await cur.fetchone() is None:
+            raise HTTPException(404, f"observation {observation_id} not found")
+    await db.execute("DELETE FROM observations_vec WHERE rowid=?", (observation_id,))
+    await db.execute("DELETE FROM observations WHERE id=?", (observation_id,))
+    await db.commit()
+    return {"ok": True, "deleted": observation_id}
+
+
+@router.get("/stats")
+async def memory_stats() -> dict:
+    counts = await memory_store.count_by_status()
+    db = get_db()
+    async with db.execute("SELECT COUNT(*) FROM observations") as cur:
+        total = (await cur.fetchone())[0]
+    async with db.execute("SELECT COUNT(*) FROM observations_vec") as cur:
+        vec_total = (await cur.fetchone())[0]
+    return {
+        "total": int(total),
+        "vec_total": int(vec_total),
+        "by_status": counts,
+    }