Render nested report content semantically

app.py

@@ -101,10 +101,14 @@ class ReportSection(BaseModel):
             raise ValueError("section content must be substantive")
         if self.layout == "timeline" and len(content.get("nodes", [])) < 2:
             raise ValueError("timeline content requires at least two nodes")
+        if self.layout == "timeline" and not all(isinstance(node, dict) for node in content.get("nodes", [])):
+            raise ValueError("timeline nodes must be objects")
         if self.layout == "comparison" and (
             len(content.get("columns", [])) < 2 or len(content.get("rows", [])) < 2
         ):
             raise ValueError("comparison content requires columns and at least two rows")
+        if self.layout == "comparison" and not all(isinstance(row, dict) for row in content.get("rows", [])):
+            raise ValueError("comparison rows must be objects")
         if self.layout == "paper-analysis" and not all(
             content.get(key) for key in ("method", "evidence", "limitations")
         ):
@@ -649,11 +653,40 @@ def render_presentation_legacy(report: dict[str, Any], papers: list[dict[str, An
 </main><div class="progress"><span id="progress-bar"></span></div><script>{deck_js}</script></body></html>'''
 
 
-def render_value(value: Any) -> str:
+def field_label(key: Any) -> str:
+    labels = {
+        "points": "要点", "details": "详细说明", "claim": "结论", "claims": "结论",
+        "conditions": "适用条件", "evidence": "证据", "limitations": "局限",
+        "method": "方法", "mechanism": "机制", "problem": "问题", "innovation": "创新",
+        "tradeoffs": "权衡", "interpretation": "解释", "related_topics": "相关主题",
+        "hypotheses": "待验证假设", "required_inputs": "所需补充信息", "findings": "发现",
+    }
+    normalized = str(key).strip().lower().replace("-", "_")
+    return labels.get(normalized, str(key).replace("_", " ").replace("-", " ").strip().title())
+
+
+def render_value(value: Any, *, depth: int = 0) -> str:
+    """Render arbitrary model JSON recursively instead of leaking JSON/Python repr."""
+    if value is None or value == "":
+        return ""
     if isinstance(value, list):
-        return "<ul>" + "".join(f"<li>{esc(x) if not isinstance(x, dict) else esc(json.dumps(x, ensure_ascii=False))}</li>" for x in value) + "</ul>"
+        if not value:
+            return ""
+        return '<div class="content-list">' + "".join(
+            f'<article class="content-card">{render_value(item, depth=depth + 1)}</article>'
+            if isinstance(item, dict) else
+            f'<div class="content-item">{render_value(item, depth=depth + 1)}</div>'
+            for item in value
+        ) + "</div>"
     if isinstance(value, dict):
-        return "<dl>" + "".join(f"<dt>{esc(k)}</dt><dd>{esc(v)}</dd>" for k, v in value.items()) + "</dl>"
+        if not value:
+            return ""
+        return '<div class="content-object">' + "".join(
+            f'<div class="content-field"><h4>{esc(field_label(key))}</h4>{render_value(item, depth=depth + 1)}</div>'
+            for key, item in value.items() if item is not None and item != ""
+        ) + "</div>"
+    if isinstance(value, bool):
+        return f'<p>{"是" if value else "否"}</p>'
     return f"<p>{esc(value)}</p>"
 
 
@@ -661,25 +694,36 @@ def render_section_content(section: dict[str, Any]) -> str:
     content, layout = section.get("content", {}), section.get("layout", "text")
     if layout == "timeline":
         return '<div class="timeline">' + "".join(
-            f'<article class="milestone"><span>{esc(n.get("year"))}</span><h3>{esc(n.get("title"))}</h3>'
-            f'<p>{esc(n.get("innovation") or n.get("description"))}</p><small>{esc(n.get("limitation"))}</small></article>'
+            f'<article class="milestone"><span>{esc(n.get("year") or n.get("stage"))}</span>'
+            f'<h3>{esc(n.get("title") or n.get("method") or n.get("name"))}</h3>'
+            f'{render_value({k: v for k, v in n.items() if k not in {"year", "stage", "title", "method", "name"}})}</article>'
             for n in content.get("nodes", [])
         ) + "</div>"
     if layout == "comparison":
         columns, rows = content.get("columns", []), content.get("rows", [])
         head = "".join(f"<th>{esc(x)}</th>" for x in columns)
+        def cells(row: dict[str, Any]) -> list[Any]:
+            values = row.get("values")
+            if isinstance(values, dict):
+                return [values.get(column, "") for column in columns]
+            if isinstance(values, list):
+                return values
+            reserved = {"name", "method", "title"}
+            return [row.get(column, "") for column in columns] or [v for k, v in row.items() if k not in reserved]
         body = "".join(
-            f'<tr><th>{esc(row.get("name"))}</th>{"".join(f"<td>{esc(v)}</td>" for v in row.get("values", []))}</tr>'
+            f'<tr><th>{esc(row.get("name") or row.get("method") or row.get("title"))}</th>'
+            f'{"".join(f"<td>{render_value(v)}</td>" for v in cells(row))}</tr>'
             for row in rows
         )
         return f'<div class="table-wrap"><table><thead><tr><th>方法</th>{head}</tr></thead><tbody>{body}</tbody></table></div>'
     if layout == "process":
-        return '<ol class="process">' + "".join(f"<li>{esc(x)}</li>" for x in content.get("steps", [])) + "</ol>"
+        return '<div class="process">' + "".join(
+            f'<article class="process-step"><span>{i}</span>{render_value(step)}</article>'
+            for i, step in enumerate(content.get("steps", []), 1)
+        ) + "</div>"
     if layout == "equation":
-        symbols = content.get("symbols", {})
-        symbol_items = symbols.items() if isinstance(symbols, dict) else []
         return (f'<pre class="equation">{esc(content.get("equation"))}</pre><p>{esc(content.get("interpretation"))}</p>'
-                f'<dl>{"".join(f"<dt>{esc(k)}</dt><dd>{esc(v)}</dd>" for k, v in symbol_items)}</dl>')
+                f'{render_value(content.get("symbols"))}')
     wrapper = "aside" if layout == "evidence-gap" else "div"
     return f'<{wrapper} class="{esc(layout)}">' + "".join(
         f'<h3>{esc(k.replace("_", " ").title())}</h3>{render_value(v)}' for k, v in content.items()
@@ -688,7 +732,10 @@ def render_section_content(section: dict[str, Any]) -> str:
 
 # This later definition intentionally replaces the legacy fixed-layout renderer above.
 def render_presentation(report: dict[str, Any], papers: list[dict[str, Any]], cutoff: str) -> str:
-    deck_css = (STATIC_DIR / "deck.css").read_text(encoding="utf-8")
+    deck_css = "\n".join(
+        (STATIC_DIR / name).read_text(encoding="utf-8")
+        for name in ("deck.css", "dynamic-content.css")
+    )
     deck_js = (STATIC_DIR / "deck.js").read_text(encoding="utf-8").replace("</script", "<\\/script")
     citations = {p["id"]: p for p in papers}
     evidence_mode = (report.get("english_understanding") or {}).get("evidence_mode", "")

static/dynamic-content.css

@@ -0,0 +1,61 @@
+.content-list {
+  display: grid;
+  gap: 10px;
+}
+.content-item,
+.content-card,
+.content-field,
+.process-step {
+  padding: 10px 14px;
+  border: 1px solid #344158;
+  border-radius: 9px;
+  background: #101827;
+}
+.content-card .content-object {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+  gap: 8px;
+}
+.content-field h4 {
+  margin: 0 0 4px;
+  color: var(--accent);
+  font-size: 13px;
+}
+.content-field p,
+.content-item p {
+  margin: 0;
+}
+.process {
+  display: grid;
+  gap: 12px;
+}
+.process-step {
+  display: grid;
+  grid-template-columns: 38px 1fr;
+  align-items: start;
+  gap: 12px;
+}
+.process-step > span {
+  display: grid;
+  place-items: center;
+  width: 32px;
+  height: 32px;
+  border-radius: 50%;
+  background: #263b68;
+  color: #fff;
+  font-weight: 700;
+}
+.equation {
+  overflow: auto;
+  padding: 18px;
+  border: 1px solid #344158;
+  border-radius: 9px;
+  background: #101827;
+  font-size: clamp(16px, 1.6vw, 24px);
+}
+.evidence-gap {
+  padding: 16px;
+  border-left: 4px solid #e7ae59;
+  border-radius: 8px;
+  background: #231c12;
+}

tests/test_app.py

@@ -2,7 +2,7 @@ import unittest
 
 from pydantic import ValidationError
 
-from app import ResearchReport, deduplicate, render_presentation, safe_slug
+from app import ResearchReport, deduplicate, render_presentation, render_section_content, render_value, safe_slug
 
 
 def base_report(section):
@@ -55,6 +55,23 @@ class AppTests(unittest.TestCase):
         with self.assertRaises(ValidationError):
             ResearchReport.model_validate(base_report(section))
 
+    def test_nested_json_is_rendered_as_semantic_html(self):
+        output = render_value({"findings": [{"claim": "Works well", "conditions": ["GPU", "FP16"]}]})
+        self.assertIn("<h4>", output)
+        self.assertIn("Works well", output)
+        self.assertIn("GPU", output)
+        self.assertNotIn("{&quot;", output)
+        self.assertNotIn("['GPU'", output)
+
+    def test_timeline_keeps_nonstandard_fields(self):
+        output = render_section_content({"layout": "timeline", "content": {"nodes": [
+            {"stage": "Early", "method": "Baseline", "problem": "High cost", "tradeoffs": ["Memory", "Latency"]},
+            {"stage": "Later", "method": "Improved", "problem": "Low recall", "tradeoffs": ["Complexity"]},
+        ]}})
+        self.assertIn("High cost", output)
+        self.assertIn("Memory", output)
+        self.assertNotIn("{'", output)
+
 
 if __name__ == "__main__":
     unittest.main()