modao-prd-cli 0.1.0__py3-none-any.whl

modao_prd_cli/modao_prd/extractor.py

@@ -0,0 +1,465 @@
+"""Build the versioned Agent-friendly document model."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+from .classifier import classify_blocks
+from .capture_evidence import redact_url
+from .normalizer import build_sections, clean_text, normalize_records
+
+
+SCHEMA_VERSION = "2.1"
+
+
+def build_document(raw: dict[str, Any]) -> dict[str, Any]:
+    blocks, _order_map = normalize_records(raw)
+    raw_screens = raw.get("screens") or [{"index": 0, "title": raw.get("title") or "页面 1"}]
+    raw_evidence = raw.get("evidence") or []
+    evidence_by_state: dict[str, list[str]] = {}
+    for item in raw_evidence:
+        if isinstance(item, dict) and item.get("state_id") and item.get("id"):
+            evidence_by_state.setdefault(str(item["state_id"]), []).append(str(item["id"]))
+    primary_evidence_by_state = _primary_evidence_by_state(raw_evidence)
+    raw_states = list(raw.get("states") or [{"id": "state-001", "url": raw.get("final_url"), "depth": 0}])
+    # The complete DOM/layout tree lives in evidence/state-*.dom.json. Keep
+    # document.json agent-readable by retaining state metadata and references,
+    # not duplicating the potentially very large tree inline.
+    states = [
+        {key: value for key, value in item.items() if key != "dom"}
+        for item in raw_states
+    ]
+    state_by_id = {str(item.get("id")): item for item in states}
+    default_state_id = str(states[0].get("id") or "state-001")
+    screens = [
+        {
+            "id": f"screen-{index + 1:03d}",
+            "title": clean_text(str(item.get("title") or f"页面 {index + 1}")),
+            "source_id": item.get("source_id"),
+            "index": index,
+            "bounds": item.get("bounds") or {},
+            "state_id": str(item.get("state_id") or default_state_id),
+            "evidence_ids": list(primary_evidence_by_state.get(str(item.get("state_id") or default_state_id), [])),
+        }
+        for index, item in enumerate(raw_screens)
+    ]
+    for block in blocks:
+        state_id = str(block.get("state_id") or default_state_id)
+        block["state_id"] = state_id
+        block["evidence_ids"] = list(block.get("evidence_ids") or primary_evidence_by_state.get(state_id, []))
+    sections = build_sections(screens, blocks)
+    tables = _build_tables(blocks)
+    block_by_id = {block.get("id"): block for block in blocks}
+    for table in tables:
+        source_block = block_by_id.get(table.get("source_block_id"), {})
+        table["state_id"] = source_block.get("state_id", default_state_id)
+        table["evidence_ids"] = list(source_block.get("evidence_ids") or primary_evidence_by_state.get(table["state_id"], []))
+    assets = [
+        {
+            "id": f"asset-{index + 1:03d}",
+            "block_id": block["id"],
+            **block.get("asset", {}),
+        }
+        for index, block in enumerate(blocks)
+        if block.get("type") == "image"
+    ]
+    for asset in assets:
+        source_block = block_by_id.get(asset.get("block_id"), {})
+        asset["state_id"] = source_block.get("state_id", default_state_id)
+        asset["evidence_ids"] = list(source_block.get("evidence_ids") or primary_evidence_by_state.get(asset["state_id"], []))
+    requirements, interactions, warnings = classify_blocks(blocks)
+    for item in requirements + interactions:
+        item["method"] = "deterministic_text_classification"
+        item["confidence"] = "heuristic"
+        item["source_block_ids"] = list(item.get("source_block_ids", []))
+        source_blocks = [block_by_id[block_id] for block_id in item["source_block_ids"] if block_id in block_by_id]
+        state_ids = _unique([str(block.get("state_id") or default_state_id) for block in source_blocks])
+        screen_ids = _unique([str(block.get("screen_id") or "") for block in source_blocks if block.get("screen_id")])
+        evidence_ids = _unique(
+            evidence_id
+            for block in source_blocks
+            for evidence_id in block.get("evidence_ids", [])
+        )
+        if len(state_ids) == 1:
+            item["state_id"] = state_ids[0]
+        if len(screen_ids) == 1:
+            item["screen_id"] = screen_ids[0]
+        if evidence_ids:
+            item["evidence_ids"] = evidence_ids
+    observed_interactions = list(raw.get("observed_interactions") or raw.get("coverage", {}).get("transitions", []) or [])
+    for observed in observed_interactions:
+        target_id = str(observed.get("target_state_id") or observed.get("state_id") or default_state_id)
+        observed.setdefault("state_id", target_id)
+        observed.setdefault("screen_id", "screen-001")
+        observed.setdefault("evidence_ids", list(primary_evidence_by_state.get(target_id, [])))
+    warnings.extend(raw.get("warnings") or [])
+    warnings.extend(_document_warnings(raw, blocks))
+    warnings = _unique(warnings)
+
+    title = clean_text(str(raw.get("title") or raw.get("project_id") or "墨刀原型"))
+    source_url = redact_url(str(raw.get("requested_url") or raw.get("url") or ""))
+    quality = _quality(raw, blocks, screens)
+    stats = {
+        "screen_count": len(screens),
+        "section_count": len(sections),
+        "block_count": len(blocks),
+        "text_block_count": sum(block["type"] in {"text", "heading", "label", "tab"} for block in blocks),
+        "table_count": len(tables),
+        "image_count": len(assets),
+        "control_count": sum(block["type"] == "button" for block in blocks),
+        "requirement_count": len(requirements),
+        "interaction_count": len(interactions),
+        "warning_count": len(warnings),
+        "body_text_length": raw.get("body_text_length", 0),
+        "quality": quality,
+        "state_count": len(states),
+        "evidence_count": len(raw_evidence),
+        "network_count": len(raw.get("network") or []),
+        "visual_only_count": sum(int((item.get("evidence_stats") or {}).get("visual_only_count", 0)) for item in states),
+    }
+    facts = {
+        "screens": screens,
+        "states": states,
+        "blocks": blocks,
+        "tables": tables,
+        "assets": assets,
+        "observed_interactions": observed_interactions,
+        "visual_regions": _visual_regions(raw_states, primary_evidence_by_state),
+    }
+    derived = {
+        "requirements": requirements,
+        "declared_interactions": interactions,
+    }
+    coverage = {
+        "schema_version": "1.0",
+        **(raw.get("coverage") or {}),
+        "states": states,
+        "transitions": observed_interactions,
+        "uncovered": list((raw.get("coverage") or {}).get("uncovered", [])),
+        "quality": quality,
+        "summary": {
+            "state_count": len(states),
+            "transition_count": len(observed_interactions),
+            "evidence_count": len(raw_evidence),
+            "quality": quality,
+        },
+        "metrics": {
+            "dom": {
+                "states_captured": len(states),
+                "nodes_observed": sum(int((item.get("evidence_stats") or {}).get("dom_node_count", 0)) for item in states),
+            },
+            "page": {"screens_observed": len(screens)},
+            "scroll": {"attempted": bool(raw.get("capture"))},
+            "interaction": {
+                "actions_attempted": int((raw.get("coverage") or {}).get("actions_attempted", 0)),
+                "transitions_observed": len(observed_interactions),
+            },
+            "frame": {
+                "frames_observed": sum(int((item.get("evidence_stats") or {}).get("frame_count", 0)) for item in states),
+            },
+            "resource": {"network_records": len(raw.get("network") or [])},
+            "visual": {
+                "regions": sum(int((item.get("evidence_stats") or {}).get("visual_only_count", 0)) for item in states),
+            },
+        },
+    }
+    # Keep only a compact document overview here. The detailed blocks live in
+    # facts and the complete DOM/layout tree lives in evidence/state-*.dom.json.
+    # Do not duplicate blocks, rules, tables, assets or layout relations in the
+    # Agent-facing document: those projections used to make large prototypes
+    # needlessly expensive to read.
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "source": {
+            "url": source_url,
+            "platform": "modao",
+            "access_mode": "public_share",
+            "title": title,
+            "fetched_at": datetime.now(timezone.utc).isoformat(),
+            "final_url": redact_url(str(raw.get("final_url") or source_url)),
+            "project_id": raw.get("project_id") or _project_id(source_url),
+        },
+        "capture": raw.get("capture") or {},
+        "facts": facts,
+        "derived": derived,
+        "evidence": raw_evidence,
+        "network": list(raw.get("network") or []),
+        "coverage": coverage,
+        "document": {
+            "title": title,
+            "type": "prototype",
+            "sections": sections,
+        },
+        "warnings": warnings,
+        "stats": stats,
+    }
+
+
+def summarize_document(document: dict[str, Any]) -> dict[str, Any]:
+    stats = document.get("stats", {})
+    return {
+        "schema_version": document.get("schema_version"),
+        "title": document.get("source", {}).get("title"),
+        "url": document.get("source", {}).get("url"),
+        "final_url": document.get("source", {}).get("final_url"),
+        "document_type": document.get("document", {}).get("type"),
+        "screens": stats.get("screen_count", len(document.get("facts", {}).get("screens", []))),
+        "sections": stats.get("section_count", 0),
+        "text_blocks": stats.get("text_block_count", 0),
+        "tables": stats.get("table_count", 0),
+        "images": stats.get("image_count", 0),
+        "controls": stats.get("control_count", 0),
+        "requirements": stats.get("requirement_count", 0),
+        "interactions": stats.get("interaction_count", 0),
+        "warnings": document.get("warnings", []),
+        "quality": stats.get("quality") or document.get("coverage", {}).get("quality"),
+        "states": stats.get("state_count", len(document.get("facts", {}).get("states", []))),
+        "evidence": stats.get("evidence_count", len(document.get("evidence", []))),
+    }
+
+
+def extract_from_html(html: str, *, title: str = "墨刀原型", url: str = "") -> dict[str, Any]:
+    """Extract a small deterministic fixture without requiring a browser."""
+
+    parser = _FixtureHTMLParser()
+    parser.feed(html)
+    parser.close()
+    raw = {
+        "title": title,
+        "requested_url": url,
+        "final_url": url,
+        "project_id": _project_id(url),
+        "screens": parser.screens or [{"index": 0, "title": title}],
+        "records": parser.records,
+        "body_text_length": len(clean_text("".join(parser.body_text))),
+    }
+    return build_document(raw)
+
+
+def _build_tables(blocks: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    tables: list[dict[str, Any]] = []
+    for block in blocks:
+        if block.get("type") != "table":
+            continue
+        matrix = [
+            [clean_text(str(cell)) for cell in row]
+            for row in block.get("matrix", [])
+            if any(clean_text(str(cell)) for cell in row)
+        ]
+        if not matrix:
+            continue
+        columns = _unique_columns(matrix[0])
+        rows = []
+        for values in matrix[1:]:
+            rows.append({column: values[index] if index < len(values) else "" for index, column in enumerate(columns)})
+        title = _table_title(blocks, block)
+        tables.append(
+            {
+                "id": f"table-{len(tables) + 1:03d}",
+                "title": title,
+                "screen_id": block.get("screen_id"),
+                "columns": columns,
+                "rows": rows,
+                "raw_matrix": matrix,
+                "cells": (block.get("table") or {}).get("rows", []),
+                "source_block_id": block["id"],
+            }
+        )
+    return tables
+
+
+def _unique_columns(columns: list[str]) -> list[str]:
+    result: list[str] = []
+    counts: dict[str, int] = {}
+    for index, column in enumerate(columns):
+        name = column or f"column_{index + 1}"
+        counts[name] = counts.get(name, 0) + 1
+        result.append(name if counts[name] == 1 else f"{name}_{counts[name]}")
+    return result
+
+
+def _table_title(blocks: list[dict[str, Any]], table_block: dict[str, Any]) -> str:
+    same_screen = [block for block in blocks if block.get("screen_id") == table_block.get("screen_id")]
+    position = next((index for index, block in enumerate(same_screen) if block["id"] == table_block["id"]), 0)
+    for block in reversed(same_screen[max(0, position - 3):position]):
+        text = clean_text(block.get("text"))
+        if block.get("type") in {"heading", "label", "tab"} and text:
+            return text.rstrip("：:")
+    return "未命名表格"
+
+
+def _document_warnings(raw: dict[str, Any], blocks: list[dict[str, Any]]) -> list[str]:
+    warnings: list[str] = []
+    if not raw.get("screens"):
+        warnings.append("未识别到明确画布节点，页面内容按默认页面归档。")
+    if not any(block.get("type") == "table" for block in blocks):
+        warnings.append("未识别到 HTML 表格；画布中的视觉表格可能仍保留在文本或图片中。")
+    return warnings
+
+
+def _quality(raw: dict[str, Any], blocks: list[dict[str, Any]], screens: list[dict[str, Any]]) -> str:
+    if not blocks or not screens:
+        return "unknown"
+    coverage = raw.get("coverage") or {}
+    if coverage.get("partial_reason") or any(
+        any(marker in str(item) for marker in ("未保存", "达到", "不可见", "无法读取", "未结构化"))
+        for item in raw.get("warnings", [])
+    ):
+        return "partial"
+    return "complete_within_policy"
+
+
+def _primary_evidence_by_state(raw_evidence: list[dict[str, Any]]) -> dict[str, list[str]]:
+    """Return the small set of evidence refs useful for Agent fact nodes.
+
+    Asset refs are intentionally kept at state level. Attaching every loaded
+    image to every block made a large page repeat the same list hundreds of
+    times. A block can still reach all state evidence through ``state_id`` and
+    the top-level evidence index.
+    """
+
+    preferred_kinds = {"dom", "screen_screenshot"}
+    result: dict[str, list[str]] = {}
+    for item in raw_evidence:
+        if not isinstance(item, dict) or item.get("state_id") is None or not item.get("id"):
+            continue
+        if item.get("kind") not in preferred_kinds:
+            continue
+        state_id = str(item["state_id"])
+        refs = result.setdefault(state_id, [])
+        evidence_id = str(item["id"])
+        if evidence_id not in refs:
+            refs.append(evidence_id)
+    return result
+
+
+def _visual_regions(states: list[dict[str, Any]], evidence_by_state: dict[str, list[str]]) -> list[dict[str, Any]]:
+    regions: list[dict[str, Any]] = []
+    for state in states:
+        state_id = str(state.get("id") or "")
+        node_by_id = {node.get("id"): node for node in (state.get("dom") or {}).get("nodes", [])}
+        for region in (state.get("dom") or {}).get("visual_only", []):
+            node = node_by_id.get(region.get("node_id"), {})
+            regions.append(
+                {
+                    **region,
+                    "state_id": state_id,
+                    "screen_id": node.get("screen_id") or "screen-001",
+                    "evidence_ids": list(evidence_by_state.get(state_id, [])),
+                    "classification": "visual_only",
+                }
+            )
+    return regions
+
+
+def _project_id(url: str) -> str:
+    match = re.search(r"/proto/([A-Za-z0-9_-]+)/sharing", url)
+    return match.group(1) if match else "unknown"
+
+
+def _unique(values: list[str]) -> list[str]:
+    result: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        if value not in seen:
+            seen.add(value)
+            result.append(value)
+    return result
+
+
+class _FixtureHTMLParser(HTMLParser):
+    """Small parser for offline fixtures; production extraction happens in JS."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.stack: list[dict[str, Any]] = []
+        self.records: list[dict[str, Any]] = []
+        self.screens: list[dict[str, Any]] = []
+        self.body_text: list[str] = []
+        self._order = 0
+
+    def handle_starttag(self, tag: str, attrs_list: list[tuple[str, str | None]]) -> None:
+        attrs = dict(attrs_list)
+        classes = set((attrs.get("class") or "").split())
+        context = {"tag": tag, "classes": classes, "attrs": attrs, "text": [], "matrix": None}
+        self.stack.append(context)
+        if "mb-screen" in classes:
+            self.screens.append({"index": len(self.screens), "title": attrs.get("data-title") or f"页面 {len(self.screens) + 1}"})
+        if tag == "table":
+            context["matrix"] = []
+        if tag in {"td", "th"}:
+            context["cell"] = []
+
+    def handle_startendtag(self, tag: str, attrs_list: list[tuple[str, str | None]]) -> None:
+        if tag == "img":
+            attrs = dict(attrs_list)
+            self._add_record(
+                "image",
+                clean_text(attrs.get("alt")) or "image",
+                {"tag": tag, "classes": set(), "attrs": attrs},
+                src=attrs.get("src"),
+                alt=clean_text(attrs.get("alt")),
+                embedded=(attrs.get("src") or "").startswith("data:"),
+                natural_width=0,
+                natural_height=0,
+            )
+            return
+        self.handle_starttag(tag, attrs_list)
+        self.handle_endtag(tag)
+
+    def handle_endtag(self, tag: str) -> None:
+        if not self.stack:
+            return
+        index = len(self.stack) - 1
+        while index >= 0 and self.stack[index]["tag"] != tag:
+            index -= 1
+        if index < 0:
+            return
+        context = self.stack.pop(index)
+        text = clean_text("".join(context.get("text", [])))
+        if text and self.stack:
+            self.stack[-1].setdefault("text", []).append(text)
+        ancestor_classes = set().union(*(item.get("classes", set()) for item in self.stack)) if self.stack else set()
+        if tag == "tr" and self.stack:
+            table = next((item for item in reversed(self.stack) if item.get("tag") == "table"), None)
+            if table is not None:
+                table.setdefault("matrix", []).append(context.get("cells", []))
+        if tag in {"td", "th"} and self.stack:
+            row = next((item for item in reversed(self.stack) if item.get("tag") == "tr"), None)
+            if row is not None:
+                row.setdefault("cells", []).append(text)
+        if "wRichText" in context.get("classes", set()) and "wRichText" not in ancestor_classes and text:
+            self._add_record("text", text, context)
+        if tag == "table" and context.get("matrix"):
+            self._add_record("table", "\n".join(" | ".join(row) for row in context["matrix"]), context, matrix=context["matrix"])
+        if tag == "button" and text:
+            self._add_record("button", text, context)
+
+    def handle_data(self, data: str) -> None:
+        if not self.stack:
+            return
+        self.stack[-1].setdefault("text", []).append(data)
+        self.body_text.append(data)
+
+    def _add_record(self, kind: str, text: str, context: dict[str, Any], **extra: Any) -> None:
+        screen_index = max(
+            (index for index, item in enumerate(self.stack) if "mb-screen" in item.get("classes", set())),
+            default=0,
+        )
+        record = {
+            "kind": kind,
+            "text": text,
+            "screen_index": screen_index,
+            "tag": context.get("tag", ""),
+            "selector": "." + ".".join(sorted(context.get("classes", set()))) if context.get("classes") else context.get("tag", ""),
+            "bounds": {},
+            "dom_order": self._order,
+            **extra,
+        }
+        self._order += 1
+        self.records.append(record)

modao_prd_cli/modao_prd/models.py

@@ -0,0 +1,56 @@
+"""Small, JSON-friendly data models for capture evidence and coverage."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class CaptureOptions:
+    """Options shared by a capture run."""
+
+    max_item: int = 10 * 1024 * 1024
+    max_total: int = 200 * 1024 * 1024
+    force: bool = False
+
+
+@dataclass(slots=True)
+class EvidenceItem:
+    path: str
+    sha256: str
+    size: int
+    media_type: str
+
+
+@dataclass(slots=True)
+class CaptureResult:
+    output_dir: str
+    manifest: str
+    items: list[EvidenceItem] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class StateRecord:
+    id: str
+    title: str | None = None
+    url: str | None = None
+    screenshot: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class TransitionRecord:
+    source: str
+    target: str
+    trigger: str
+    action: str | None = None
+    evidence: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class CoverageReport:
+    states: list[StateRecord] = field(default_factory=list)
+    transitions: list[TransitionRecord] = field(default_factory=list)
+    uncovered: list[str] = field(default_factory=list)
+    summary: dict[str, Any] = field(default_factory=dict)

modao_prd_cli/modao_prd/normalizer.py

@@ -0,0 +1,135 @@
+"""Turn browser records into stable, deterministic document blocks."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+SPACE_RE = re.compile(r"[ \t]+")
+
+
+def clean_text(value: str | None) -> str:
+    if not value:
+        return ""
+    value = value.replace("\u00a0", " ").replace("\r\n", "\n").replace("\r", "\n")
+    value = "\n".join(SPACE_RE.sub(" ", line).strip() for line in value.split("\n"))
+    return value.strip()
+
+
+def infer_block_type(kind: str, text: str, screen_title: str = "") -> str:
+    if kind == "table":
+        return "table"
+    if kind == "button":
+        return "button"
+    if kind == "image":
+        return "image"
+    if re.match(r"^(TAB\s*\d+|页面\s*\d+)[-—:：]", text, re.I):
+        return "tab"
+    if screen_title and text == screen_title:
+        return "heading"
+    if len(text) <= 32 and (text.endswith(("：", ":")) or text in {"攻略", "奖励", "记录", "其他说明"}):
+        return "label"
+    return "text"
+
+
+def normalize_records(raw: dict[str, Any]) -> tuple[list[dict[str, Any]], dict[int, str]]:
+    """Normalize raw browser records and return blocks plus raw-order mapping."""
+
+    screens = raw.get("screens") or [{"index": 0, "title": "页面 1"}]
+    screen_by_index = {int(item.get("index", index)): item for index, item in enumerate(screens)}
+    blocks: list[dict[str, Any]] = []
+    raw_order_to_block: dict[int, str] = {}
+    seen: dict[tuple[Any, ...], str] = {}
+
+    records = sorted(raw.get("records") or [], key=lambda item: int(item.get("dom_order", 0)))
+    for raw_record in records:
+        text = clean_text(raw_record.get("text"))
+        kind = str(raw_record.get("kind", "text"))
+        if not text and kind != "image":
+            continue
+        screen_index = int(raw_record.get("screen_index", 0))
+        screen = screen_by_index.get(screen_index, {"title": f"页面 {screen_index + 1}"})
+        screen_id = f"screen-{screen_index + 1:03d}"
+        block_type = infer_block_type(kind, text, str(screen.get("title", "")))
+        bounds = raw_record.get("bounds") or {}
+        dedupe_key = (
+            screen_id,
+            block_type,
+            text,
+            bounds.get("x"),
+            bounds.get("y"),
+            raw_record.get("selector"),
+        )
+        block_id = f"block-{len(blocks) + 1:03d}"
+        block: dict[str, Any] = {
+            "id": block_id,
+            "type": block_type,
+            "screen_id": screen_id,
+            "order": len(blocks) + 1,
+            "text": text,
+            "source": {
+                "selector": raw_record.get("selector", ""),
+                "tag": raw_record.get("tag", ""),
+                "dom_order": raw_record.get("dom_order"),
+            },
+            "state_id": str(raw_record.get("state_id") or "state-001"),
+        }
+        if dedupe_key in seen:
+            block["duplicate_of"] = seen[dedupe_key]
+        else:
+            seen[dedupe_key] = block_id
+        if bounds:
+            block["bounds"] = bounds
+        if kind == "table":
+            block["matrix"] = raw_record.get("matrix") or []
+            block["table"] = raw_record.get("table") or {}
+        if kind == "image":
+            block["asset"] = {
+                "src": raw_record.get("src"),
+                "alt": raw_record.get("alt", ""),
+                "embedded": bool(raw_record.get("embedded", False)),
+                "natural_width": raw_record.get("natural_width", 0),
+                "natural_height": raw_record.get("natural_height", 0),
+            }
+        blocks.append(block)
+        raw_order = raw_record.get("dom_order")
+        if isinstance(raw_order, int):
+            raw_order_to_block[raw_order] = block_id
+
+    return blocks, raw_order_to_block
+
+
+def build_sections(
+    screens: list[dict[str, Any]], blocks: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """Create lightweight page sections without inventing semantic content."""
+
+    sections: list[dict[str, Any]] = []
+    for index, screen in enumerate(screens):
+        screen_id = f"screen-{index + 1:03d}"
+        screen_blocks = [block for block in blocks if block["screen_id"] == screen_id]
+        tab_blocks = [block for block in screen_blocks if block["type"] == "tab"]
+        if not tab_blocks:
+            sections.append(
+                {
+                    "id": f"section-{len(sections) + 1:03d}",
+                    "title": screen.get("title") or f"页面 {index + 1}",
+                    "screen_id": screen_id,
+                    "block_ids": [block["id"] for block in screen_blocks],
+                }
+            )
+            continue
+
+        for tab_index, tab in enumerate(tab_blocks):
+            start = screen_blocks.index(tab)
+            end = screen_blocks.index(tab_blocks[tab_index + 1]) if tab_index + 1 < len(tab_blocks) else len(screen_blocks)
+            sections.append(
+                {
+                    "id": f"section-{len(sections) + 1:03d}",
+                    "title": tab["text"],
+                    "screen_id": screen_id,
+                    "block_ids": [block["id"] for block in screen_blocks[start:end]],
+                }
+            )
+    return sections

modao_prd_cli/modao_prd/schemas/coverage-1.0.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "coverage-1.0.json",
+  "title": "Capture coverage report",
+  "type": "object",
+  "required": ["schema_version", "states", "transitions"],
+  "properties": {
+    "schema_version": {"const": "1.0"},
+    "states": {"type": "array"},
+    "transitions": {"type": "array"},
+    "uncovered": {"type": "array", "items": {"type": "string"}},
+    "summary": {"type": "object"}
+  },
+  "additionalProperties": true
+}