mednotes-opencode 0.1.0

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/vocabulary/taxonomy/schema.py

@@ -0,0 +1,157 @@
+"""Canonical Wiki_Medicina taxonomy schema.
+
+The executable taxonomy policy lives in :mod:`wiki.taxonomy.policy`.  This
+module exposes the historical constants/helpers as derived compatibility APIs.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from mednotes.domains.wiki.capabilities.vocabulary.taxonomy.normalize import _fold_taxonomy_segment, safe_title
+from mednotes.domains.wiki.capabilities.vocabulary.taxonomy.policy import (
+    CANONICAL_TAXONOMY_POLICY,
+    TAXONOMY_POLICY_VERSION,
+    TaxonomyAreaPolicy,
+    iter_taxonomy_aliases,
+)
+from mednotes.kernel.base import JsonObject
+
+
+def _area_by_name(name: str) -> TaxonomyAreaPolicy:
+    for area in CANONICAL_TAXONOMY_POLICY:
+        if area.name == name:
+            return area
+    raise KeyError(name)
+
+
+GINECOLOGY_OBSTETRICS_AREA = "3. Ginecologia e Obstetrícia"
+_GINECOLOGY_OBSTETRICS_POLICY = _area_by_name(GINECOLOGY_OBSTETRICS_AREA)
+GINECOLOGY_OBSTETRICS_CHILDREN = tuple(specialty.name for specialty in _GINECOLOGY_OBSTETRICS_POLICY.specialties)
+GINECOLOGY_OBSTETRICS_LEGACY_ALIASES = (
+    *_GINECOLOGY_OBSTETRICS_POLICY.aliases,
+    *(
+        alias
+        for specialty in _GINECOLOGY_OBSTETRICS_POLICY.specialties
+        for alias in specialty.aliases
+        if alias != specialty.name
+    ),
+)
+
+
+def canonical_taxonomy_invariants() -> dict[str, Any]:
+    alias_mappings = [
+        {
+            "alias": alias.alias,
+            "canonical": "/".join(alias.canonical_target),
+            "kind": alias.kind,
+            "reason": alias.reason,
+            "migration_safe": alias.migration_safe,
+            "requires_human_review": alias.requires_human_review,
+        }
+        for alias in iter_taxonomy_aliases()
+    ]
+    return {
+        "taxonomy_policy_version": TAXONOMY_POLICY_VERSION,
+        "areas": [area.name for area in CANONICAL_TAXONOMY_POLICY],
+        "specialty_paths": [
+            f"{area.name}/{specialty.name}"
+            for area in CANONICAL_TAXONOMY_POLICY
+            for specialty in area.specialties
+        ],
+        "legacy_alias_mappings": alias_mappings,
+        "ginecologia_obstetricia": {
+            "area": GINECOLOGY_OBSTETRICS_AREA,
+            "children": list(GINECOLOGY_OBSTETRICS_CHILDREN),
+            "legacy_aliases": list(GINECOLOGY_OBSTETRICS_LEGACY_ALIASES),
+        }
+    }
+
+
+CANONICAL_TAXONOMY: tuple[tuple[str, tuple[str, ...]], ...] = (
+    *(
+        (area.name, tuple(specialty.name for specialty in area.specialties))
+        for area in CANONICAL_TAXONOMY_POLICY
+    ),
+)
+
+
+CANONICAL_AREA_ALIASES: tuple[tuple[str, str], ...] = (
+    *((alias, area.name) for area in CANONICAL_TAXONOMY_POLICY for alias in area.aliases),
+)
+
+
+CANONICAL_TAXONOMY_ALIASES: tuple[tuple[str, str, str], ...] = (
+    *(
+        (alias, area.name, specialty.name)
+        for area in CANONICAL_TAXONOMY_POLICY
+        for specialty in area.specialties
+        for alias in specialty.aliases
+    ),
+)
+
+
+@dataclass(frozen=True)
+class TaxonomyResolution:
+    requested_taxonomy: str
+    taxonomy: str
+    parts: tuple[str, ...]
+    canonicalized: tuple[dict[str, str], ...]
+    new_dirs: tuple[str, ...]
+
+    @property
+    def has_new_dirs(self) -> bool:
+        return bool(self.new_dirs)
+
+    def to_json(self, wiki_dir: Path, title: str | None = None) -> JsonObject:
+        data: JsonObject = {
+            "wiki_dir": str(wiki_dir),
+            "requested_taxonomy": self.requested_taxonomy,
+            "taxonomy": self.taxonomy,
+            "parts": list(self.parts),
+            "canonicalized": list(self.canonicalized),
+            "new_dirs": list(self.new_dirs),
+            "requires_new_folder": self.has_new_dirs,
+        }
+        if title is not None:
+            data["title"] = title
+            data["target_path"] = str(wiki_dir.joinpath(*self.parts, f"{safe_title(title)}.md"))
+        return data
+
+def _canonical_roots_by_fold() -> dict[str, str]:
+    return {_fold_taxonomy_segment(root): root for root, _specialties in CANONICAL_TAXONOMY}
+
+
+def _canonical_area_aliases_by_fold() -> dict[str, str]:
+    mapping = _canonical_roots_by_fold()
+    for alias, root in CANONICAL_AREA_ALIASES:
+        mapping[_fold_taxonomy_segment(alias)] = root
+    return mapping
+
+
+def _canonical_specialties_by_fold() -> dict[str, tuple[str, str]]:
+    mapping: dict[str, tuple[str, str]] = {}
+    for root, specialties in CANONICAL_TAXONOMY:
+        for specialty in specialties:
+            mapping[_fold_taxonomy_segment(specialty)] = (root, specialty)
+            mapping[_fold_taxonomy_segment(specialty.replace(" ", "_"))] = (root, specialty)
+    for alias, root, specialty in CANONICAL_TAXONOMY_ALIASES:
+        mapping[_fold_taxonomy_segment(alias)] = (root, specialty)
+    return mapping
+
+
+def _canonical_specialties_for_root(root: str) -> dict[str, str]:
+    specialties = next((items for candidate, items in CANONICAL_TAXONOMY if candidate == root), ())
+    mapping = {_fold_taxonomy_segment(specialty): specialty for specialty in specialties}
+    for alias, alias_root, specialty in CANONICAL_TAXONOMY_ALIASES:
+        if alias_root == root:
+            mapping[_fold_taxonomy_segment(alias)] = specialty
+    return mapping
+
+
+def canonical_taxonomy_tree() -> dict[str, Any]:
+    areas = []
+    for root, specialties in CANONICAL_TAXONOMY:
+        areas.append({"area": root, "specialties": list(specialties)})
+    return {"schema": "medical-notes-workbench.canonical-taxonomy.v1", "areas": areas}

package/.opencode/mednotes/src/mednotes/domains/wiki/capabilities/vocabulary/taxonomy/status.py

@@ -0,0 +1,137 @@
+"""Human-facing taxonomy status reports."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import ConfigDict, Field, NonNegativeInt, StrictBool, StrictStr
+
+from mednotes.domains.wiki.capabilities.vocabulary.taxonomy.audit import taxonomy_audit
+from mednotes.domains.wiki.capabilities.vocabulary.taxonomy.migration import taxonomy_migration_plan
+from mednotes.domains.wiki.capabilities.vocabulary.taxonomy.policy import TAXONOMY_POLICY_VERSION
+from mednotes.kernel.base import ContractModel, JsonObject, JsonObjectAdapter
+
+TAXONOMY_STATUS_SCHEMA = "medical-notes-workbench.taxonomy-status.v1"
+
+
+class _TaxonomyStatusSummaryPayload(ContractModel):
+    safe_move_count: NonNegativeInt
+    blocked_count: NonNegativeInt
+    unmapped_top_level_dir_count: NonNegativeInt
+    root_note_count: NonNegativeInt
+
+
+class _TaxonomyStatusOperationPayload(ContractModel):
+    model_config = ConfigDict(extra="ignore", populate_by_name=True, validate_assignment=True)
+
+    source: StrictStr
+    destination: StrictStr
+    reason: StrictStr = ""
+
+
+class _TaxonomyStatusBlockedItemPayload(ContractModel):
+    model_config = ConfigDict(extra="ignore", populate_by_name=True, validate_assignment=True)
+
+    source: StrictStr
+    blocked_reason: StrictStr
+
+
+class _TaxonomyStatusPayload(ContractModel):
+    schema_: StrictStr = Field(alias="schema", serialization_alias="schema")
+    wiki_dir: StrictStr
+    taxonomy_policy_version: StrictStr
+    status: StrictStr
+    blocked_reason: StrictStr = ""
+    next_action: StrictStr
+    recommended_next_action: StrictStr
+    required_inputs: list[StrictStr] = Field(default_factory=list)
+    human_decision_required: StrictBool = False
+    summary: _TaxonomyStatusSummaryPayload
+    operations: list[_TaxonomyStatusOperationPayload] = Field(default_factory=list)
+    # Public workflow payloads reserve root `blocked` for a boolean guardrail
+    # signal. Taxonomy keeps the internal plan's blockers under an explicit
+    # item-list name so the generic FSM hardener never mistakes it for state.
+    blocked_items: list[_TaxonomyStatusBlockedItemPayload] = Field(default_factory=list)
+    audit: JsonObject = Field(default_factory=dict)
+    human_report_markdown: StrictStr = ""
+
+
+def _status_from_counts(operation_count: int, blocked_count: int) -> str:
+    if blocked_count:
+        return "needs_review"
+    if operation_count:
+        return "ready_to_plan"
+    return "ok"
+
+
+def _next_action(status: str) -> str:
+    return {
+        "ok": "no_action_needed",
+        "ready_to_plan": "write_plan_then_apply_if_reviewed",
+        "needs_review": "review_blockers_before_apply",
+    }[status]
+
+
+def _blocked_reason(status: str) -> str:
+    return "taxonomy_review_required" if status == "needs_review" else ""
+
+
+def render_taxonomy_status_markdown(payload: JsonObject) -> str:
+    typed = _TaxonomyStatusPayload.model_validate(JsonObjectAdapter.validate_python(payload))
+    lines = [
+        "# Taxonomy Status",
+        "",
+        f"status: {typed.status}",
+        f"taxonomy_policy_version: {typed.taxonomy_policy_version}",
+        "",
+        "## Summary",
+        "",
+        f"- safe moves: {typed.summary.safe_move_count}",
+        f"- blockers: {typed.summary.blocked_count}",
+        f"- unmapped top-level dirs: {typed.summary.unmapped_top_level_dir_count}",
+        f"- root notes: {typed.summary.root_note_count}",
+        "",
+        "## Safe Moves",
+        "",
+    ]
+    if typed.operations:
+        for item in typed.operations:
+            lines.append(f"- `{item.source}` -> `{item.destination}` ({item.reason})")
+    else:
+        lines.append("- none")
+    lines.extend(["", "## Blockers", ""])
+    if typed.blocked_items:
+        for item in typed.blocked_items:
+            lines.append(f"- `{item.source}`: {item.blocked_reason}")
+    else:
+        lines.append("- none")
+    lines.extend(["", "## Next Action", "", f"- {typed.recommended_next_action}"])
+    return "\n".join(lines) + "\n"
+
+
+def taxonomy_status(wiki_dir: Path) -> JsonObject:
+    audit = taxonomy_audit(wiki_dir)
+    plan = taxonomy_migration_plan(wiki_dir)
+    status = _status_from_counts(len(plan["operations"]), len(plan["blocked_items"]))
+    next_action = _next_action(status)
+    payload = _TaxonomyStatusPayload(
+        schema=TAXONOMY_STATUS_SCHEMA,
+        wiki_dir=str(wiki_dir),
+        taxonomy_policy_version=TAXONOMY_POLICY_VERSION,
+        status=status,
+        blocked_reason=_blocked_reason(status),
+        next_action=next_action,
+        recommended_next_action=next_action,
+        required_inputs=["taxonomy_review"] if status == "needs_review" else [],
+        human_decision_required=False,
+        summary=_TaxonomyStatusSummaryPayload(
+            safe_move_count=len(plan["operations"]),
+            blocked_count=len(plan["blocked_items"]),
+            unmapped_top_level_dir_count=len(audit["unmapped_top_level_dirs"]),
+            root_note_count=len(audit["root_notes"]),
+        ),
+        operations=[JsonObjectAdapter.validate_python(item) for item in plan["operations"]],
+        blocked_items=[JsonObjectAdapter.validate_python(item) for item in plan["blocked_items"]],
+        audit=JsonObjectAdapter.validate_python(audit),
+    ).to_payload()
+    payload["human_report_markdown"] = render_taxonomy_status_markdown(payload)
+    return JsonObjectAdapter.validate_python(payload)