feat(examples): add code-review SQL schema and ReviewStore

DNKYr · DNKYr · commit 3ebd0f9b7915 · 2026-07-16T12:34:18.000+08:00
diff --git a/examples/skills_code_review_agent/storage/__init__.py b/examples/skills_code_review_agent/storage/__init__.py
@@ -0,0 +1,6 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+"""Persistence layer for the code-review example."""
diff --git a/examples/skills_code_review_agent/storage/models.py b/examples/skills_code_review_agent/storage/models.py
@@ -0,0 +1,104 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+"""SQLAlchemy declarative models for the code-review example."""
+import uuid
+from datetime import datetime
+
+from sqlalchemy import JSON, Boolean, DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+def _uuid() -> str:
+    return uuid.uuid4().hex
+
+
+class CrBase(DeclarativeBase):
+    """Dedicated base so only this example's tables are created."""
+
+
+class ReviewTaskRow(CrBase):
+    __tablename__ = "cr_review_tasks"
+
+    id: Mapped[str] = mapped_column(String(64), primary_key=True, default=_uuid)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
+    finished_at: Mapped[datetime] = mapped_column(DateTime, nullable=True)
+    status: Mapped[str] = mapped_column(String(32), default="pending")
+    input_type: Mapped[str] = mapped_column(String(32), default="")
+    input_ref: Mapped[str] = mapped_column(String(512), default="")
+    runtime: Mapped[str] = mapped_column(String(32), default="local")
+    dry_run: Mapped[bool] = mapped_column(Boolean, default=True)
+    diff_summary: Mapped[dict] = mapped_column(JSON, nullable=True)
+
+
+class SandboxRunRow(CrBase):
+    __tablename__ = "cr_sandbox_runs"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    task_id: Mapped[str] = mapped_column(String(64), ForeignKey("cr_review_tasks.id"))
+    script: Mapped[str] = mapped_column(String(128), default="")
+    category: Mapped[str] = mapped_column(String(64), default="")
+    status: Mapped[str] = mapped_column(String(32), default="")
+    exit_code: Mapped[int] = mapped_column(Integer, default=0)
+    duration_ms: Mapped[int] = mapped_column(Integer, default=0)
+    timed_out: Mapped[bool] = mapped_column(Boolean, default=False)
+    stdout_summary: Mapped[str] = mapped_column(Text, default="")
+    stderr_summary: Mapped[str] = mapped_column(Text, default="")
+    error_type: Mapped[str] = mapped_column(String(64), default="")
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
+
+
+class FindingRow(CrBase):
+    __tablename__ = "cr_findings"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    task_id: Mapped[str] = mapped_column(String(64), ForeignKey("cr_review_tasks.id"))
+    severity: Mapped[str] = mapped_column(String(16), default="")
+    category: Mapped[str] = mapped_column(String(64), default="")
+    file: Mapped[str] = mapped_column(String(512), default="")
+    line: Mapped[int] = mapped_column(Integer, default=0)
+    title: Mapped[str] = mapped_column(String(256), default="")
+    evidence: Mapped[str] = mapped_column(Text, default="")
+    recommendation: Mapped[str] = mapped_column(Text, default="")
+    confidence: Mapped[float] = mapped_column(Float, default=1.0)
+    source: Mapped[str] = mapped_column(String(32), default="static")
+    status: Mapped[str] = mapped_column(String(32), default="reported")
+    dedup_key: Mapped[str] = mapped_column(String(640), default="")
+
+
+class FilterEventRow(CrBase):
+    __tablename__ = "cr_filter_events"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    task_id: Mapped[str] = mapped_column(String(64), ForeignKey("cr_review_tasks.id"))
+    target: Mapped[str] = mapped_column(String(512), default="")
+    decision: Mapped[str] = mapped_column(String(32), default="")
+    rule: Mapped[str] = mapped_column(String(64), default="")
+    reason: Mapped[str] = mapped_column(Text, default="")
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
+
+
+class MetricsRow(CrBase):
+    __tablename__ = "cr_metrics"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    task_id: Mapped[str] = mapped_column(String(64), ForeignKey("cr_review_tasks.id"))
+    total_duration_ms: Mapped[int] = mapped_column(Integer, default=0)
+    sandbox_duration_ms: Mapped[int] = mapped_column(Integer, default=0)
+    tool_calls: Mapped[int] = mapped_column(Integer, default=0)
+    intercepts: Mapped[int] = mapped_column(Integer, default=0)
+    findings_total: Mapped[int] = mapped_column(Integer, default=0)
+    severity_distribution: Mapped[dict] = mapped_column(JSON, nullable=True)
+    error_distribution: Mapped[dict] = mapped_column(JSON, nullable=True)
+
+
+class ReportRow(CrBase):
+    __tablename__ = "cr_reports"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    task_id: Mapped[str] = mapped_column(String(64), ForeignKey("cr_review_tasks.id"))
+    report_json: Mapped[dict] = mapped_column(JSON, nullable=True)
+    report_md: Mapped[str] = mapped_column(Text, default="")
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now)
diff --git a/examples/skills_code_review_agent/storage/store.py b/examples/skills_code_review_agent/storage/store.py
@@ -0,0 +1,124 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+"""ReviewStore: persistence built on the SDK's SqlStorage (SQLite by default,
+any SQLAlchemy db_url works)."""
+from datetime import datetime
+
+from trpc_agent_sdk.storage import SqlCondition, SqlKey, SqlStorage
+
+from review.redaction import redact_text
+
+from .models import (CrBase, FilterEventRow, FindingRow, MetricsRow, ReportRow,
+                     ReviewTaskRow, SandboxRunRow)
+
+
+def _row_to_dict(row):
+    if row is None:
+        return None
+    return {c.name: getattr(row, c.name) for c in row.__table__.columns}
+
+
+class ReviewStore:
+    """CRUD facade over the code-review tables. All write paths redact secrets."""
+
+    def __init__(self, db_url: str = "sqlite:///code_review.db"):
+        self._storage = SqlStorage(is_async=False, db_url=db_url, metadata=CrBase.metadata)
+
+    async def _add(self, row) -> None:
+        async with self._storage.create_db_session() as db:
+            await self._storage.add(db, row)
+            await self._storage.commit(db)
+
+    async def create_task(self, input_type: str, input_ref: str, runtime: str,
+                          dry_run: bool) -> str:
+        row = ReviewTaskRow(input_type=input_type, input_ref=input_ref,
+                            runtime=runtime, dry_run=dry_run, status="running")
+        task_id = row.id or ""
+        if not task_id:
+            import uuid
+            task_id = uuid.uuid4().hex
+            row.id = task_id
+        await self._add(row)
+        return task_id
+
+    async def update_task(self, task_id: str, status: str = None,
+                          diff_summary: dict = None, finished: bool = False) -> None:
+        async with self._storage.create_db_session() as db:
+            row = await self._storage.get(db, SqlKey(key=(task_id,), storage_cls=ReviewTaskRow))
+            if row is None:
+                return
+            if status is not None:
+                row.status = status
+            if diff_summary is not None:
+                row.diff_summary = diff_summary
+            if finished:
+                row.finished_at = datetime.now()
+            await self._storage.commit(db)
+
+    async def add_sandbox_run(self, task_id: str, *, script: str, category: str,
+                              status: str, exit_code: int, duration_ms: int,
+                              timed_out: bool, stdout_summary: str,
+                              stderr_summary: str, error_type: str) -> None:
+        await self._add(SandboxRunRow(
+            task_id=task_id, script=script, category=category, status=status,
+            exit_code=exit_code, duration_ms=duration_ms, timed_out=timed_out,
+            stdout_summary=redact_text(stdout_summary),
+            stderr_summary=redact_text(stderr_summary), error_type=error_type))
+
+    async def add_findings(self, task_id: str, findings, status: str) -> None:
+        for f in findings:
+            await self._add(FindingRow(
+                task_id=task_id, severity=f.severity, category=f.category,
+                file=f.file, line=f.line, title=f.title,
+                evidence=redact_text(f.evidence), recommendation=f.recommendation,
+                confidence=f.confidence, source=f.source, status=status,
+                dedup_key=f.dedup_key))
+
+    async def add_filter_event(self, task_id: str, target: str, decision: str,
+                               rule: str, reason: str) -> None:
+        await self._add(FilterEventRow(task_id=task_id, target=redact_text(target),
+                                       decision=decision, rule=rule, reason=reason))
+
+    async def add_metrics(self, task_id: str, metrics: dict) -> None:
+        await self._add(MetricsRow(
+            task_id=task_id,
+            total_duration_ms=metrics.get("total_duration_ms", 0),
+            sandbox_duration_ms=metrics.get("sandbox_duration_ms", 0),
+            tool_calls=metrics.get("tool_calls", 0),
+            intercepts=metrics.get("intercepts", 0),
+            findings_total=metrics.get("findings_total", 0),
+            severity_distribution=metrics.get("severity_distribution", {}),
+            error_distribution=metrics.get("error_distribution", {})))
+
+    async def add_report(self, task_id: str, report_json: dict, report_md: str) -> None:
+        await self._add(ReportRow(task_id=task_id, report_json=report_json,
+                                  report_md=redact_text(report_md)))
+
+    async def _query_all(self, db, storage_cls, task_id):
+        rows = await self._storage.query(
+            db, SqlKey(key=(), storage_cls=storage_cls),
+            SqlCondition(filters=[storage_cls.task_id == task_id]))
+        return [_row_to_dict(r) for r in rows]
+
+    async def get_task_bundle(self, task_id: str) -> dict:
+        async with self._storage.create_db_session() as db:
+            task = await self._storage.get(db, SqlKey(key=(task_id,), storage_cls=ReviewTaskRow))
+            runs = await self._query_all(db, SandboxRunRow, task_id)
+            findings = await self._query_all(db, FindingRow, task_id)
+            events = await self._query_all(db, FilterEventRow, task_id)
+            metrics_rows = await self._query_all(db, MetricsRow, task_id)
+            report_rows = await self._query_all(db, ReportRow, task_id)
+        return {
+            "task": _row_to_dict(task),
+            "sandbox_runs": runs,
+            "findings": findings,
+            "filter_events": events,
+            "metrics": metrics_rows[0] if metrics_rows else None,
+            "report": report_rows[0] if report_rows else None,
+        }
+
+    async def close(self) -> None:
+        await self._storage.close()
diff --git a/examples/skills_code_review_agent/tests/test_store.py b/examples/skills_code_review_agent/tests/test_store.py
@@ -0,0 +1,73 @@
+# Tencent is pleased to support the open source community by making tRPC-Agent-Python available.
+#
+# Copyright (C) 2026 Tencent. All rights reserved.
+#
+# tRPC-Agent-Python is licensed under Apache-2.0.
+"""Tests for the SQLite-backed ReviewStore."""
+from review.findings import Finding
+from storage.store import ReviewStore
+
+
+async def _new_store(tmp_path):
+    return ReviewStore(db_url=f"sqlite:///{tmp_path}/cr.db")
+
+
+async def test_task_roundtrip(tmp_path):
+    store = await _new_store(tmp_path)
+    task_id = await store.create_task("fixture", "clean.diff", "local", True)
+    assert task_id
+    await store.update_task(task_id, status="completed",
+                            diff_summary={"files_changed": 1}, finished=True)
+    bundle = await store.get_task_bundle(task_id)
+    assert bundle["task"]["status"] == "completed"
+    assert bundle["task"]["diff_summary"]["files_changed"] == 1
+    assert bundle["task"]["dry_run"] is True
+    await store.close()
+
+
+async def test_bundle_collects_all_tables(tmp_path):
+    store = await _new_store(tmp_path)
+    task_id = await store.create_task("fixture", "x.diff", "local", True)
+    await store.add_sandbox_run(task_id, script="check_security.py", category="security",
+                                status="ok", exit_code=0, duration_ms=12, timed_out=False,
+                                stdout_summary="{}", stderr_summary="", error_type="")
+    await store.add_findings(task_id, [Finding(
+        severity="critical", category="secret_leak", file="a.py", line=3,
+        title="secret", evidence='key = "sk-abcdefghijklmnopqrstuvwxyz123456"',
+        confidence=0.95)], status="reported")
+    await store.add_filter_event(task_id, "rm -rf /", "deny", "risk_command", "destructive command")
+    await store.add_metrics(task_id, {"total_duration_ms": 1000, "sandbox_duration_ms": 500,
+                                      "tool_calls": 6, "intercepts": 1, "findings_total": 1,
+                                      "severity_distribution": {"critical": 1},
+                                      "error_distribution": {}})
+    await store.add_report(task_id, {"conclusion": "blocked"}, "# report")
+    bundle = await store.get_task_bundle(task_id)
+    assert len(bundle["sandbox_runs"]) == 1
+    assert len(bundle["findings"]) == 1
+    assert len(bundle["filter_events"]) == 1
+    assert bundle["metrics"]["tool_calls"] == 6
+    assert bundle["report"]["report_json"]["conclusion"] == "blocked"
+    await store.close()
+
+
+async def test_store_redacts_evidence_and_output(tmp_path):
+    store = await _new_store(tmp_path)
+    task_id = await store.create_task("fixture", "x.diff", "local", True)
+    secret = "sk-abcdefghijklmnopqrstuvwxyz123456"
+    await store.add_findings(task_id, [Finding(
+        severity="critical", category="secret_leak", file="a.py", line=3,
+        title="secret", evidence=f'key = "{secret}"', confidence=0.95)], status="reported")
+    await store.add_sandbox_run(task_id, script="s.py", category="c", status="ok",
+                                exit_code=0, duration_ms=1, timed_out=False,
+                                stdout_summary=f"leaked {secret}", stderr_summary="", error_type="")
+    bundle = await store.get_task_bundle(task_id)
+    assert secret not in bundle["findings"][0]["evidence"]
+    assert secret not in bundle["sandbox_runs"][0]["stdout_summary"]
+    await store.close()
+
+
+async def test_unknown_task_returns_none_task(tmp_path):
+    store = await _new_store(tmp_path)
+    bundle = await store.get_task_bundle("nope")
+    assert bundle["task"] is None
+    await store.close()
