chore: initial commit — existing single-user document scanner codebase

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/api/documents.py

@@ -0,0 +1,101 @@
+from datetime import datetime, timezone
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException, Query
+from services import storage, extractor, classifier
+
+router = APIRouter(prefix="/api/documents", tags=["documents"])
+
+ALLOWED_MIME_TYPES = {
+    "application/pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/msword",
+    "text/plain",
+    "text/markdown",
+    "image/png",
+    "image/jpeg",
+    "image/jpg",
+    "image/tiff",
+    "image/webp",
+}
+
+
+@router.post("/upload")
+async def upload_document(
+    file: UploadFile = File(...),
+    auto_classify: bool = Form(True),
+):
+    content = await file.read()
+    if len(content) == 0:
+        raise HTTPException(400, "Empty file")
+
+    mime = file.content_type or "application/octet-stream"
+
+    saved = storage.save_upload(content, file.filename or "upload", mime)
+    text = extractor.extract_text(saved["path"], mime)
+
+    now = datetime.now(timezone.utc).isoformat()
+    meta = {
+        "id": saved["id"],
+        "original_name": file.filename or "upload",
+        "filename": saved["filename"],
+        "mime_type": mime,
+        "size_bytes": len(content),
+        "extracted_text": text,
+        "topics": [],
+        "created_at": now,
+        "classified_at": None,
+    }
+    storage.save_metadata(meta)
+
+    if auto_classify:
+        try:
+            topics = await classifier.classify_document(saved["id"])
+            meta["topics"] = topics
+            meta["classified_at"] = datetime.now(timezone.utc).isoformat()
+        except Exception as e:
+            # Classification failure is non-fatal; document is still saved
+            meta["classification_error"] = str(e)
+
+    return meta
+
+
+@router.get("")
+async def list_documents(
+    topic: str | None = Query(None),
+    page: int = Query(1, ge=1),
+    per_page: int = Query(20, ge=1, le=100),
+):
+    docs = storage.list_metadata(topic=topic)
+    total = len(docs)
+    start = (page - 1) * per_page
+    return {"items": docs[start : start + per_page], "total": total, "page": page, "per_page": per_page}
+
+
+@router.get("/{doc_id}")
+async def get_document(doc_id: str):
+    meta = storage.get_metadata(doc_id)
+    if meta is None:
+        raise HTTPException(404, "Document not found")
+    return meta
+
+
+@router.delete("/{doc_id}")
+async def delete_document(doc_id: str):
+    ok = storage.delete_document(doc_id)
+    if not ok:
+        raise HTTPException(404, "Document not found")
+    return {"success": True}
+
+
+@router.post("/{doc_id}/classify")
+async def classify_document(doc_id: str, body: dict = {}):
+    meta = storage.get_metadata(doc_id)
+    if meta is None:
+        raise HTTPException(404, "Document not found")
+
+    topic_names = body.get("topics") if body else None
+    try:
+        topics = await classifier.classify_document(doc_id, topic_names)
+    except Exception as e:
+        raise HTTPException(500, f"Classification failed: {e}")
+
+    return {"topics": topics}

backend/api/settings.py

@@ -0,0 +1,84 @@
+import time
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import storage
+from config import DEFAULT_SYSTEM_PROMPT
+from ai import get_provider
+
+router = APIRouter(prefix="/api/settings", tags=["settings"])
+
+
+class SettingsPatch(BaseModel):
+    system_prompt: str | None = None
+    active_provider: str | None = None
+    providers: dict | None = None
+
+
+class TestProviderRequest(BaseModel):
+    provider: str
+
+
+@router.get("")
+async def get_settings():
+    settings = storage.load_settings()
+    return storage.settings_masked(settings)
+
+
+@router.patch("")
+async def patch_settings(body: SettingsPatch):
+    settings = storage.load_settings()
+
+    if body.system_prompt is not None:
+        settings["system_prompt"] = body.system_prompt
+
+    if body.active_provider is not None:
+        valid = {"anthropic", "openai", "ollama", "lmstudio"}
+        if body.active_provider not in valid:
+            raise HTTPException(400, f"Invalid provider. Must be one of: {valid}")
+        settings["active_provider"] = body.active_provider
+
+    if body.providers is not None:
+        # Deep merge per-provider config
+        for prov_name, prov_cfg in body.providers.items():
+            if prov_name not in settings.get("providers", {}):
+                settings.setdefault("providers", {})[prov_name] = {}
+            existing = settings["providers"][prov_name]
+            for key, val in prov_cfg.items():
+                # Don't overwrite api_key if it comes in masked (contains ****)
+                if key == "api_key" and val and "****" in str(val):
+                    continue
+                existing[key] = val
+
+    storage.save_settings(settings)
+    return storage.settings_masked(settings)
+
+
+@router.post("/test-provider")
+async def test_provider(body: TestProviderRequest):
+    settings = storage.load_settings()
+    # Temporarily switch active provider for the test
+    test_settings = dict(settings)
+    test_settings["active_provider"] = body.provider
+
+    try:
+        provider = get_provider(test_settings)
+    except ValueError as e:
+        raise HTTPException(400, str(e))
+
+    start = time.monotonic()
+    try:
+        ok = await provider.health_check()
+    except Exception as e:
+        return {"ok": False, "message": str(e), "latency_ms": 0}
+
+    latency_ms = int((time.monotonic() - start) * 1000)
+    return {
+        "ok": ok,
+        "message": "Connection successful" if ok else "Health check failed",
+        "latency_ms": latency_ms,
+    }
+
+
+@router.get("/default-prompt")
+async def get_default_prompt():
+    return {"system_prompt": DEFAULT_SYSTEM_PROMPT}

backend/api/topics.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from services import storage, classifier
+
+router = APIRouter(prefix="/api/topics", tags=["topics"])
+
+
+class TopicCreate(BaseModel):
+    name: str
+    description: str = ""
+    color: str = "#6366f1"
+
+
+class TopicUpdate(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    color: str | None = None
+
+
+class SuggestRequest(BaseModel):
+    document_id: str
+
+
+@router.get("")
+async def list_topics():
+    topics = storage.load_topics()
+    counts = storage.topic_doc_counts()
+    for t in topics:
+        t["doc_count"] = counts.get(t["name"], 0)
+    return {"topics": topics}
+
+
+@router.post("")
+async def create_topic(body: TopicCreate):
+    topic = storage.create_topic(body.name, body.description, body.color)
+    topic["doc_count"] = 0
+    return topic
+
+
+@router.patch("/{topic_id}")
+async def update_topic(topic_id: str, body: TopicUpdate):
+    topic = storage.update_topic(
+        topic_id,
+        name=body.name,
+        description=body.description,
+        color=body.color,
+    )
+    if topic is None:
+        raise HTTPException(404, "Topic not found")
+    counts = storage.topic_doc_counts()
+    topic["doc_count"] = counts.get(topic["name"], 0)
+    return topic
+
+
+@router.delete("/{topic_id}")
+async def delete_topic(topic_id: str):
+    name = storage.delete_topic(topic_id)
+    if name is None:
+        raise HTTPException(404, "Topic not found")
+    return {"success": True, "removed_from_documents": True}
+
+
+@router.post("/suggest")
+async def suggest_topics(body: SuggestRequest):
+    meta = storage.get_metadata(body.document_id)
+    if meta is None:
+        raise HTTPException(404, "Document not found")
+    try:
+        suggestions = await classifier.suggest_topics_for_document(body.document_id)
+    except Exception as e:
+        raise HTTPException(500, f"Suggestion failed: {e}")
+    return {"suggested": suggestions}