mednotes-opencode 0.1.0

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/cli.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python
+"""Internal JSON CLI for /mednotes:pdf-library."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from mednotes.domains.wiki.capabilities.pdf import config as config_mod
+from mednotes.domains.wiki.capabilities.pdf import doctor, ingest
+from mednotes.kernel.base import JsonObject, JsonObjectAdapter
+
+EXIT_OK = 0
+EXIT_USAGE = 2
+EXIT_VALIDATION = 3
+EXIT_IO = 5
+
+
+def scan_dry_run(cfg: config_mod.PdfLibraryConfig, *, app_home: Path | None = None) -> JsonObject:
+    return _as_payload(ingest.scan_dry_run(cfg, app_home=app_home))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        payload = dispatch(args)
+    except Exception as exc:
+        payload = _as_payload({
+            "schema": "medical-notes-workbench.pdf-library-error.v1",
+            "status": "failed",
+            "phase": getattr(args, "command", "unknown"),
+            "error": type(exc).__name__,
+            "message": str(exc),
+        })
+        _emit(payload)
+        return EXIT_IO
+    _emit(payload)
+    status = _payload_status(payload)
+    if status in {"blocked", "blocked_vault_guard_required"}:
+        return EXIT_VALIDATION
+    if status == "failed":
+        return EXIT_IO
+    return EXIT_OK
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="pdf-library")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    doctor_p = sub.add_parser("doctor")
+    doctor_p.add_argument("--json", action="store_true")
+    doctor_p.add_argument("--config", type=Path)
+    doctor_p.add_argument("--path", "--pdf-dir", dest="paths", type=Path, action="append")
+
+    setup_p = sub.add_parser("setup")
+    setup_p.add_argument("--json", action="store_true")
+    setup_p.add_argument("--dry-run", action="store_true")
+
+    tui_p = sub.add_parser("tui")
+    tui_p.add_argument("--note", type=Path)
+    tui_p.add_argument("--image-backend", default=None)
+    tui_p.add_argument("--open-mode", choices=["inline", "split-auto"], default="inline")
+
+    ingest_p = sub.add_parser("ingest")
+    ingest_sub = ingest_p.add_subparsers(dest="ingest_command", required=True)
+    scan_p = ingest_sub.add_parser("scan")
+    scan_p.add_argument("--dry-run", action="store_true", required=True)
+    scan_p.add_argument("--json", action="store_true")
+    scan_p.add_argument("--config", type=Path)
+    scan_p.add_argument("--path", "--pdf-dir", dest="paths", type=Path, action="append")
+    add_p = ingest_sub.add_parser("add")
+    add_p.add_argument("pdfs", type=Path, nargs="+")
+    add_p.add_argument("--json", action="store_true")
+    remove_p = ingest_sub.add_parser("remove")
+    remove_p.add_argument("--pdf-sha256", required=True)
+    remove_p.add_argument("--json", action="store_true")
+    reindex_p = ingest_sub.add_parser("reindex")
+    reindex_p.add_argument("--pdf-sha256")
+    reindex_p.add_argument("--path", type=Path)
+    reindex_p.add_argument("--json", action="store_true")
+
+    search_p = sub.add_parser("search")
+    group = search_p.add_mutually_exclusive_group(required=False)
+    group.add_argument("--query")
+    group.add_argument("--note", type=Path)
+    search_p.add_argument("--anchor-id", default="")
+    search_p.add_argument("--provider", default="local")
+    search_p.add_argument("--top-k", type=int, default=20)
+    search_p.add_argument("--json", action="store_true")
+
+    insert_p = sub.add_parser("insert")
+    insert_sub = insert_p.add_subparsers(dest="insert_command", required=True)
+    preview_p = insert_sub.add_parser("preview")
+    preview_p.add_argument("--note", type=Path, required=True)
+    preview_p.add_argument("--figure-uid", required=True)
+    preview_p.add_argument("--anchor-id", default="")
+    preview_p.add_argument("--section", action="append", dest="section_path")
+    preview_p.add_argument("--crop", type=Path)
+    preview_p.add_argument("--json", action="store_true")
+    apply_p = insert_sub.add_parser("apply")
+    apply_p.add_argument("--preview-receipt", type=Path, required=True)
+    apply_p.add_argument("--confirm", action="store_true")
+    apply_p.add_argument("--json", action="store_true")
+    return parser
+
+
+def dispatch(args: argparse.Namespace) -> JsonObject:
+    if args.command == "doctor":
+        cfg = config_mod.load_pdf_library_config(config_path=args.config, cli_paths=args.paths)
+        return _as_payload(doctor.run_doctor(cfg=cfg))
+    if args.command == "setup":
+        return _as_payload(doctor.setup_payload(dry_run=args.dry_run))
+    if args.command == "tui":
+        from mednotes.domains.wiki.capabilities.pdf.tui.app import PdfLibraryApp
+        from mednotes.domains.wiki.capabilities.pdf.tui.state import PdfLibraryState
+
+        app = PdfLibraryApp(state=PdfLibraryState(selected_note=args.note), image_backend=args.image_backend or "auto")
+        app.run()
+        return _as_payload({"schema": "medical-notes-workbench.pdf-library-tui.v1", "status": "closed", "phase": "tui"})
+    if args.command == "ingest":
+        if args.ingest_command == "scan":
+            cfg = config_mod.load_pdf_library_config(config_path=args.config, cli_paths=args.paths)
+            return _as_payload(ingest.scan_dry_run(cfg))
+        if args.ingest_command == "add":
+            return _as_payload(ingest.add_pdfs(args.pdfs))
+        if args.ingest_command == "remove":
+            return _as_payload(ingest.remove_pdf(pdf_sha256=args.pdf_sha256))
+        if args.ingest_command == "reindex":
+            return _as_payload(ingest.reindex_pdf(pdf_sha256=args.pdf_sha256, path=args.path))
+    if args.command == "search":
+        from mednotes.domains.wiki.capabilities.pdf import search
+
+        return _as_payload(
+            search.search(
+                search.SearchRequest(
+                    query_text=args.query or "",
+                    note_path=args.note,
+                    anchor_id=args.anchor_id,
+                    provider=args.provider,
+                    top_k=args.top_k,
+                )
+            )
+        )
+    if args.command == "insert":
+        from mednotes.domains.wiki.capabilities.pdf import insert
+
+        if args.insert_command == "preview":
+            crop = args.crop
+            if crop is None:
+                return _as_payload({
+                    "schema": insert.PREVIEW_SCHEMA,
+                    "status": "blocked",
+                    "phase": "insert_preview",
+                    "blocked_reason": "crop_path_required",
+                    "next_action": "pass --crop PATH",
+                })
+            section = list(args.section_path or [])
+            return insert.preview(note_path=args.note, figure_uid=args.figure_uid, section_path=section, crop_path=crop)
+        if args.insert_command == "apply":
+            return insert.apply_preview(receipt_path=args.preview_receipt, confirm=args.confirm)
+    raise AssertionError(f"unhandled command: {args.command}")
+
+
+def _as_payload(payload: object) -> JsonObject:
+    return JsonObjectAdapter.validate_python(payload)
+
+
+def _payload_status(payload: JsonObject) -> str:
+    value = _as_payload(payload).get("status")
+    return value if isinstance(value, str) else ""
+
+
+def _emit(payload: JsonObject) -> None:
+    print(json.dumps(_as_payload(payload), ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/cloud.py

@@ -0,0 +1,52 @@
+"""Optional provider registry for PDF library cloud assists."""
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+RESERVED_PROVIDERS = {"huggingface_free", "free_api_quota", "hosted_open_model_free_quota"}
+FUNCTIONAL_PROVIDERS = {"local", "gemini_cli"}
+
+
+def resolve_provider(provider: str) -> dict[str, Any]:
+    if provider in RESERVED_PROVIDERS:
+        return {
+            "schema": "medical-notes-workbench.pdf-library-provider-receipt.v1",
+            "provider": provider,
+            "model": "",
+            "purpose": "anchors",
+            "status": "blocked",
+            "blocked_reason": "provider_not_implemented",
+            "quota_limited": False,
+            "item_count": 0,
+            "created_at": _now(),
+            "next_action": "use gemini_cli or local mode",
+        }
+    if provider not in FUNCTIONAL_PROVIDERS:
+        return {
+            "schema": "medical-notes-workbench.pdf-library-provider-receipt.v1",
+            "provider": provider,
+            "model": "",
+            "purpose": "anchors",
+            "status": "blocked",
+            "blocked_reason": "provider_not_implemented",
+            "quota_limited": False,
+            "item_count": 0,
+            "created_at": _now(),
+            "next_action": "use gemini_cli or local mode",
+        }
+    return {
+        "schema": "medical-notes-workbench.pdf-library-provider-receipt.v1",
+        "provider": provider,
+        "model": "gemini-configured-default" if provider == "gemini_cli" else "",
+        "purpose": "anchors",
+        "status": "completed",
+        "blocked_reason": "",
+        "quota_limited": False,
+        "item_count": 0,
+        "created_at": _now(),
+    }
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/config.py

@@ -0,0 +1,196 @@
+"""Configuration loading for the PDF library."""
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.pdf import paths
+
+VALID_CLOUD_POLICIES = {"optional", "disabled"}
+VALID_IMAGE_BACKENDS = {"auto", "sixel", "tgp", "halfcell", "chafa", "ascii", "none"}
+
+
+@dataclass(frozen=True)
+class PdfLibraryLocalConfig:
+    text_index: str = "sqlite-fts5"
+    image_embedding: str = "none"
+    ocr: str = "tesseract"
+
+
+@dataclass(frozen=True)
+class PdfLibraryCloudConfig:
+    enabled: bool = True
+    default_provider: str = "gemini_cli"
+    allow_free_api_quota: bool = True
+    allow_hosted_open_model_free_quota: bool = True
+    send_full_pdf: bool = False
+    send_full_ocr_text: bool = False
+    record_provider_receipts: bool = True
+
+
+@dataclass(frozen=True)
+class PdfLibraryContextConfig:
+    detect_figure_ids: bool = True
+    link_mentions: bool = True
+    default_mention_window_pages: int = 20
+    conflict_policy: str = "needs_review"
+
+
+@dataclass(frozen=True)
+class PdfLibraryOcrConfig:
+    enabled: bool = True
+    backend: str = "tesseract"
+    languages: list[str] = field(default_factory=lambda: ["por", "eng"])
+    auto_run: bool = False
+    max_parallel_pages: int = 1
+    page_timeout_seconds: int = 90
+
+
+@dataclass(frozen=True)
+class PdfLibraryTuiConfig:
+    enabled: bool = True
+    show_thumbnails: bool = True
+    image_backend: str = "auto"
+    confirm_insert: bool = True
+
+
+@dataclass(frozen=True)
+class PdfLibraryConfig:
+    enabled: bool = True
+    mode: str = "cost-constrained-12gb"
+    paths: list[Path] = field(default_factory=list)
+    index_granularity: str = "figure"
+    cloud_policy: str = "optional"
+    local: PdfLibraryLocalConfig = field(default_factory=PdfLibraryLocalConfig)
+    cloud: PdfLibraryCloudConfig = field(default_factory=PdfLibraryCloudConfig)
+    context: PdfLibraryContextConfig = field(default_factory=PdfLibraryContextConfig)
+    ocr: PdfLibraryOcrConfig = field(default_factory=PdfLibraryOcrConfig)
+    tui: PdfLibraryTuiConfig = field(default_factory=PdfLibraryTuiConfig)
+
+
+def load_pdf_library_config(
+    *,
+    config_path: Path | None = None,
+    cli_paths: list[Path] | None = None,
+    cloud_policy: str | None = None,
+    image_backend: str | None = None,
+) -> PdfLibraryConfig:
+    raw = _read_config(config_path or paths.app_config_path())
+    section = raw.get("pdf_library") if isinstance(raw.get("pdf_library"), dict) else {}
+    cfg = _from_section(section)
+
+    env_paths = _env_paths()
+    effective_paths = cli_paths if cli_paths is not None else env_paths if env_paths is not None else cfg.paths
+    effective_cloud_policy = (
+        cloud_policy
+        or os.environ.get("MEDNOTES_PDF_LIBRARY_CLOUD_POLICY")
+        or cfg.cloud_policy
+    )
+    effective_image_backend = (
+        image_backend
+        or os.environ.get("MEDNOTES_PDF_LIBRARY_IMAGE_BACKEND")
+        or cfg.tui.image_backend
+    )
+    _validate_choice("cloud_policy", effective_cloud_policy, VALID_CLOUD_POLICIES)
+    _validate_choice("image_backend", effective_image_backend, VALID_IMAGE_BACKENDS)
+    return PdfLibraryConfig(
+        enabled=cfg.enabled,
+        mode=cfg.mode,
+        paths=[_resolve_path(path) for path in effective_paths],
+        index_granularity=cfg.index_granularity,
+        cloud_policy=effective_cloud_policy,
+        local=cfg.local,
+        cloud=cfg.cloud,
+        context=cfg.context,
+        ocr=cfg.ocr,
+        tui=PdfLibraryTuiConfig(
+            enabled=cfg.tui.enabled,
+            show_thumbnails=cfg.tui.show_thumbnails,
+            image_backend=effective_image_backend,
+            confirm_insert=cfg.tui.confirm_insert,
+        ),
+    )
+
+
+def _read_config(path: Path) -> dict[str, Any]:
+    try:
+        return tomllib.loads(path.expanduser().read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return {}
+
+
+def _from_section(section: dict[str, Any]) -> PdfLibraryConfig:
+    local = section.get("local") if isinstance(section.get("local"), dict) else {}
+    cloud = section.get("cloud") if isinstance(section.get("cloud"), dict) else {}
+    context = section.get("context") if isinstance(section.get("context"), dict) else {}
+    ocr = section.get("ocr") if isinstance(section.get("ocr"), dict) else {}
+    tui = section.get("tui") if isinstance(section.get("tui"), dict) else {}
+    return PdfLibraryConfig(
+        enabled=bool(section.get("enabled", True)),
+        mode=str(section.get("mode", "cost-constrained-12gb")),
+        paths=[_resolve_path(Path(str(item))) for item in _as_list(section.get("paths"))],
+        index_granularity=str(section.get("index_granularity", "figure")),
+        cloud_policy=str(section.get("cloud_policy", "optional")),
+        local=PdfLibraryLocalConfig(
+            text_index=str(local.get("text_index", "sqlite-fts5")),
+            image_embedding=str(local.get("image_embedding", "none")),
+            ocr=str(local.get("ocr", "tesseract")),
+        ),
+        cloud=PdfLibraryCloudConfig(
+            enabled=bool(cloud.get("enabled", True)),
+            default_provider=str(cloud.get("default_provider", "gemini_cli")),
+            allow_free_api_quota=bool(cloud.get("allow_free_api_quota", True)),
+            allow_hosted_open_model_free_quota=bool(cloud.get("allow_hosted_open_model_free_quota", True)),
+            send_full_pdf=bool(cloud.get("send_full_pdf", False)),
+            send_full_ocr_text=bool(cloud.get("send_full_ocr_text", False)),
+            record_provider_receipts=bool(cloud.get("record_provider_receipts", True)),
+        ),
+        context=PdfLibraryContextConfig(
+            detect_figure_ids=bool(context.get("detect_figure_ids", True)),
+            link_mentions=bool(context.get("link_mentions", True)),
+            default_mention_window_pages=int(context.get("default_mention_window_pages", 20)),
+            conflict_policy=str(context.get("conflict_policy", "needs_review")),
+        ),
+        ocr=PdfLibraryOcrConfig(
+            enabled=bool(ocr.get("enabled", True)),
+            backend=str(ocr.get("backend", "tesseract")),
+            languages=[str(item) for item in _as_list(ocr.get("languages", ["por", "eng"]))],
+            auto_run=bool(ocr.get("auto_run", False)),
+            max_parallel_pages=int(ocr.get("max_parallel_pages", 1)),
+            page_timeout_seconds=int(ocr.get("page_timeout_seconds", 90)),
+        ),
+        tui=PdfLibraryTuiConfig(
+            enabled=bool(tui.get("enabled", True)),
+            show_thumbnails=bool(tui.get("show_thumbnails", True)),
+            image_backend=str(tui.get("image_backend", "auto")),
+            confirm_insert=bool(tui.get("confirm_insert", True)),
+        ),
+    )
+
+
+def _as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def _env_paths() -> list[Path] | None:
+    raw = os.environ.get("MEDNOTES_PDF_LIBRARY_PATHS")
+    if raw is None:
+        return None
+    items = [part.strip() for part in raw.replace(",", os.pathsep).split(os.pathsep)]
+    return [_resolve_path(Path(part)) for part in items if part]
+
+
+def _resolve_path(path: Path) -> Path:
+    return path.expanduser().resolve(strict=False)
+
+
+def _validate_choice(name: str, value: str, choices: set[str]) -> None:
+    if value not in choices:
+        raise ValueError(f"invalid {name}: {value!r}; expected one of {sorted(choices)}")

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/context_packets.py

@@ -0,0 +1,76 @@
+"""Redacted context packets for PDF figures."""
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.pdf.captions import Caption
+from mednotes.domains.wiki.capabilities.pdf.mentions import Mention
+
+SCHEMA = "medical-notes-workbench.pdf-figure-context-packet.v1"
+EVIDENCE_LEVELS = {"caption_and_mentions", "caption_only", "mentions_only", "page_context_only", "visual_only"}
+
+
+def build_packet(
+    *,
+    caption: Caption | None = None,
+    mentions: list[Mention] | None = None,
+    heading_window: str | None = None,
+    figure_uid: str | None = None,
+) -> dict[str, Any]:
+    mentions = list(mentions or [])
+    evidence_level = _evidence_level(caption, mentions)
+    if evidence_level not in EVIDENCE_LEVELS:
+        return {"status": "blocked", "blocked_reason": "invalid_evidence_level"}
+    conflict_reason = _conflict_reason(caption, mentions, heading_window)
+    is_low_confidence = bool(conflict_reason or evidence_level in {"page_context_only", "visual_only", "mentions_only"})
+    figure_id = caption.figure_id if caption else mentions[0].figure_id if mentions else ""
+    return {
+        "schema": SCHEMA,
+        "figure_uid": figure_uid or _uid(figure_id, caption.text if caption else ""),
+        "figure_id": figure_id,
+        "caption": {"page_number": caption.page_number, "text": caption.text} if caption else None,
+        "mentions": [
+            {
+                "page_number": mention.page_number,
+                "sentence": mention.sentence,
+                "section_path_guess": list(mention.section_path_guess),
+            }
+            for mention in mentions
+        ],
+        "section_path_guess": list(caption.section_path_guess if caption else mentions[0].section_path_guess if mentions else []),
+        "evidence_level": evidence_level,
+        "is_low_confidence": is_low_confidence,
+        "conflict_reason": conflict_reason,
+        "source_coordinates": {
+            "caption_page": caption.page_number if caption else None,
+            "mention_pages": [mention.page_number for mention in mentions],
+        },
+    }
+
+
+def _evidence_level(caption: Caption | None, mentions: list[Mention]) -> str:
+    if caption and mentions:
+        return "caption_and_mentions"
+    if caption:
+        return "caption_only"
+    if mentions:
+        return "mentions_only"
+    return "visual_only"
+
+
+def _conflict_reason(caption: Caption | None, mentions: list[Mention], heading_window: str | None) -> str:
+    if not caption or not mentions or heading_window:
+        return ""
+    for mention in mentions:
+        if caption.section_path_guess and mention.section_path_guess and caption.section_path_guess[:1] == mention.section_path_guess[:1]:
+            continue
+        if abs(mention.page_number - caption.page_number) > 20:
+            return "same_id_distant_sections"
+    return ""
+
+
+def _uid(*parts: str) -> str:
+    material = json.dumps(parts, ensure_ascii=False, sort_keys=True).encode("utf-8")
+    return f"ctx:{hashlib.sha256(material).hexdigest()[:16]}"

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/db.py

@@ -0,0 +1,81 @@
+"""SQLite helpers for the PDF library."""
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from mednotes.domains.wiki.capabilities.pdf import schema
+
+
+def open_database(path: Path) -> sqlite3.Connection:
+    path.expanduser().parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(path)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys=ON")
+    with conn:
+        conn.executescript(schema.SCHEMA_SQL)
+        conn.execute(
+            "INSERT OR REPLACE INTO metadata(key, value) VALUES ('schema_version', ?)",
+            (schema.SCHEMA_VERSION,),
+        )
+    return conn
+
+
+def schema_version(conn: sqlite3.Connection) -> str:
+    row = conn.execute("SELECT value FROM metadata WHERE key = 'schema_version'").fetchone()
+    return str(row[0]) if row else ""
+
+
+def replace_page_fts(
+    conn: sqlite3.Connection,
+    *,
+    pdf_sha256: str,
+    page_number: int,
+    title_guess: str,
+    section_path_guess: str,
+    text: str,
+) -> None:
+    conn.execute("DELETE FROM page_fts WHERE pdf_sha256 = ? AND page_number = ?", (pdf_sha256, page_number))
+    conn.execute(
+        "INSERT INTO page_fts(pdf_sha256, page_number, title_guess, section_path_guess, text) VALUES (?, ?, ?, ?, ?)",
+        (pdf_sha256, page_number, title_guess, section_path_guess, text),
+    )
+
+
+def replace_figure_fts(
+    conn: sqlite3.Connection,
+    *,
+    figure_uid: str,
+    pdf_sha256: str,
+    figure_id: str,
+    display_label: str,
+    caption: str,
+) -> None:
+    conn.execute("DELETE FROM figure_fts WHERE figure_uid = ?", (figure_uid,))
+    conn.execute(
+        "INSERT INTO figure_fts(figure_uid, pdf_sha256, figure_id, display_label, caption) VALUES (?, ?, ?, ?, ?)",
+        (figure_uid, pdf_sha256, figure_id, display_label, caption),
+    )
+
+
+def replace_mention_fts(
+    conn: sqlite3.Connection,
+    *,
+    mention_uid: str,
+    pdf_sha256: str,
+    figure_id: str,
+    sentence: str,
+    paragraph: str,
+    section_path_guess: str,
+) -> None:
+    conn.execute("DELETE FROM mention_fts WHERE mention_uid = ?", (mention_uid,))
+    conn.execute(
+        "INSERT INTO mention_fts(mention_uid, pdf_sha256, figure_id, sentence, paragraph, section_path_guess) VALUES (?, ?, ?, ?, ?, ?)",
+        (mention_uid, pdf_sha256, figure_id, sentence, paragraph, section_path_guess),
+    )
+
+
+def delete_document_fts(conn: sqlite3.Connection, *, pdf_sha256: str) -> None:
+    conn.execute("DELETE FROM page_fts WHERE pdf_sha256 = ?", (pdf_sha256,))
+    conn.execute("DELETE FROM figure_fts WHERE pdf_sha256 = ?", (pdf_sha256,))
+    conn.execute("DELETE FROM mention_fts WHERE pdf_sha256 = ?", (pdf_sha256,))

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/pdf/doctor.py

@@ -0,0 +1,102 @@
+"""Bootstrap-safe doctor and setup helpers."""
+from __future__ import annotations
+
+import importlib.util
+import os
+import platform
+import shutil
+import subprocess
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.pdf import config as config_mod
+from mednotes.domains.wiki.capabilities.pdf import paths
+
+DOCTOR_SCHEMA = "medical-notes-workbench.pdf-library-doctor.v1"
+SETUP_SCHEMA = "medical-notes-workbench.pdf-library-setup.v1"
+REQUIRED_MODULES = {
+    "fitz": "PyMuPDF",
+    "pytesseract": "pytesseract",
+    "textual": "textual",
+}
+
+
+def run_doctor(*, cfg: config_mod.PdfLibraryConfig | None = None, app_home: Path | None = None) -> dict[str, Any]:
+    cfg = cfg or config_mod.load_pdf_library_config()
+    missing = [dist for module, dist in REQUIRED_MODULES.items() if importlib.util.find_spec(module) is None]
+    missing_paths = [str(path) for path in cfg.paths if not path.exists()]
+    payload: dict[str, Any] = {
+        "schema": DOCTOR_SCHEMA,
+        "status": "ok",
+        "phase": "doctor",
+        "app_home": str(app_home or paths.app_home()),
+        "configured_paths": [str(path) for path in cfg.paths],
+        "missing_paths": missing_paths,
+        "dependencies": {
+            "missing": missing,
+            "tesseract_binary": shutil.which("tesseract") or "",
+            "platform": platform.platform(),
+        },
+        "third_party_notices": [
+            "PyMuPDF is optional and distributed under AGPL/commercial terms.",
+        ],
+        "created_at": _now(),
+    }
+    blockers: list[str] = []
+    if missing:
+        blockers.append("pdf_library_dependencies_missing")
+    if missing_paths:
+        blockers.append("pdf_library_paths_missing")
+    if blockers:
+        payload.update(
+            {
+                "status": "blocked",
+                "blocked_reason": blockers[0],
+                "next_action": "/mednotes:pdf-library setup" if "pdf_library_dependencies_missing" in blockers else "fix configured PDF paths",
+                "required_inputs": ["pdf-library optional dependencies"] if missing else ["valid PDF paths"],
+            }
+        )
+    return payload
+
+
+def setup_payload(*, dry_run: bool, app_home: Path | None = None, extension_path: Path | None = None) -> dict[str, Any]:
+    root = app_home or paths.app_home()
+    venv = root.parent / ".venv"
+    project = extension_path or paths.extension_root()
+    cmd = ["uv", "sync", "--project", str(project), "--extra", "pdf-library"]
+    payload: dict[str, Any] = {
+        "schema": SETUP_SCHEMA,
+        "status": "dry_run" if dry_run else "running",
+        "phase": "setup",
+        "uv_project_environment": str(venv),
+        "command": cmd,
+        "third_party_notices": [
+            "PyMuPDF is optional and distributed under AGPL/commercial terms.",
+        ],
+    }
+    if dry_run:
+        return payload
+    env = dict(os.environ)
+    env["UV_PROJECT_ENVIRONMENT"] = str(venv)
+    proc = subprocess.run(cmd, text=True, capture_output=True, env=env, check=False)
+    payload.update(
+        {
+            "status": "ok" if proc.returncode == 0 else "failed",
+            "exit_code": proc.returncode,
+            "stdout_tail": proc.stdout[-4000:],
+            "stderr_tail": proc.stderr[-4000:],
+        }
+    )
+    if proc.returncode != 0:
+        payload.update(
+            {
+                "blocked_reason": "pdf_library_setup_failed",
+                "next_action": "corrigir ambiente uv/Python e rodar /mednotes:setup",
+            }
+        )
+    return payload
+
+
+def _now() -> str:
+    return datetime.now(UTC).isoformat()