mednotes-opencode 0.1.0

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/note_style/models.py

@@ -0,0 +1,208 @@
+"""Shared constants and models for the Wiki_Medicina style contract."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+StyleIssuePayload = dict[str, str | int]
+
+STYLE_REPORT_SCHEMA = "medical-notes-workbench.wiki-note-style-report.v1"
+STYLE_AUDIT_SCHEMA = "medical-notes-workbench.wiki-note-style-audit.v1"
+STYLE_FIX_SCHEMA = "medical-notes-workbench.wiki-note-style-fix.v1"
+WIKI_INDEX_LINK = "[[_Índice_Medicina]]"
+
+NOTE_MODEL_CHANGE_RULE = (
+    "Any Wiki_Medicina note model change, including data, metadata, YAML, "
+    "formatting, footer, sections, tables, aliases, or provenance, must be "
+    "implemented in both /mednotes:process-chats for new notes and "
+    "/mednotes:fix-wiki as a retroactive path. If retroactive repair is not "
+    "deterministic, fix-wiki must block with a rewrite or human decision instead "
+    "of reporting green health."
+)
+
+PREFERRED_H2_EMOJIS = {"🎯", "🧠", "🔎", "🩺", "⚖️", "⚠️", "🏁", "🔗", "🧬"}
+
+REQUIRED_SECTION_LINES = (
+    "## 🏁 Fechamento",
+    "### Resumo",
+    "### Key Points",
+    "### Frase de Prova",
+    "## 🔗 Notas Relacionadas",
+)
+
+REWRITE_REQUIRED_CODES = {
+    "missing_title_heading",
+    "missing_h2_sections",
+    "missing_required_section",
+}
+
+REWRITE_TRIGGER_WARNING_CODES = {
+    "didactic_visual_opportunity",
+}
+
+NOTE_MODEL_ISSUE_COVERAGE = {
+    "didactic_visual_opportunity": {
+        "severity": "warning",
+        "note_model_attribute": "embedded_mermaid_or_equation_when_clarifying",
+        "process_chats_new_notes": "rewrite_required",
+        "fix_wiki_retroactive": "llm_style_rewrite",
+    },
+    "excessive_callouts": {
+        "severity": "warning",
+        "note_model_attribute": "callout_density",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "extra_blank_lines_before_related": {
+        "severity": "warning",
+        "note_model_attribute": "related_notes_spacing",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "frontmatter_not_canonical": {
+        "severity": "error",
+        "note_model_attribute": "canonical_yaml_frontmatter",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "h2_missing_emoji": {
+        "severity": "error",
+        "note_model_attribute": "emoji_prefixed_h2_headings",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "chats.missing_unrecoverable": {
+        "severity": "warning",
+        "note_model_attribute": "chat_provenance_missing",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "chats.shape_invalid": {
+        "severity": "error",
+        "note_model_attribute": "chat_provenance_yaml",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "manual_or_llm_blocker",
+    },
+    "frontmatter_yaml_unavailable": {
+        "severity": "error",
+        "note_model_attribute": "canonical_yaml_frontmatter",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "manual_or_llm_blocker",
+    },
+    "invalid_footer_link": {
+        "severity": "error",
+        "note_model_attribute": "canonical_footer",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "provenance.legacy_chat_original_footer": {
+        "severity": "error",
+        "note_model_attribute": "chat_provenance",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "provenance.sources_section_missing": {
+        "severity": "error",
+        "note_model_attribute": "chat_provenance",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "legacy_index_footer_link": {
+        "severity": "error",
+        "note_model_attribute": "canonical_footer",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "long_definition": {
+        "severity": "warning",
+        "note_model_attribute": "opening_definition",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "long_paragraph": {
+        "severity": "warning",
+        "note_model_attribute": "paragraph_length",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "malformed_markdown_table": {
+        "severity": "error",
+        "note_model_attribute": "markdown_tables",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "manual_or_llm_blocker",
+    },
+    "malformed_wikilink_alias": {
+        "severity": "warning",
+        "note_model_attribute": "wikilink_alias_syntax",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "missing_blank_line_before_callout": {
+        "severity": "warning",
+        "note_model_attribute": "callout_spacing",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+    "missing_definition": {
+        "severity": "warning",
+        "note_model_attribute": "opening_definition",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "missing_h2_sections": {
+        "severity": "error",
+        "note_model_attribute": "section_structure",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "llm_style_rewrite",
+    },
+    "missing_required_section": {
+        "severity": "error",
+        "note_model_attribute": "required_closing_sections",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "llm_style_rewrite",
+    },
+    "missing_title_heading": {
+        "severity": "error",
+        "note_model_attribute": "title_heading",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "llm_style_rewrite",
+    },
+    "non_preferred_h2_emoji": {
+        "severity": "warning",
+        "note_model_attribute": "preferred_heading_emoji_set",
+        "process_chats_new_notes": "allow_warning",
+        "fix_wiki_retroactive": "diagnostic_warning",
+    },
+    "unescaped_wikilink_pipe_in_table": {
+        "severity": "error",
+        "note_model_attribute": "markdown_tables",
+        "process_chats_new_notes": "block_error",
+        "fix_wiki_retroactive": "deterministic_fix",
+    },
+}
+
+
+@dataclass(frozen=True)
+class StyleIssue:
+    code: str
+    message: str
+    severity: str
+    line: int | None = None
+    section: str | None = None
+    suggested_visual: str | None = None
+    reason: str | None = None
+
+    def to_json(self) -> StyleIssuePayload:
+        data: StyleIssuePayload = {
+            "code": self.code,
+            "message": self.message,
+            "severity": self.severity,
+        }
+        if self.line is not None:
+            data["line"] = self.line
+        if self.section is not None:
+            data["section"] = self.section
+        if self.suggested_visual is not None:
+            data["suggested_visual"] = self.suggested_visual
+        if self.reason is not None:
+            data["reason"] = self.reason
+        return data

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/note_style/prompts.py

@@ -0,0 +1,37 @@
+"""LLM rewrite prompts emitted by the deterministic Wiki style validator."""
+from __future__ import annotations
+
+from typing import Any
+
+
+def _issue_line(item: dict[str, Any]) -> str:
+    details = []
+    for key in ("section", "suggested_visual", "reason"):
+        value = str(item.get(key) or "").strip()
+        if value:
+            details.append(f"{key}={value}")
+    suffix = f" ({'; '.join(details)})" if details else ""
+    return f"- {item['code']}: {item['message']}{suffix}"
+
+
+def rewrite_prompt(title: str, errors: list[dict[str, Any]], warnings: list[dict[str, Any]]) -> str:
+    issue_lines = "\n".join(_issue_line(item) for item in errors + warnings)
+    visual_instruction = ""
+    if any(item["code"] == "didactic_visual_opportunity" for item in errors + warnings):
+        visual_instruction = (
+            " Quando houver `didactic_visual_opportunity`, insira Mermaid ou equação "
+            "somente na seção clínica correspondente, logo após o texto que justifica "
+            "o visual; não crie seção genérica de diagramas/fórmulas e siga o "
+            "material-fonte sem inventar relações, etapas, números, limiares ou fórmulas."
+        )
+    return (
+        "Reescreva a nota temporária abaixo para cumprir o Modelo Wiki_Medicina "
+        "de estudo para residência, sem inventar fatos novos além do material-fonte. "
+        f"Preserve o título '# {title}', use headings ## com emoji semântico, inclua "
+        "'## 🏁 Fechamento' com '### Resumo', '### Key Points' e "
+        "'### Frase de Prova', inclua '## 🔗 Notas Relacionadas' e finalize com "
+        "'## 🧬 Fontes Consolidadas' derivada do YAML chats[]. "
+        f"{visual_instruction} "
+        "Problemas encontrados:\n"
+        f"{issue_lines}"
+    )

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/notes/note_style/tables.py

@@ -0,0 +1,236 @@
+"""Markdown table validation and normalization for Wiki_Medicina notes."""
+from __future__ import annotations
+
+import re
+
+from mednotes.domains.wiki.capabilities.notes.markdown_zones import protected_markdown_zones
+from mednotes.domains.wiki.capabilities.notes.note_style.models import StyleIssue
+
+_WIKILINK_RE = re.compile(r"\[\[([^\]]+)\]\]")
+
+
+def check_tables(body: str, errors: list[StyleIssue]) -> None:
+    protected_lines = _protected_line_numbers(body)
+    for block_lines, start_line in _iter_table_blocks(body.splitlines(), protected_lines=protected_lines):
+        if len(block_lines) < 2:
+            continue
+        protected_lines = [escape_wikilink_alias_pipes_in_table_line(line) for line in block_lines]
+        parsed = [_split_table_cells(line) for line in protected_lines]
+        separator_index = _first_separator_index(parsed)
+        if separator_index is None:
+            errors.append(
+                StyleIssue(
+                    "malformed_markdown_table",
+                    "markdown table is missing a separator row",
+                    "error",
+                    line=start_line,
+                )
+            )
+            continue
+
+        if any(table_line_has_unescaped_wikilink_pipe(line) for line in block_lines):
+            errors.append(
+                StyleIssue(
+                    "unescaped_wikilink_pipe_in_table",
+                    "escape Obsidian wikilink alias pipes inside markdown tables",
+                    "error",
+                    line=start_line,
+                )
+            )
+
+        expected_columns = len(_trim_trailing_empty_cells(parsed[0]))
+        if expected_columns == 0:
+            errors.append(
+                StyleIssue("malformed_markdown_table", "markdown table header has no columns", "error", line=start_line)
+            )
+            continue
+
+        for offset, cells in enumerate(parsed):
+            if offset == separator_index:
+                if len(cells) != expected_columns:
+                    errors.append(
+                        StyleIssue(
+                            "malformed_markdown_table",
+                            "markdown table separator column count does not match the header",
+                            "error",
+                            line=start_line + offset,
+                        )
+                    )
+                continue
+            if len(_trim_trailing_empty_cells(cells)) != expected_columns:
+                errors.append(
+                    StyleIssue(
+                        "malformed_markdown_table",
+                        "markdown table row column count does not match the header",
+                        "error",
+                        line=start_line + offset,
+                    )
+                )
+
+
+def escape_wikilink_alias_pipes_in_tables(text: str) -> str:
+    fixed_lines: list[str] = []
+    protected_lines = _protected_line_numbers(text)
+    for idx, line in enumerate(text.splitlines(), start=1):
+        if idx not in protected_lines and _is_table_line(line):
+            fixed_lines.append(escape_wikilink_alias_pipes_in_table_line(line))
+        else:
+            fixed_lines.append(line)
+    return "\n".join(fixed_lines)
+
+
+def escape_wikilink_alias_pipes_in_table_line(line: str) -> str:
+    def replace(match: re.Match[str]) -> str:
+        inner = match.group(1)
+        if "|" not in inner:
+            return match.group(0)
+        inner = re.sub(r"\s*(?<!\\)\|\s*", r"\\|", inner)
+        inner = re.sub(r"\s*\\\|\s*", r"\\|", inner)
+        return f"[[{inner}]]"
+
+    return _WIKILINK_RE.sub(replace, line)
+
+
+def table_line_has_unescaped_wikilink_pipe(line: str) -> bool:
+    for match in _WIKILINK_RE.finditer(line):
+        if re.search(r"(?<!\\)\|", match.group(1)):
+            return True
+    return False
+
+
+def normalize_markdown_tables(text: str) -> str:
+    lines = text.splitlines()
+    normalized: list[str] = []
+    cursor = 0
+    protected_lines = _protected_line_numbers(text)
+    for block_lines, start_line in _iter_table_blocks(lines, protected_lines=protected_lines):
+        start_index = start_line - 1
+        normalized.extend(lines[cursor:start_index])
+        normalized.extend(_normalize_table_block(block_lines))
+        cursor = start_index + len(block_lines)
+    normalized.extend(lines[cursor:])
+    return "\n".join(normalized)
+
+
+def _iter_table_blocks(lines: list[str], *, protected_lines: set[int] | None = None) -> list[tuple[list[str], int]]:
+    protected_lines = protected_lines or set()
+    blocks: list[tuple[list[str], int]] = []
+    idx = 0
+    while idx < len(lines):
+        if idx + 1 in protected_lines or not _is_table_line(lines[idx]):
+            idx += 1
+            continue
+        start = idx
+        block: list[str] = []
+        while idx < len(lines) and idx + 1 not in protected_lines and _is_table_line(lines[idx]):
+            block.append(lines[idx])
+            idx += 1
+        if len(block) >= 2:
+            blocks.append((block, start + 1))
+    return blocks
+
+
+def _protected_line_numbers(text: str) -> set[int]:
+    lines: set[int] = set()
+    for zone in protected_markdown_zones(text):
+        lines.update(range(zone.start_line, zone.end_line + 1))
+    return lines
+
+
+def _is_table_line(line: str) -> bool:
+    return line.lstrip().startswith("|")
+
+
+def _normalize_table_block(lines: list[str]) -> list[str]:
+    parsed = [_split_table_cells(line) for line in lines]
+    separator_index = _first_separator_index(parsed)
+    if separator_index is None:
+        return lines
+
+    expected_columns = len(_trim_trailing_empty_cells(parsed[0]))
+    if expected_columns == 0:
+        return lines
+
+    normalized_rows: list[list[str]] = []
+    for idx, cells in enumerate(parsed):
+        if idx == separator_index:
+            row = cells[:expected_columns]
+            row.extend(["---"] * (expected_columns - len(row)))
+        else:
+            row = _trim_trailing_empty_cells(cells)
+            if len(row) > expected_columns:
+                return lines
+            row.extend([""] * (expected_columns - len(row)))
+        normalized_rows.append([cell.strip() for cell in row])
+
+    widths = [3] * expected_columns
+    for row in normalized_rows:
+        for idx, cell in enumerate(row):
+            widths[idx] = max(widths[idx], len(cell))
+
+    rendered: list[str] = []
+    for idx, row in enumerate(normalized_rows):
+        if idx == separator_index:
+            rendered.append(_render_separator_row(row, widths))
+        else:
+            rendered.append(_render_table_row(row, widths))
+    return rendered
+
+
+def _split_table_cells(line: str) -> list[str]:
+    stripped = line.strip()
+    if stripped.startswith("|"):
+        stripped = stripped[1:]
+    if stripped.endswith("|") and not stripped.endswith("\\|"):
+        stripped = stripped[:-1]
+
+    cells: list[str] = []
+    current: list[str] = []
+    for idx, char in enumerate(stripped):
+        if char == "|" and (idx == 0 or stripped[idx - 1] != "\\"):
+            cells.append("".join(current))
+            current = []
+        else:
+            current.append(char)
+    cells.append("".join(current))
+    return cells
+
+
+def _first_separator_index(rows: list[list[str]]) -> int | None:
+    for idx, cells in enumerate(rows[:3]):
+        if _is_separator_row(cells):
+            return idx
+    return None
+
+
+def _is_separator_row(cells: list[str]) -> bool:
+    return bool(cells) and all(re.fullmatch(r":?-{3,}:?", cell.strip()) for cell in cells)
+
+
+def _trim_trailing_empty_cells(cells: list[str]) -> list[str]:
+    trimmed = list(cells)
+    while trimmed and not trimmed[-1].strip():
+        trimmed.pop()
+    return trimmed
+
+
+def _render_table_row(cells: list[str], widths: list[int]) -> str:
+    return "| " + " | ".join(cell.ljust(widths[idx]) for idx, cell in enumerate(cells)) + " |"
+
+
+def _render_separator_row(cells: list[str], widths: list[int]) -> str:
+    tokens = [_separator_token(cell, widths[idx]) for idx, cell in enumerate(cells)]
+    return "| " + " | ".join(tokens) + " |"
+
+
+def _separator_token(cell: str, width: int) -> str:
+    stripped = cell.strip()
+    left = stripped.startswith(":")
+    right = stripped.endswith(":")
+    dash_count = max(3, width - int(left) - int(right))
+    token = "-" * dash_count
+    if left:
+        token = ":" + token
+    if right:
+        token = token + ":"
+    return token.ljust(width)