loopx 0.4.8__py3-none-any.whl

loopx/presentation/renderers/periodic_report_markdown.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from ...capabilities.periodic_report.adapters import (
+    ARTIFACT_SCHEMA,
+    DOCUMENT_SCHEMA,
+    PeriodicReportRendererAdapter,
+    validate_periodic_report_editorial,
+)
+from ..public_safety import redact_public_text
+
+
+def _mapping(value: object) -> dict[str, Any]:
+    return dict(value) if isinstance(value, Mapping) else {}
+
+
+def _items(value: object) -> list[dict[str, Any]]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes)):
+        return []
+    return [dict(item) for item in value if isinstance(item, Mapping)]
+
+
+def _safe(value: object, *, maximum: int) -> str:
+    return str(redact_public_text(value, limit=maximum))
+
+
+def _visibility(item: Mapping[str, Any]) -> str:
+    return str(item.get("visibility") or "primary")
+
+
+def periodic_report_labels(language: object) -> dict[str, str]:
+    """Return the small built-in report UI vocabulary for one language."""
+
+    if str(language or "").lower().startswith("zh"):
+        return {
+            "period": "报告周期",
+            "no_items": "暂无条目。",
+            "next": "下一步",
+            "source": "来源",
+            "supporting_appendix": "附录：投递与运行信息",
+            "label_separator": "：",
+        }
+    return {
+        "period": "Period",
+        "no_items": "No items.",
+        "next": "Next",
+        "source": "source",
+        "supporting_appendix": "Appendix: delivery and runtime context",
+        "label_separator": ": ",
+    }
+
+
+def _render_markdown_item(
+    lines: list[str],
+    item: Mapping[str, Any],
+    *,
+    labels: Mapping[str, str],
+) -> None:
+    item_title = _safe(item.get("title"), maximum=240)
+    source_ref = _safe(item.get("source_ref"), maximum=500)
+    status = _safe(item.get("status"), maximum=80)
+    headline = f"- **{item_title}**"
+    if status:
+        headline += f" · `{status}`"
+    if source_ref:
+        headline += f" · [{labels['source']}]({source_ref})"
+    lines.append(headline)
+    lines.append(f"  - {_safe(item.get('summary'), maximum=1000)}")
+    for detail in _items(item.get("details")):
+        detail_label = _safe(detail.get("label"), maximum=40)
+        detail_text = _safe(detail.get("text"), maximum=500)
+        lines.append(
+            f"  - **{detail_label}{labels['label_separator']}** {detail_text}"
+        )
+    next_action = _safe(item.get("next_action"), maximum=500)
+    if next_action:
+        lines.append(
+            f"  - **{labels['next']}{labels['label_separator']}** {next_action}"
+        )
+
+
+def render_periodic_report_markdown(
+    document: Mapping[str, Any],
+) -> dict[str, Any]:
+    """Render normalized sections without changing ordering or business meaning."""
+
+    if document.get("schema_version") != DOCUMENT_SCHEMA:
+        raise ValueError(f"document must use {DOCUMENT_SCHEMA}")
+    validate_periodic_report_editorial(document)
+    title = _safe(document.get("title"), maximum=200)
+    window = _mapping(document.get("period_window"))
+    editorial = _mapping(document.get("editorial"))
+    editorial_orchestration = _mapping(editorial.get("orchestration"))
+    labels = periodic_report_labels(editorial.get("language"))
+    period_label = _safe(editorial.get("period_label"), maximum=160)
+    lines = [
+        f"# {title}",
+        "",
+        (
+            period_label
+            or f"{labels['period']}：`{window.get('start_at')}` – `{window.get('end_at')}`"
+        ),
+    ]
+    summary = _safe(editorial.get("summary"), maximum=600)
+    if summary:
+        lines.extend(["", summary])
+    primary_item_count = 0
+    supporting_item_count = 0
+    supporting_sections: list[tuple[dict[str, Any], list[dict[str, Any]]]] = []
+    for section in _items(document.get("sections")):
+        all_items = _items(section.get("items"))
+        section_items = [item for item in all_items if _visibility(item) == "primary"]
+        section_supporting = [
+            item for item in all_items if _visibility(item) == "supporting"
+        ]
+        supporting_item_count += len(section_supporting)
+        if section_supporting:
+            supporting_sections.append((section, section_supporting))
+        primary_item_count += len(section_items)
+        if all_items and not section_items:
+            continue
+        lines.extend(["", f"## {_safe(section.get('title'), maximum=160)}", ""])
+        if not section_items:
+            lines.append(f"- {labels['no_items']}")
+            continue
+        for item in section_items:
+            _render_markdown_item(lines, item, labels=labels)
+    if supporting_sections:
+        lines.extend(["", f"## {labels['supporting_appendix']}"])
+        for section, section_items in supporting_sections:
+            lines.extend(["", f"### {_safe(section.get('title'), maximum=160)}", ""])
+            for item in section_items:
+                _render_markdown_item(lines, item, labels=labels)
+    content = "\n".join(lines).rstrip() + "\n"
+    content_digest = hashlib.sha256(content.encode("utf-8")).hexdigest()
+    document_digest = hashlib.sha256(
+        json.dumps(
+            document,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8")
+    ).hexdigest()
+    return {
+        "schema_version": ARTIFACT_SCHEMA,
+        "artifact_id": "periodic_report_markdown",
+        "renderer_id": "markdown_v0",
+        "renderer_kind": "markdown",
+        "content": content,
+        "content_digest": f"sha256:{content_digest}",
+        "artifact_ref": f"artifact:periodic-report/{content_digest[:24]}",
+        "document_digest": f"sha256:{document_digest}",
+        "content_policy": {
+            "primary_visibility": "primary",
+            "supporting_visibility": "supporting",
+            "supporting_context": "appendix",
+            "process_narration_default_visible": False,
+            "editorial_summary_source": editorial_orchestration.get(
+                "summary_source", "none"
+            ),
+            "readability_policy": editorial_orchestration.get(
+                "readability_policy", "none"
+            ),
+            "primary_item_count": primary_item_count,
+            "supporting_item_count": supporting_item_count,
+        },
+        "boundary": {
+            "schedule_policy_applied": False,
+            "business_evidence_judged": False,
+            "external_writes_performed": False,
+        },
+    }
+
+
+def periodic_report_markdown_renderer_adapter() -> PeriodicReportRendererAdapter:
+    return PeriodicReportRendererAdapter(
+        renderer_id="markdown_v0",
+        renderer_kind="markdown",
+        render=render_periodic_report_markdown,
+    )

loopx/presentation/renderers/quota_event_markdown.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ...control_plane.quota.slot_accounting import QUOTA_SLOT_SPENT_CLASSIFICATION
+from ..markdown import append_operator_action_markdown, as_dict
+
+
+def render_quota_monitor_poll_markdown(payload: dict[str, Any]) -> str:
+    if payload.get("ok") is False:
+        lines = [
+            "# LoopX Quota Monitor Poll",
+            "",
+            "- ok: `False`",
+            f"- mode: `{payload.get('mode') or 'monitor-poll'}`",
+            f"- goal_id: `{payload.get('goal_id') or ''}`",
+            f"- appended: `{bool(payload.get('appended'))}`",
+            f"- registry_mutated: `{bool(payload.get('registry_mutated'))}`",
+            f"- agent_id: `{payload.get('agent_id') or ''}`",
+            f"- source: `{payload.get('source') or ''}`",
+            f"- todo_id: `{payload.get('todo_id') or ''}`",
+            f"- target_key: `{payload.get('target_key') or ''}`",
+            f"- material_change: `{bool(payload.get('material_change'))}`",
+            f"- reason: {payload.get('reason') or 'monitor-poll rejected'}",
+        ]
+        append_operator_action_markdown(lines, payload)
+        return "\n".join(lines)
+    event = as_dict(payload.get("monitor_event"))
+    before = as_dict(event.get("before"))
+    todo_writeback = as_dict(event.get("todo_writeback"))
+    monitor_target = as_dict(event.get("monitor_target"))
+    lines = [
+        "# LoopX Quota Monitor Poll",
+        "",
+        f"- goal_id: `{payload.get('goal_id')}`",
+        f"- classification: `{payload.get('classification')}`",
+        f"- agent_id: `{payload.get('agent_id') or event.get('agent_id') or ''}`",
+        f"- source: `{event.get('source')}`",
+        f"- effective_action: `{before.get('effective_action')}`",
+        f"- monitor_target: `{monitor_target.get('target_id')}`",
+        f"- todo_id: `{event.get('todo_id') or ''}`",
+        f"- target_key: `{event.get('target_key') or ''}`",
+        f"- material_change: `{event.get('material_change')}`",
+        f"- should_run: `{before.get('should_run')}`",
+        f"- self_repair_allowed: `{before.get('self_repair_allowed')}`",
+        f"- state: `{before.get('state')}`",
+        f"- health_check: {payload.get('health_check')}",
+        f"- reason: {event.get('reason_summary')}",
+    ]
+    if todo_writeback:
+        lines.append(
+            "- todo_writeback: "
+            f"dry_run={todo_writeback.get('dry_run')} "
+            f"consecutive_no_change={todo_writeback.get('consecutive_no_change')} "
+            f"last_checked_at={todo_writeback.get('last_checked_at')} "
+            f"next_due_at={todo_writeback.get('next_due_at')}"
+        )
+    append_operator_action_markdown(lines, payload)
+    return "\n".join(lines)
+
+
+def render_quota_slot_preview_markdown(payload: dict[str, Any]) -> str:
+    before = as_dict(payload.get("before"))
+    after = as_dict(payload.get("after"))
+    before_quota = (
+        as_dict(before.get("quota"))
+        if isinstance(before.get("quota"), dict)
+        else before
+    )
+    after_quota = (
+        as_dict(after.get("quota"))
+        if isinstance(after.get("quota"), dict)
+        else after
+    )
+    lines = [
+        "# LoopX Quota Slot Preview",
+        "",
+        f"- ok: `{payload.get('ok')}`",
+        f"- dry_run: `{payload.get('dry_run')}`",
+        f"- goal_id: `{payload.get('goal_id')}`",
+        f"- classification: `{payload.get('classification') or QUOTA_SLOT_SPENT_CLASSIFICATION}`",
+        f"- agent_id: `{payload.get('agent_id') or ''}`",
+        f"- slots: `{payload.get('slots')}`",
+        f"- appended: `{payload.get('appended')}`",
+        f"- registry_mutated: `{payload.get('registry_mutated')}`",
+        f"- would_throttle: `{payload.get('would_throttle')}`",
+    ]
+    if payload.get("json_path"):
+        lines.append(f"- json_path: `{payload.get('json_path')}`")
+    if payload.get("index_path"):
+        lines.append(f"- index_path: `{payload.get('index_path')}`")
+    if payload.get("reason"):
+        lines.append(f"- reason: {payload.get('reason')}")
+    if before:
+        lines.append(
+            "- before: "
+            f"state={before.get('state')} "
+            f"should_run={before.get('should_run')} "
+            f"slots={before_quota.get('spent_slots')}/{before_quota.get('allowed_slots')}"
+        )
+    if after:
+        lines.append(
+            "- after: "
+            f"state={after.get('state')} "
+            f"should_run={after.get('should_run')} "
+            f"slots={after_quota.get('spent_slots')}/{after_quota.get('allowed_slots')}"
+        )
+        summary = as_dict(after.get("plan_summary"))
+        if summary:
+            lines.append(
+                f"- after_plan_next_automatic_turn: {summary.get('next_automatic_turn') or 'none'}"
+            )
+    if payload.get("rolling_window_note"):
+        lines.append(f"- rolling_window_note: {payload.get('rolling_window_note')}")
+    append_operator_action_markdown(lines, payload)
+    return "\n".join(lines)