mednotes-opencode 0.1.0

package/.opencode/mednotes/src/mednotes/domains/wiki/flows/enrich/workflow/candidates.py

@@ -0,0 +1,193 @@
+"""Image candidate search and thumbnail preparation."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+from mednotes.domains.wiki.capabilities.illustrate.core.download import DownloadError
+from mednotes.domains.wiki.capabilities.illustrate.core.download import download as download_image
+from mednotes.domains.wiki.capabilities.illustrate.sources import (
+    ImageCandidate,
+    SourceQuotaExceeded,
+    web_profiles,
+    web_search,
+    wikimedia,
+)
+from mednotes.domains.wiki.flows.enrich.workflow import quality
+from mednotes.domains.wiki.flows.enrich.workflow.models import CandidateReport
+from mednotes.domains.wiki.flows.enrich.workflow.utils import _log
+
+
+class _SearchAdapter(Protocol):
+    """Uniform image-search adapter used by the enrichment workflow."""
+
+    NAME: str
+
+    def search(
+        self,
+        query: str,
+        visual_type: str,
+        *,
+        top_k: int = 4,
+        language: str | None = None,
+    ) -> list[ImageCandidate]: ...
+
+
+class _WikimediaAdapter:
+    NAME = wikimedia.NAME
+
+    def search(
+        self,
+        query: str,
+        visual_type: str,
+        *,
+        top_k: int = 4,
+        language: str | None = None,
+    ) -> list[ImageCandidate]:
+        return wikimedia.search(query, visual_type, top_k=top_k)
+
+
+class _WebSearchAdapter:
+    NAME = web_search.NAME
+
+    def search(
+        self,
+        query: str,
+        visual_type: str,
+        *,
+        top_k: int = 4,
+        language: str | None = None,
+    ) -> list[ImageCandidate]:
+        return web_search.search(query, visual_type, top_k=top_k, language=language)
+
+
+class _ProfileAdapter:
+    def __init__(self, name: str):
+        self.NAME = name
+
+    def search(
+        self,
+        query: str,
+        visual_type: str,
+        *,
+        top_k: int = 4,
+        language: str | None = None,
+    ) -> list[ImageCandidate]:
+        return web_profiles.search_profile(
+            self.NAME,
+            query,
+            visual_type,
+            top_k=top_k,
+            language=language,
+        )
+
+
+_SOURCE_REGISTRY: dict[str, _SearchAdapter] = {
+    wikimedia.NAME: _WikimediaAdapter(),
+    web_search.NAME: _WebSearchAdapter(),
+    **{name: _ProfileAdapter(name) for name in web_profiles.PROFILES},
+}
+
+
+def gather_candidates(
+    anchor: dict,
+    *,
+    sources_enabled: list[str],
+    top_k_per_source: int,
+    max_total: int,
+    preferred_language: str = "any",
+) -> list[ImageCandidate]:
+    return gather_candidate_report(
+        anchor,
+        sources_enabled=sources_enabled,
+        top_k_per_source=top_k_per_source,
+        max_total=max_total,
+        preferred_language=preferred_language,
+    ).candidates
+
+
+def gather_candidate_report(
+    anchor: dict,
+    *,
+    sources_enabled: list[str],
+    top_k_per_source: int,
+    max_total: int,
+    preferred_language: str = "any",
+) -> CandidateReport:
+    seen_urls: set[str] = set()
+    out: list[ImageCandidate] = []
+    counts_by_source = dict.fromkeys(sources_enabled, 0)
+    failed_queries: list[tuple[str, str, str]] = []
+    for source_name in sources_enabled:
+        adapter = _SOURCE_REGISTRY.get(source_name)
+        if adapter is None:
+            failed_queries.append((source_name, "(adapter)", "fonte desconhecida"))
+            continue
+        for query in anchor["search_queries"]:
+            try:
+                cs = adapter.search(
+                    query,
+                    anchor["visual_type"],
+                    top_k=top_k_per_source,
+                    language=preferred_language,
+                )
+            except SourceQuotaExceeded:
+                raise
+            except Exception as e:
+                failed_queries.append((source_name, query, str(e)))
+                continue
+            for c in cs:
+                if c.image_url in seen_urls:
+                    continue
+                seen_urls.add(c.image_url)
+                out.append(c)
+                counts_by_source[source_name] += 1
+    ranked = quality.rank_candidates_for_rerank(anchor["visual_type"], out)
+    return CandidateReport(
+        candidates=ranked[:max_total],
+        counts_by_source=counts_by_source,
+        failed_queries=failed_queries,
+        capped=len(ranked) > max_total,
+    )
+
+
+def _candidate_image_urls(c: ImageCandidate) -> list[str]:
+    urls = [c.image_url]
+    thumbnail_url = getattr(c, "thumbnail_url", None)
+    if thumbnail_url and thumbnail_url not in urls:
+        urls.append(thumbnail_url)
+    return urls
+
+
+def fetch_thumbs(
+    candidates: list[ImageCandidate],
+    *,
+    tmp_dir: Path,
+    user_agent: str | None = None,
+) -> list[Path | None]:
+    """Baixa thumbnails (256px) sem usar cache do projeto. Falha por candidata
+    é tolerada — devolve None na posição correspondente."""
+    out: list[Path | None] = []
+    for i, c in enumerate(candidates):
+        thumb_path = None
+        last_error = None
+        for url in _candidate_image_urls(c):
+            try:
+                res = download_image(
+                    url,
+                    vault_dir=tmp_dir,
+                    max_dim=256,
+                    webp_min_savings_pct=0,  # sempre WebP nos thumbs
+                    cache=None,
+                    source=c.source,
+                    source_url=c.source_url,
+                    user_agent=user_agent,
+                )
+                thumb_path = Path(res["path"])
+                break
+            except DownloadError as e:
+                last_error = e
+        if thumb_path is None:
+            _log(f"    [warn] thumb #{i} falhou: {last_error}", err=True)
+        out.append(thumb_path)
+    return out

package/.opencode/mednotes/src/mednotes/domains/wiki/flows/enrich/workflow/cli.py

@@ -0,0 +1,189 @@
+"""CLI entrypoint for the image enrichment workflow."""
+from __future__ import annotations
+
+import argparse
+import time
+from pathlib import Path
+
+from mednotes.domains.wiki.capabilities.illustrate.core.config import load as load_config
+from mednotes.domains.wiki.capabilities.illustrate.core.config import wiki_memory_path
+from mednotes.domains.wiki.flows.enrich.workflow import reporting
+from mednotes.domains.wiki.flows.enrich.workflow.inputs import _resolve_note_inputs
+from mednotes.domains.wiki.flows.enrich.workflow.models import _EXIT_SOURCE_QUOTA, NoteResult
+from mednotes.domains.wiki.flows.enrich.workflow.runner import (
+    _log_run_header,
+    _print_summary,
+    _process_note,
+    _resolve_vault,
+)
+from mednotes.domains.wiki.flows.enrich.workflow.utils import _log
+from mednotes.domains.wiki.flows.enrich.workflow.vault_guard_bridge import VaultGuardError, require_enrich_guard
+from mednotes.platform.feedback import command_string, safe_record_workflow_run
+
+
+def main(argv: list[str] | None = None) -> int:
+    started_at = time.time()
+    parser = argparse.ArgumentParser(
+        prog="enrich_notes",
+        description="Orquestrador end-to-end (gemini CLI + enricher toolbox).",
+    )
+    parser.add_argument(
+        "notes",
+        nargs="+",
+        type=Path,
+        help="Caminho(s) da(s) nota(s) .md",
+    )
+    parser.add_argument("--config", type=Path, default=None)
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Re-enriquece mesmo se images_enriched já é true.",
+    )
+    parser.add_argument(
+        "--quality-report",
+        type=Path,
+        default=None,
+        help="Escreve relatório local JSON com fontes, candidatos e razões de aceite/recusa.",
+    )
+    parser.add_argument(
+        "--quality-profile",
+        choices=["clinical", "broad"],
+        default="clinical",
+        help="Perfil de curadoria visual. clinical é estrito; broad preserva comportamento mais permissivo.",
+    )
+    args = parser.parse_args(argv)
+
+    cfg = load_config(args.config)
+    vault = _resolve_vault(cfg, args.config)
+    if vault is None:
+        _log(
+            f"erro: configure [vault].path no config.toml ou [paths].wiki_dir em {wiki_memory_path()}.",
+            err=True,
+        )
+        safe_record_workflow_run(
+            workflow="/mednotes:enrich",
+            command=command_string(),
+            payload={
+                "phase": "enrich_preflight",
+                "status": "failed",
+                "blocked_reason": "missing_vault_config",
+                "next_action": "Configurar [paths].wiki_dir em ~/.mednotes/config.toml ou [vault].path no config.toml e rodar novamente.",
+                "required_inputs": ["config", "wiki_dir"],
+            },
+            exit_code=4,
+            started_at=started_at,
+        )
+        return 4
+
+    notes, input_errors = _resolve_note_inputs(args.notes)
+    for note in notes:
+        try:
+            require_enrich_guard(note, command="enrich_notes")
+        except VaultGuardError as exc:
+            payload = exc.to_payload()
+            _log(str(payload["human_message"]), err=True)
+            safe_record_workflow_run(
+                workflow="/mednotes:enrich",
+                command=command_string(),
+                payload=payload,
+                exit_code=exc.exit_code,
+                started_at=started_at,
+            )
+            return exc.exit_code
+    _log_run_header(
+        cfg=cfg,
+        config_path=args.config,
+        vault=vault,
+        notes_count=len(notes),
+    )
+
+    results: list[NoteResult] = list(input_errors)
+    for result in input_errors:
+        _log(f"erro: {result.message}", err=True)
+    for index, note in enumerate(notes, start=1):
+        if index > 1:
+            _log("")
+        result = _process_note(
+            note,
+            cfg=cfg,
+            vault=vault,
+            force=args.force,
+            index=index,
+            total=len(notes),
+            quality_profile=args.quality_profile,
+        )
+        results.append(result)
+        if result.code == _EXIT_SOURCE_QUOTA:
+            break
+
+    _print_summary(results)
+    if args.quality_report:
+        reporting.write_quality_report(args.quality_report, {
+            "schema": "medical-notes-workbench.enricher-quality-report.v1",
+            "note_count": len(results),
+            "quality_profile": args.quality_profile,
+            "sources_enabled": cfg["sources"]["enabled"],
+            "notes": [
+                result.quality_report
+                for result in results
+                if result.quality_report
+            ],
+        })
+    exit_code = 0
+    for result in results:
+        if result.code != 0:
+            exit_code = result.code
+            break
+    safe_record_workflow_run(
+        workflow="/mednotes:enrich",
+        command=command_string(),
+        payload=_feedback_payload(results, vault=vault, force=args.force),
+        exit_code=exit_code,
+        started_at=started_at,
+        snippets=[result.message for result in results if result.message],
+    )
+    return exit_code
+
+
+def _feedback_payload(results: list[NoteResult], *, vault: Path, force: bool) -> dict[str, object]:
+    enriched = sum(1 for item in results if item.status == "enriched")
+    skipped = sum(1 for item in results if item.status == "skipped")
+    no_insert = sum(1 for item in results if item.status == "no_insert")
+    failures = [item for item in results if item.code != 0]
+    source_counts: dict[str, int] = {}
+    for result in results:
+        for source, count in result.sources_count.items():
+            source_counts[source] = (source_counts[source] if source in source_counts else 0) + count
+    return {
+        "phase": "enrich_notes",
+        "status": "failed" if failures else "completed_with_warnings" if no_insert or skipped else "completed",
+        "blocked_reason": "source_quota" if any(item.code == _EXIT_SOURCE_QUOTA for item in failures) else "",
+        "next_action": "Revisar falhas e rodar novamente apenas para as notas afetadas." if failures else "",
+        "required_inputs": ["notes", "config", "wiki_dir"],
+        "vault_dir": str(vault),
+        "force": force,
+        "quality_reports_available": any(item.quality_report for item in results),
+        "summary": {
+            "note_count": len(results),
+            "enriched_count": enriched,
+            "skipped_count": skipped,
+            "no_insert_count": no_insert,
+            "failure_count": len(failures),
+            "inserted_count": sum(item.inserted_count for item in results),
+        },
+        "source_counts": source_counts,
+        "notes": [
+            {
+                "path": str(item.note),
+                "status": item.status,
+                "inserted_count": item.inserted_count,
+                "code": item.code,
+            }
+            for item in results
+        ],
+        "errors": [item.message for item in failures if item.message],
+    }
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.opencode/mednotes/src/mednotes/domains/wiki/flows/enrich/workflow/gemini.py

@@ -0,0 +1,220 @@
+"""Gemini CLI seam for image enrichment."""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+from typing import TypeVar
+
+from mednotes.domains.wiki.flows.enrich.workflow.models import _DEFAULT_GEMINI_TIMEOUT_SECONDS, GeminiError
+
+_WINDOWS_PROMPT_FILE_THRESHOLD = 6000
+ParsedGeminiJsonT = TypeVar("ParsedGeminiJsonT")
+
+
+def _resolve_gemini_binary(binary: str) -> str:
+    """Resolve o executável do Gemini CLI de forma portável.
+
+    No Windows, o Gemini instalado por npm costuma existir como `gemini.cmd`
+    em `%APPDATA%\npm`. `subprocess` com `shell=False` nem sempre resolve esse
+    shim quando o config diz só `gemini`, então normalizamos antes de montar o
+    comando.
+    """
+    expanded = os.path.expandvars(os.path.expanduser(binary))
+    if _is_pathish(expanded):
+        return expanded
+
+    found = shutil.which(expanded)
+    if found:
+        return found
+
+    if expanded.lower() in {"gemini", "gemini.cmd"}:
+        for candidate in _npm_gemini_candidates():
+            if candidate.is_file():
+                return str(candidate)
+
+    return expanded
+
+
+def _is_pathish(value: str) -> bool:
+    return (
+        "/" in value
+        or "\\" in value
+        or (len(value) >= 2 and value[1] == ":")
+    )
+
+
+def _npm_gemini_candidates() -> list[Path]:
+    candidates: list[Path] = []
+    appdata = os.environ.get("APPDATA")
+    if appdata:
+        candidates.append(Path(appdata) / "npm" / "gemini.cmd")
+    prefix = os.environ.get("NPM_CONFIG_PREFIX")
+    if prefix:
+        prefix_path = Path(prefix)
+        candidates.extend(
+            [
+                prefix_path / "gemini.cmd",
+                prefix_path / "bin" / "gemini",
+            ]
+        )
+    return candidates
+
+
+def _invoke_gemini(
+    cmd: list[str],
+    *,
+    timeout_seconds: int = _DEFAULT_GEMINI_TIMEOUT_SECONDS,
+) -> str:
+    """Roda o gemini CLI e devolve stdout. Levanta GeminiError em rc != 0.
+
+    Seam pra teste: monkeypatch isso pra fingir respostas.
+    """
+    try:
+        proc = subprocess.run(
+            _subprocess_command(cmd),
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=timeout_seconds,
+        )
+    except subprocess.TimeoutExpired as e:
+        raise GeminiError(
+            f"gemini CLI excedeu timeout de {timeout_seconds}s"
+        ) from e
+    except FileNotFoundError as e:
+        raise GeminiError(
+            "gemini CLI não encontrado. Configure [gemini].binary com o caminho "
+            "do executável, ou garanta que `gemini`/`gemini.cmd` esteja no PATH."
+        ) from e
+    except OSError as e:
+        raise GeminiError(f"gemini CLI não pôde ser iniciado: {e}") from e
+    if proc.returncode != 0:
+        raise GeminiError(
+            f"gemini CLI falhou (rc={proc.returncode}): {proc.stderr.strip()}"
+        )
+    return proc.stdout
+
+
+def _subprocess_command(cmd: list[str]) -> list[str]:
+    if not cmd:
+        return cmd
+    executable = cmd[0]
+    suffix = Path(executable).suffix.lower()
+    if os.name == "nt" and suffix in {".cmd", ".bat"}:
+        comspec = os.environ.get("COMSPEC") or "cmd.exe"
+        return [comspec, "/d", "/s", "/c", *cmd]
+    return cmd
+
+
+def call_gemini(
+    prompt: str,
+    *,
+    binary: str,
+    model: str | None = None,
+    include_dirs: list[Path] | None = None,
+    skip_trust: bool = True,
+    timeout_seconds: int = _DEFAULT_GEMINI_TIMEOUT_SECONDS,
+) -> str:
+    """Chama o gemini CLI em modo headless. Multimodal via `@arquivo` no
+    próprio prompt + `--include-directories` pra dar acesso ao path."""
+    cmd = _base_gemini_command(
+        binary=binary,
+        model=model,
+        include_dirs=include_dirs,
+        skip_trust=skip_trust,
+    )
+    if _prompt_needs_file(prompt):
+        return _invoke_gemini_with_prompt_file(cmd, prompt, timeout_seconds=timeout_seconds)
+    cmd.extend(["-p", prompt])
+    return _invoke_gemini(cmd, timeout_seconds=timeout_seconds)
+
+
+def _base_gemini_command(
+    *,
+    binary: str,
+    model: str | None,
+    include_dirs: list[Path] | None,
+    skip_trust: bool,
+) -> list[str]:
+    cmd: list[str] = [_resolve_gemini_binary(binary)]
+    if skip_trust:
+        cmd.append("--skip-trust")
+    if include_dirs:
+        for d in include_dirs:
+            cmd.extend(["--include-directories", str(d)])
+    if model:
+        cmd.extend(["-m", model])
+    return cmd
+
+
+def _prompt_needs_file(prompt: str) -> bool:
+    return os.name == "nt" and len(prompt) >= _WINDOWS_PROMPT_FILE_THRESHOLD
+
+
+def _invoke_gemini_with_prompt_file(cmd: list[str], prompt: str, *, timeout_seconds: int) -> str:
+    with tempfile.TemporaryDirectory(prefix="mednotes-gemini-") as tmp:
+        prompt_path = Path(tmp) / "prompt.md"
+        prompt_path.write_text(prompt, encoding="utf-8")
+        file_cmd = [
+            *cmd,
+            "--include-directories",
+            str(prompt_path.parent),
+            "-p",
+            f"@{prompt_path}",
+        ]
+        return _invoke_gemini(file_cmd, timeout_seconds=timeout_seconds)
+
+
+def call_gemini_json_with_retry(
+    prompt: str,
+    parser: Callable[[str], ParsedGeminiJsonT],
+    *,
+    binary: str,
+    model: str | None = None,
+    include_dirs: list[Path] | None = None,
+    timeout_seconds: int = _DEFAULT_GEMINI_TIMEOUT_SECONDS,
+    skip_trust: bool = True,
+    label: str,
+) -> tuple[ParsedGeminiJsonT, str]:
+    """Chama o Gemini e dá uma chance de autocorreção quando ele responde
+    prose em vez do JSON contratado."""
+    raw = call_gemini(
+        prompt,
+        binary=binary,
+        model=model,
+        include_dirs=include_dirs,
+        skip_trust=skip_trust,
+        timeout_seconds=timeout_seconds,
+    )
+    try:
+        return parser(raw), raw
+    except (json.JSONDecodeError, ValueError) as first_error:
+        retry_prompt = (
+            "Sua resposta anterior para a tarefa abaixo foi inválida: "
+            f"{first_error}.\n\n"
+            "Responda novamente com APENAS JSON válido, sem comentários, sem Markdown, "
+            "sem texto antes ou depois.\n\n"
+            "TAREFA ORIGINAL:\n"
+            f"{prompt}\n\n"
+            "RESPOSTA ANTERIOR INVÁLIDA:\n"
+            f"{raw}"
+        )
+        retry_raw = call_gemini(
+            retry_prompt,
+            binary=binary,
+            model=model,
+            include_dirs=include_dirs,
+            skip_trust=skip_trust,
+            timeout_seconds=timeout_seconds,
+        )
+        try:
+            return parser(retry_raw), retry_raw
+        except (json.JSONDecodeError, ValueError) as retry_error:
+            raise ValueError(
+                f"{label} inválido após retry: {retry_error}"
+            ) from retry_error