diff --git a/examples/skills_code_review_agent/.env.example b/examples/skills_code_review_agent/.env.example new file mode 100644 index 00000000..8016449f --- /dev/null +++ b/examples/skills_code_review_agent/.env.example @@ -0,0 +1,14 @@ +# All variables are OPTIONAL — the example runs fully offline by default +# (--dry-run / --model-mode fake needs no key at all). +# +# NOTE: this file is NOT loaded automatically (no dotenv dependency). Export +# the variables into your shell yourself, e.g.: +# set -a; source .env; set +a + +# Only used with --model-mode real (LLM summary stage): +TRPC_AGENT_API_KEY=your_api_key +TRPC_AGENT_BASE_URL=https://api.openai.com/v1 +TRPC_AGENT_MODEL_NAME=gpt-4o-mini + +# Only used with --sandbox cube (Cube/E2B workspace runtime): +E2B_API_KEY=your_e2b_key diff --git a/examples/skills_code_review_agent/DESIGN.zh_CN.md b/examples/skills_code_review_agent/DESIGN.zh_CN.md new file mode 100644 index 00000000..d50d44d7 --- /dev/null +++ b/examples/skills_code_review_agent/DESIGN.zh_CN.md @@ -0,0 +1,15 @@ +# 方案设计说明 + +**Skill 设计**：code-review Skill 以 SKILL.md 声明用法，规则文档与执行脚本分离；diff 解析器、规则引擎与密钥正则表统一放在 scripts/lib（纯标准库），沙箱内直接执行，宿主经 importlib 加载同一份代码，检测与脱敏单源不漂移。规则覆盖安全风险、异步错误、资源泄漏、测试缺失、敏感信息泄漏与数据库生命周期六类。 + +**沙箱隔离**：生产默认 Container 运行时，亦支持 Cube/E2B；本地运行时仅作开发回退，并重写环境构造逻辑，仅放行白名单变量。每次执行受超时与输出字节上限约束；失败、超时、异常均记录为 sandbox_run 行并触发宿主内规则回退，评审任务绝不中断。 + +**Filter 策略**：沙箱执行前经 BaseFilter 链决策：高风险脚本内容、非白名单命令、禁止路径、网络访问、超预算运行分别产生 deny 或 needs_human_review；被拦截的执行不会进入沙箱，原因同时写入报告与数据库。 + +**监控字段**：总耗时、沙箱耗时与次数、工具调用数、拦截次数与决策分布、finding 数、severity 分布、异常类型分布，随报告入库可查，并辅以 tracer span。 + +**数据库 schema**：cr_review_task、cr_sandbox_run、cr_filter_event、cr_finding、cr_report 五表，经 ReviewStore 抽象接口访问；SQLite 为默认实现，更换连接 URL 即切换 MySQL/PostgreSQL。 + +**去重降噪**：同文件同行同类问题仅报一条，保留最高严重级别并合并命中的规则号；置信度低于阈值的启发式结果进入人工复核桶，不混入高置信 findings。 + +**安全边界**：证据在沙箱内先行脱敏，宿主对报告与全部入库字段递归二次脱敏；diff 摘要不含代码内容，明文密钥不落任何持久化面。 diff --git a/examples/skills_code_review_agent/README.en.md b/examples/skills_code_review_agent/README.en.md new file mode 100644 index 00000000..774b48c7 --- /dev/null +++ b/examples/skills_code_review_agent/README.en.md @@ -0,0 +1,84 @@ +# Automatic Code-Review Agent (Skills + Sandbox + Database) + +> 中文文档: [README.md](README.md) · Design note (Chinese): [DESIGN.zh_CN.md](DESIGN.zh_CN.md) + +A verifiable automatic code-review (CR) agent prototype built on the +tRPC-Agent SDK: it reads a git diff / PR patch / local changes, loads rules +and scripts through the **code-review Skill**, executes static checks in a +**sandbox** after the **Filter policy** approves, persists structured +findings, block records, sandbox logs and monitoring metrics to a **SQL +database**, and renders `review_report.json` + `review_report.md`. + +## Highlights + +- **CR Skill** (`skills/code-review/`): SKILL.md + rule docs + sandbox + scripts covering six categories — security risk, async errors, resource + leaks, missing tests, secret leakage, DB transaction/connection lifecycle + (the issue requires four). +- **One implementation, both sides**: the diff parser, rule engine and secret + pattern table live in `skills/code-review/scripts/lib/` (stdlib-only). The + sandbox executes it directly; the host loads the very same files via + importlib — detection and redaction can never drift apart. +- **Sandbox execution**: `--sandbox` defaults to **auto** — **container** + (Docker, native isolation) when Docker is available, otherwise a clearly + logged fallback to **local**; **cube** (Cube/E2B) is supported. **local** + is a development fallback only (tests/dry-run pin it) and is hardened with + `EnvWhitelistLocalProgramRunner` so host secrets never enter the sandbox. +- **Safety boundary**: per-run timeout, stdout/stderr size cap, env + whitelist, in-sandbox evidence redaction; timeouts/failures/exceptions are + recorded as data (`cr_sandbox_run` rows) and the pipeline falls back to the + in-process rule engine — **a sandbox crash never kills a review**. +- **Filter governance**: `SandboxGovernanceFilter` (real SDK `BaseFilter` + + `run_filters` chain) pre-blocks risky scripts, non-whitelisted commands, + forbidden paths, network access and over-budget runs. On + `deny`/`needs_human_review` the terminal handler is never invoked; reasons + land in the report and `cr_filter_event`. +- **Dedup & noise control**: one report per `(file, line, category)` (highest + severity wins, merged rule ids preserved); findings with confidence < 0.7 + go to `needs_human_review` and never mix into high-confidence findings. +- **Storage**: five tables behind the `ReviewStore` ABC; switching to + MySQL/PostgreSQL is just a different SQLAlchemy URL. +- **Monitoring**: total/sandbox duration, tool calls, filter decisions, + finding counts, severity distribution, exception types — all DB-queryable, + plus OpenTelemetry tracer spans per phase. +- **Offline by default**: `--dry-run` (fake model + local sandbox) needs no + API key and finishes in seconds (acceptance limit: 2 minutes). + +## Usage + +```bash +cd examples/skills_code_review_agent + +python run_agent.py review --fixture security_issue --dry-run # no API key +python run_agent.py review --diff-file my.patch +python run_agent.py review --repo-path /path/to/repo +python run_agent.py review --files a.py b.py + +python run_agent.py show --task-id # full DB bundle for one task +python run_agent.py list +python run_agent.py init-db # idempotent schema init/migration + +# production shape: container sandbox + real model. Export the variables +# listed in .env.example first — .env is NOT loaded automatically: +# set -a; source .env; set +a +python run_agent.py review --diff-file my.patch --sandbox container --model-mode real +``` + +## Tests + +```bash +python -m pytest examples/skills_code_review_agent/tests -q # 71 passed, all offline +``` + +## Database schema + +`cr_review_task` (task + status machine), `cr_sandbox_run` (every sandbox +attempt incl. blocked/failed, redacted output excerpts), `cr_filter_event` +(every governance decision with reasons), `cr_finding` (structured findings, +bucketed into `finding` / `needs_human_review`), `cr_report` (final document ++ metrics). Everything is queryable by task id via +`ReviewStore.get_task_bundle()` / `run_agent.py show`. + +See README.md (Chinese) for the acceptance-criteria mapping table and the +architecture diagram, and DESIGN.zh_CN.md for the 300–500-character design +note required by the issue. diff --git a/examples/skills_code_review_agent/README.md b/examples/skills_code_review_agent/README.md new file mode 100644 index 00000000..73cb08e1 --- /dev/null +++ b/examples/skills_code_review_agent/README.md @@ -0,0 +1,140 @@ +# 自动代码评审 Agent（Skills + 沙箱 + 数据库） + +> English version: [README.en.md](README.en.md) · 方案设计说明: [DESIGN.zh_CN.md](DESIGN.zh_CN.md) + +本示例基于 tRPC-Agent SDK 构建一个可验证的自动代码评审（CR）Agent 原型： +读取 git diff / PR patch / 本地变更，通过 **code-review Skill** 加载规则与脚本， +经 **Filter 策略**放行后在**沙箱**中执行静态检查，把结构化 findings、拦截记录、 +沙箱日志和监控指标全部落入 **SQL 数据库**，最终输出 `review_report.json` 与 +`review_report.md`。 + +## 关键特性 + +- **CR Skill**（`skills/code-review/`）：SKILL.md + 6 类规则文档 + 沙箱脚本。 + 规则覆盖安全风险、异步错误、资源泄漏、测试缺失、敏感信息泄漏、数据库事务/连接 + 生命周期（超出题目要求的 4 类）。 +- **单一实现，双端复用**：diff 解析器、规则引擎、密钥正则表全部放在 + `skills/code-review/scripts/lib/`（纯标准库）。沙箱内直接执行，宿主端通过 + importlib 加载同一份代码 —— 检测与脱敏永不漂移。 +- **沙箱执行**：`--sandbox` 默认 **auto**——检测到 Docker 即用 **container** + （原生隔离，生产方案），否则记录告警并回退 **local**；另支持 **cube** + （Cube/E2B 云沙箱）。**local** 仅作为开发 fallback（测试与 `--dry-run` 显式 + 使用），并通过 `EnvWhitelistLocalProgramRunner` 强制环境变量白名单， + 宿主密钥不进沙箱。 +- **安全边界**：每次运行有超时、stdout/stderr 大小上限、环境白名单；证据文本在 + 沙箱内即完成脱敏；沙箱超时/失败/异常一律记录为数据（`cr_sandbox_run` 行）， + 自动回退到宿主内规则引擎，**评审任务永不崩溃**。 +- **Filter 治理**：`SandboxGovernanceFilter`（真实 `BaseFilter` + `run_filters` + 链）对高风险脚本、非白名单命令、禁止路径、网络访问、超预算执行做前置拦截； + `deny` / `needs_human_review` 时终端 handler 不会被调用，拦截原因写入报告与 + `cr_filter_event` 表。 +- **去重与降噪**：同一 `(file, line, category)` 只报一次（保最高严重级别，合并 + 规则 ID）；置信度 < 0.7 的启发式结果进入 `needs_human_review`，绝不混入高置信 + findings。 +- **数据库存储**：5 张表（task / sandbox_run / filter_event / finding / report）， + 接口为 `ReviewStore` ABC —— 换 MySQL/PostgreSQL 只需换 SQLAlchemy URL。 +- **监控审计**：总耗时、沙箱耗时、工具调用次数、拦截次数与分布、finding 数量、 + severity 分布、异常类型分布，全部入库可查，另附 OpenTelemetry tracer span。 +- **离线可测**：`--dry-run`（fake model + local 沙箱）不需要任何 API Key， + 完整链路秒级完成（验收要求 ≤ 2 分钟）。 + +## 架构与数据流 + +``` +--diff-file | --repo-path | --files | --fixture + │ inputs.py → RawChangeSet(unified diff + 可选全文件内容) + ▼ +ReviewPipeline.run() [span code_review.total] + 1 建任务 cr_review_task(status=running) + 2 宿主解析 diff → 摘要(无内容, 安全入库) [span code_review.parse] + 3 Filter 治理门 (run_filters) + allow → 4 deny/needs_human_review → 记录拦截, 走宿主回退 + 4 沙箱执行 run_checks.py [span code_review.sandbox] + stage skill → 注入 diff.json → 白名单环境运行(超时/输出上限) + 失败/超时 → cr_sandbox_run 记录 + 宿主回退, 任务继续 + 5 后处理: 去重 → 降噪分桶 → 二次脱敏 [span code_review.postprocess] + 6 LLM 摘要 (fake|real|off) [span code_review.llm] + 7 落库 findings/filter_events/report + 渲染 json/md 报告 +``` + +## 关键文件 + +| 路径 | 说明 | +|---|---| +| `run_agent.py` | CLI 入口（review / show / list / init-db） | +| `skills/code-review/SKILL.md` | Skill 使用说明 | +| `skills/code-review/rules/*.md` | 6 类规则文档 | +| `skills/code-review/scripts/` | 沙箱入口脚本 + 纯标准库规则引擎 `lib/` | +| `codereview/pipeline.py` | 评审编排（任务生命周期、回退、落库） | +| `codereview/governance.py` | Filter 策略（BaseFilter + run_filters） | +| `codereview/sandbox.py` | 沙箱运行时工厂 + 环境白名单 + SandboxExecutor | +| `codereview/findings.py` | Finding 模型、去重、降噪 | +| `codereview/redaction.py` | 宿主端脱敏（复用 Skill 的正则表） | +| `codereview/store/` | ReviewStore ABC + SqlReviewStore + schema + init 脚本 | +| `fixtures/*.diff` | 8 条可运行测试样例 | +| `sample_output/` | 提交的示例报告（json + md） | +| `tests/` | 71 个 pytest 用例（全部离线） | + +## 运行方式 + +```bash +cd examples/skills_code_review_agent + +# 1. 离线体检（无需任何 API Key） +python run_agent.py review --fixture security_issue --dry-run + +# 2. 评审一个 diff / 一个 git 工作区 / 一组文件 +python run_agent.py review --diff-file my.patch +python run_agent.py review --repo-path /path/to/repo +python run_agent.py review --files a.py b.py + +# 3. 查询数据库（按 task id 取回全部记录） +python run_agent.py show --task-id +python run_agent.py list +python run_agent.py init-db # 初始化/迁移 schema（幂等） + +# 4. 生产形态：容器沙箱 + 真实模型 +python run_agent.py review --diff-file my.patch --sandbox container --model-mode real +``` + +- `--sandbox` 默认 **auto**：检测到 Docker 时使用 container + （`python:3.12-slim` 镜像），否则告警并回退 local；`--sandbox cube` 使用 + Cube/E2B（需要 E2B Key）。**local 只是开发 fallback，不是生产方案**—— + 生产请使用 container。 +- `--model-mode real` 需要环境变量 `TRPC_AGENT_API_KEY` / `TRPC_AGENT_BASE_URL` + / `TRPC_AGENT_MODEL_NAME`（键名参考 `.env.example`；本示例**不会**自动加载 + `.env`，请先 `set -a; source .env; set +a` 或逐个 `export`）。 +- `--inject-sandbox-failure` 演示沙箱失败被安全吸收（任务状态 + `completed_with_errors`，报告照常生成）。 + +## 运行测试 + +```bash +python -m pytest examples/skills_code_review_agent/tests -q # 71 passed +``` + +## 数据库 Schema（SQLite 默认，URL 可换 MySQL/PostgreSQL） + +| 表 | 内容 | 关键字段 | +|---|---|---| +| `cr_review_task` | 任务与状态机 | id, status, input_type/ref, diff_summary(JSON), config(JSON), error_* | +| `cr_sandbox_run` | 每次沙箱尝试（含被拦截/失败） | task_id, status(ok/failed/timeout/blocked/error), exit_code, timed_out, filter_action, stdout/stderr 摘录(已脱敏+截断), error_type | +| `cr_filter_event` | 每个治理决策 | task_id, stage, target, action, rule, reasons(JSON) | +| `cr_finding` | 结构化 finding | task_id, severity, category, file, line, title, evidence(已脱敏), recommendation, confidence, source, rule_id, bucket, dedup_key | +| `cr_report` | 最终报告 + 监控摘要 | task_id(unique), summary, severity_stats, filter_summary, sandbox_summary, metrics, report(完整 JSON) | + +初始化/迁移：`python run_agent.py init-db`（`SqlStorage.create_sql_engine` 执行 +`create_all` + 前向列迁移，幂等可重复执行）。 + +## 验收标准对照 + +| # | 验收标准 | 实现/验证 | +|---|---|---| +| 1 | 8 条 diff 样本全部可运行并生成报告 | `fixtures/` 8 条；`tests/test_fixtures_e2e.py` 参数化全跑 | +| 2 | 高危检出 ≥80%，误报 ≤15% | `tests/test_rules.py`：19 条带标注正样本全检出（公开集召回 100%）；10 条干净样本高置信 FP 为 0。隐藏集指标以此带标注语料为代理 | +| 3 | DB 完整记录并按 task id 查询 | 5 张表 + `get_task_bundle(task_id)`；`tests/test_store.py` | +| 4 | 沙箱超时/输出上限；失败不崩溃 | `tests/test_sandbox_safety.py`（超时、截断、强制失败、异常包裹） | +| 5 | 脱敏检出 ≥95%，报告与 DB 无明文 | `tests/test_redaction.py`（48 条样本 ≥95%）；e2e 断言报告与 sqlite 文件字节中无种子明文 | +| 6 | dry-run ≤2 分钟 | `test_dry_run_speed_and_no_api_key`（实测 < 5 秒，且删除全部 Key 环境变量） | +| 7 | 高风险脚本先经 Filter，deny/needs_human_review 不进沙箱 | `tests/test_governance_filter.py`（handler 哨兵证明未执行） | +| 8 | 报告含 7 个规定部分 | `tests/test_cli_and_report.py::test_report_sections_complete` | diff --git a/examples/skills_code_review_agent/codereview/__init__.py b/examples/skills_code_review_agent/codereview/__init__.py new file mode 100644 index 00000000..3a2028ea --- /dev/null +++ b/examples/skills_code_review_agent/codereview/__init__.py @@ -0,0 +1,11 @@ +# 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. +"""Host-side package of the skills_code_review_agent example. + +Orchestrates the automatic code-review pipeline on top of trpc_agent_sdk: +skill-driven rules, governed sandbox execution (Filter), SQL persistence +(storage), telemetry spans and an optional (fake/real) LLM summary stage. +""" diff --git a/examples/skills_code_review_agent/codereview/config.py b/examples/skills_code_review_agent/codereview/config.py new file mode 100644 index 00000000..ec4bea3d --- /dev/null +++ b/examples/skills_code_review_agent/codereview/config.py @@ -0,0 +1,110 @@ +# 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. +"""Configuration dataclasses for the code-review pipeline.""" + +from __future__ import annotations + +import logging +import os +import shutil +from dataclasses import asdict +from dataclasses import dataclass +from dataclasses import field +from typing import FrozenSet +from typing import Tuple + +EXAMPLE_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +SKILLS_ROOT = os.path.join(EXAMPLE_ROOT, "skills") +SKILL_NAME = "code-review" +FIXTURES_DIR = os.path.join(EXAMPLE_ROOT, "fixtures") + +DEFAULT_DB_FILENAME = "review.db" + +#: Environment variables the sandbox is allowed to inherit from the host. +DEFAULT_ENV_WHITELIST: FrozenSet[str] = frozenset({ + "PATH", + "LANG", + "LC_ALL", + "HOME", + "TMPDIR", + "PYTHONIOENCODING", +}) + + +@dataclass +class SandboxConfig: + """Sandbox execution limits and runtime selection. + + ``runtime_kind='container'`` is the default (Docker image, native + isolation); ``'local'`` is the development fallback used by tests and + dry-run on hosts without Docker, hardened with an env whitelist — the CLI + resolves ``--sandbox auto`` via :func:`resolve_sandbox_kind`. ``'cube'`` + targets Cube/E2B cloud sandboxes. + """ + + runtime_kind: str = "container" # container | local | cube + timeout_sec: float = 30.0 + max_output_bytes: int = 64_000 + env_whitelist: FrozenSet[str] = DEFAULT_ENV_WHITELIST + container_image: str = "python:3.12-slim" + work_root: str = "" + force_fail: bool = False # test injection: sandbox check raises deterministically + + +@dataclass +class PolicyConfig: + """Filter governance policy for sandbox runs.""" + + allowed_cmds: Tuple[str, ...] = ("python3", "python") + forbidden_paths: Tuple[str, ...] = ("/etc", "/root", "/var/run/docker.sock", ".ssh", "..", "~") + allow_network: bool = False + max_sandbox_runs: int = 8 + max_total_sandbox_seconds: float = 90.0 + + +@dataclass +class NoiseConfig: + """Dedup / noise-control thresholds.""" + + min_confidence: float = 0.7 # findings below go to needs_human_review + + +@dataclass +class ReviewConfig: + """Top-level pipeline configuration.""" + + db_url: str = "" + out_dir: str = "out" + model_mode: str = "fake" # fake | real | off + model_name: str = "fake-review-v1" + sandbox: SandboxConfig = field(default_factory=SandboxConfig) + policy: PolicyConfig = field(default_factory=PolicyConfig) + noise: NoiseConfig = field(default_factory=NoiseConfig) + + def to_dict(self) -> dict: + data = asdict(self) + data["sandbox"]["env_whitelist"] = sorted(self.sandbox.env_whitelist) + return data + + +def resolve_sandbox_kind(kind: str = "auto") -> str: + """Resolve the ``--sandbox`` choice: ``'auto'`` → ``'container'`` when + Docker is available, otherwise fall back — clearly logged — to the LOCAL + dev runtime. Explicit choices pass through unchanged.""" + if kind != "auto": + return kind + if shutil.which("docker"): + return "container" + logging.getLogger(__name__).warning( + "sandbox 'auto': docker not found on PATH — falling back to the local " + "dev runtime (env-whitelisted, dev fallback only). Install Docker or " + "pass --sandbox container for production isolation.") + return "local" + + +def default_db_url(base_dir: str) -> str: + """SQLite (aiosqlite) URL under ``base_dir`` — the swappable default backend.""" + return f"sqlite+aiosqlite:///{os.path.join(os.path.abspath(base_dir), DEFAULT_DB_FILENAME)}" diff --git a/examples/skills_code_review_agent/codereview/diff_parser.py b/examples/skills_code_review_agent/codereview/diff_parser.py new file mode 100644 index 00000000..c3c61771 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/diff_parser.py @@ -0,0 +1,54 @@ +# 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. +"""Importlib bridge to the skill's stdlib-only library. + +The unified-diff parser, the rule engine and the secret-pattern table live in +``skills/code-review/scripts/lib`` so the SAME implementation runs inside the +sandbox and on the host (single source of truth, no drift). This module loads +that package once and re-exports the host-facing entry points. +""" + +from __future__ import annotations + +import importlib.util +import os +import sys + +from .config import SKILL_NAME +from .config import SKILLS_ROOT + +_LIB_PACKAGE = "cr_skill_lib" +_LIB_DIR = os.path.join(SKILLS_ROOT, SKILL_NAME, "scripts", "lib") + + +def _load_skill_lib(): + if _LIB_PACKAGE in sys.modules: + return sys.modules[_LIB_PACKAGE] + spec = importlib.util.spec_from_file_location( + _LIB_PACKAGE, + os.path.join(_LIB_DIR, "__init__.py"), + submodule_search_locations=[_LIB_DIR], + ) + module = importlib.util.module_from_spec(spec) + sys.modules[_LIB_PACKAGE] = module + spec.loader.exec_module(module) + return module + + +_load_skill_lib() + +# pylint: disable=wrong-import-position,wrong-import-order +from cr_skill_lib.diffparse import build_diff_summary # noqa: E402 +from cr_skill_lib.diffparse import parse_unified_diff # noqa: E402 +from cr_skill_lib.engine import run_all_rules # noqa: E402 +from cr_skill_lib import secret_patterns # noqa: E402 + +__all__ = [ + "build_diff_summary", + "parse_unified_diff", + "run_all_rules", + "secret_patterns", +] diff --git a/examples/skills_code_review_agent/codereview/findings.py b/examples/skills_code_review_agent/codereview/findings.py new file mode 100644 index 00000000..9eda9b5e --- /dev/null +++ b/examples/skills_code_review_agent/codereview/findings.py @@ -0,0 +1,151 @@ +# 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. +"""Finding model, dedup and noise control.""" + +from __future__ import annotations + +from dataclasses import asdict +from dataclasses import dataclass +from dataclasses import field +from enum import Enum +from typing import Any +from typing import Dict +from typing import List +from typing import Tuple + + +class Severity(str, Enum): + CRITICAL = "critical" + HIGH = "high" + MEDIUM = "medium" + LOW = "low" + INFO = "info" + + +class Category(str, Enum): + SECURITY_RISK = "security_risk" + ASYNC_ERROR = "async_error" + RESOURCE_LEAK = "resource_leak" + MISSING_TESTS = "missing_tests" + SECRET_LEAKAGE = "secret_leakage" + DB_LIFECYCLE = "db_lifecycle" + + +class Source(str, Enum): + STATIC_RULE = "static_rule" + SANDBOX_CHECK = "sandbox_check" + LLM = "llm" + + +_SEVERITY_RANK = { + Severity.CRITICAL.value: 4, + Severity.HIGH.value: 3, + Severity.MEDIUM.value: 2, + Severity.LOW.value: 1, + Severity.INFO.value: 0, +} + +BUCKET_FINDING = "finding" +BUCKET_NEEDS_HUMAN_REVIEW = "needs_human_review" + + +@dataclass +class Finding: + """One structured review finding (fields required by issue requirement 4).""" + + severity: str + category: str + file: str + line: int + title: str + evidence: str + recommendation: str + confidence: float + source: str + rule_id: str = "" + extra: Dict[str, Any] = field(default_factory=dict) + + @property + def dedup_key(self) -> Tuple[str, int, str]: + return (self.file, self.line, self.category) + + @property + def severity_rank(self) -> int: + return _SEVERITY_RANK.get(self.severity, 0) + + def to_dict(self) -> Dict[str, Any]: + data = asdict(self) + if not data["extra"]: + data.pop("extra") + return data + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "Finding": + return cls( + severity=str(data.get("severity", Severity.INFO.value)), + category=str(data.get("category", "")), + file=str(data.get("file", "")), + line=int(data.get("line", 0) or 0), + title=str(data.get("title", "")), + evidence=str(data.get("evidence", "")), + recommendation=str(data.get("recommendation", "")), + confidence=float(data.get("confidence", 0.0) or 0.0), + source=str(data.get("source", Source.STATIC_RULE.value)), + rule_id=str(data.get("rule_id", "")), + extra=dict(data.get("extra") or {}), + ) + + +def dedup_findings(findings: List[Finding]) -> Tuple[List[Finding], int]: + """Collapse duplicates: same (file, line, category) reported at most once. + + Keeps the representative with the highest (severity, confidence); merges + the losing rule ids into ``extra['also_matched']`` so no signal is lost. + + Returns: + (kept, removed_count) + """ + best: Dict[Tuple[str, int, str], Finding] = {} + order: List[Tuple[str, int, str]] = [] + removed = 0 + for finding in findings: + key = finding.dedup_key + current = best.get(key) + if current is None: + best[key] = finding + order.append(key) + continue + removed += 1 + finding_wins = ((finding.severity_rank, finding.confidence) + > (current.severity_rank, current.confidence)) + winner, loser = (finding, current) if finding_wins else (current, finding) + if loser.rule_id and loser.rule_id != winner.rule_id: + also = winner.extra.setdefault("also_matched", []) + if loser.rule_id not in also: + also.append(loser.rule_id) + best[key] = winner + return [best[key] for key in order], removed + + +def split_noise(findings: List[Finding], min_confidence: float) -> Tuple[List[Finding], List[Finding]]: + """Split into (high-confidence findings, needs_human_review). + + Low-confidence results NEVER mix into the findings list — they surface in + the report's 人工复核 section instead (issue requirement 6). + """ + high: List[Finding] = [] + review: List[Finding] = [] + for finding in findings: + (high if finding.confidence >= min_confidence else review).append(finding) + return high, review + + +def severity_distribution(findings: List[Finding]) -> Dict[str, int]: + """Count findings per severity, all severities always present.""" + dist = {severity.value: 0 for severity in Severity} + for finding in findings: + dist[finding.severity] = dist.get(finding.severity, 0) + 1 + return dist diff --git a/examples/skills_code_review_agent/codereview/governance.py b/examples/skills_code_review_agent/codereview/governance.py new file mode 100644 index 00000000..dd26c754 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/governance.py @@ -0,0 +1,214 @@ +# 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. +"""Filter governance: pre-execution policy gate for sandbox runs. + +Implements issue requirement 8 with the SDK's real filter chain +(``trpc_agent_sdk.filter.BaseFilter`` + ``run_filters``): every sandbox run is +wrapped as a request; the filter's ``_before`` may veto it, in which case the +terminal handler (the actual sandbox execution) is NEVER invoked and the +policy decision is returned instead. + +Blocking mechanics (verified against ``filter/_base_filter.py``): a policy +block sets ``rsp.rsp = PolicyDecision(...)`` and ``rsp.is_continue = False``. +It must NOT set ``rsp.error`` — ``run_filters`` re-raises errors, and a policy +veto is a decision, not a failure. +""" + +from __future__ import annotations + +import os +import re +from dataclasses import dataclass +from dataclasses import field +from typing import Any +from typing import Awaitable +from typing import Callable +from typing import List +from typing import Optional +from typing import Union + +from trpc_agent_sdk.abc import FilterResult +from trpc_agent_sdk.context import AgentContext +from trpc_agent_sdk.context import create_agent_context +from trpc_agent_sdk.filter import BaseFilter +from trpc_agent_sdk.filter import run_filters + +from .config import PolicyConfig + +ACTION_ALLOW = "allow" +ACTION_DENY = "deny" +ACTION_NEEDS_HUMAN_REVIEW = "needs_human_review" + +#: Script-content patterns that mark a script as high-risk. High-risk scripts +#: are not silently executed OR silently dropped — they go to a human. +DANGEROUS_PATTERNS = ( + ("rm_rf", re.compile(r"\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r)\b")), + ("shutil_rmtree_root", re.compile(r"shutil\.rmtree\s*\(\s*[\"']/")), + ("network_fetch", re.compile(r"\b(?:curl|wget)\b|\burllib\.request\b|\brequests\.(?:get|post)\b" + r"|http[s]?://(?!localhost|127\.0\.0\.1)")), + ("raw_socket", re.compile(r"\bsocket\.socket\b")), + ("privilege", re.compile(r"\bsudo\b|\bsetuid\b|\bos\.setuid\b")), + ("world_writable", re.compile(r"\bchmod\s+777\b|\bos\.chmod\s*\([^)]*0o?777")), + ("sensitive_file", re.compile(r"/etc/passwd|/etc/shadow|\.aws/credentials|id_rsa")), + ("shell_out_network", re.compile(r"subprocess\.[a-zA-Z_]+\s*\([^)]*(?:curl|wget|nc|ncat|ssh)\b")), +) + + +@dataclass +class SandboxRunRequest: + """Everything the policy needs to know about one intended sandbox run.""" + + kind: str # parse_diff | static_checks | custom + cmd: str + args: List[str] = field(default_factory=list) + script_host_path: str = "" # host path of the script, for content inspection + wants_network: bool = False + est_timeout: float = 30.0 + run_index: int = 0 + total_sandbox_seconds: float = 0.0 + + +@dataclass +class PolicyDecision: + """Outcome of the governance gate for one sandbox run.""" + + action: str # allow | deny | needs_human_review + reasons: List[str] = field(default_factory=list) + rule: str = "" + + @property + def blocked(self) -> bool: + return self.action != ACTION_ALLOW + + +class SandboxGovernanceFilter(BaseFilter): + """Pre-execution policy checks for sandbox runs (deny / needs_human_review). + + Check order (first hit wins): + 1. command not whitelisted → deny + 2. risky script content → needs_human_review + 3. forbidden path in args → deny + 4. non-whitelisted network access → deny + 5. over budget (runs / total seconds) → needs_human_review + """ + + def __init__(self, + policy: PolicyConfig, + on_decision: Optional[Callable[[SandboxRunRequest, PolicyDecision], None]] = None) -> None: + super().__init__() + self._policy = policy + self._on_decision = on_decision + + # -- individual checks ------------------------------------------------- + + def _check_cmd(self, req: SandboxRunRequest) -> Optional[PolicyDecision]: + # The request carries the real interpreter (may be an absolute + # sys.executable path, or foo.exe on Windows) — match the policy list + # against the exact value and its normalized basename. + cmd_name = os.path.basename(req.cmd) + if cmd_name.lower().endswith(".exe"): + cmd_name = cmd_name[:-len(".exe")] + if req.cmd not in self._policy.allowed_cmds and cmd_name not in self._policy.allowed_cmds: + return PolicyDecision( + action=ACTION_DENY, + reasons=[f"command {req.cmd!r} is not in the allowed command list " + f"{list(self._policy.allowed_cmds)}"], + rule="allowed_cmds", + ) + return None + + def _check_script_content(self, req: SandboxRunRequest) -> Optional[PolicyDecision]: + if not req.script_host_path or not os.path.isfile(req.script_host_path): + return None + try: + with open(req.script_host_path, "r", encoding="utf-8", errors="replace") as fh: + content = fh.read() + except OSError: + return PolicyDecision(action=ACTION_DENY, + reasons=[f"script {req.script_host_path!r} is unreadable"], + rule="risky_script") + hits = [name for name, pattern in DANGEROUS_PATTERNS if pattern.search(content)] + if hits: + return PolicyDecision( + action=ACTION_NEEDS_HUMAN_REVIEW, + reasons=[f"script matches high-risk pattern(s): {', '.join(hits)}"], + rule="risky_script", + ) + return None + + def _check_paths(self, req: SandboxRunRequest) -> Optional[PolicyDecision]: + for arg in req.args: + if arg.startswith("-"): + continue + normalized = os.path.normpath(arg) + for forbidden in self._policy.forbidden_paths: + if (normalized == forbidden or normalized.startswith(forbidden.rstrip("/") + "/") + or forbidden in normalized.split(os.sep) or normalized.startswith("~")): + return PolicyDecision( + action=ACTION_DENY, + reasons=[f"argument {arg!r} touches forbidden path pattern {forbidden!r}"], + rule="forbidden_paths", + ) + return None + + def _check_network(self, req: SandboxRunRequest) -> Optional[PolicyDecision]: + if req.wants_network and not self._policy.allow_network: + return PolicyDecision( + action=ACTION_DENY, + reasons=["run requests network access but the policy network whitelist is empty"], + rule="network_whitelist", + ) + return None + + def _check_budget(self, req: SandboxRunRequest) -> Optional[PolicyDecision]: + if req.run_index >= self._policy.max_sandbox_runs: + return PolicyDecision( + action=ACTION_NEEDS_HUMAN_REVIEW, + reasons=[f"sandbox run budget exhausted " + f"({req.run_index} >= max {self._policy.max_sandbox_runs} runs)"], + rule="run_budget", + ) + if req.total_sandbox_seconds + req.est_timeout > self._policy.max_total_sandbox_seconds: + return PolicyDecision( + action=ACTION_NEEDS_HUMAN_REVIEW, + reasons=[f"sandbox time budget exceeded " + f"({req.total_sandbox_seconds:.1f}s used + {req.est_timeout:.1f}s requested " + f"> max {self._policy.max_total_sandbox_seconds:.1f}s)"], + rule="time_budget", + ) + return None + + # -- filter hook -------------------------------------------------------- + + async def _before(self, ctx: AgentContext, req: SandboxRunRequest, rsp: FilterResult) -> None: + for check in (self._check_cmd, self._check_script_content, self._check_paths, + self._check_network, self._check_budget): + decision = check(req) + if decision is not None: + # Policy veto: set the decision as the response and stop the + # chain. NEVER set rsp.error — run_filters would raise. + rsp.rsp = decision + rsp.is_continue = False + if self._on_decision: + self._on_decision(req, decision) + return + if self._on_decision: + self._on_decision(req, PolicyDecision(action=ACTION_ALLOW, reasons=[], rule="")) + + +async def gated_sandbox_run( + req: SandboxRunRequest, + governance: SandboxGovernanceFilter, + handler: Callable[[], Awaitable[Any]], + ctx: Optional[AgentContext] = None, +) -> Union[Any, PolicyDecision]: + """Run ``handler`` behind the governance filter chain. + + Returns the handler result when allowed, or the blocking + :class:`PolicyDecision` when vetoed (handler is then never called). + """ + ctx = ctx or create_agent_context() + return await run_filters(ctx, req, [governance], handler) diff --git a/examples/skills_code_review_agent/codereview/inputs.py b/examples/skills_code_review_agent/codereview/inputs.py new file mode 100644 index 00000000..fe9686c9 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/inputs.py @@ -0,0 +1,141 @@ +# 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. +"""Input resolution: --diff-file / --repo-path / --files / --fixture → RawChangeSet.""" + +from __future__ import annotations + +import os +import subprocess +from dataclasses import dataclass +from dataclasses import field +from typing import Dict +from typing import List +from typing import Optional + +from .config import FIXTURES_DIR + +INPUT_DIFF_FILE = "diff_file" +INPUT_REPO_PATH = "repo_path" +INPUT_FILE_LIST = "file_list" +INPUT_FIXTURE = "fixture" + +_MAX_FILE_BYTES = 512_000 # skip pathological blobs when snapshotting file contents + + +@dataclass +class RawChangeSet: + """Normalized review input: a unified diff plus optional full file contents.""" + + input_type: str + input_ref: str + unified_diff_text: str + file_contents: Dict[str, str] = field(default_factory=dict) + + +def _run_git(repo_path: str, *args: str) -> str: + result = subprocess.run( + ["git", "-C", repo_path, *args], + capture_output=True, + text=True, + timeout=30, + check=True, + ) + return result.stdout + + +def _read_text(path: str) -> Optional[str]: + try: + if os.path.getsize(path) > _MAX_FILE_BYTES: + return None + with open(path, "r", encoding="utf-8", errors="replace") as fh: + return fh.read() + except OSError: + return None + + +def _synthesize_add_diff(rel_path: str, content: str) -> str: + lines = content.splitlines() + body = "".join(f"+{line}\n" for line in lines) + count = len(lines) + return (f"diff --git a/{rel_path} b/{rel_path}\n" + f"new file mode 100644\n" + f"--- /dev/null\n" + f"+++ b/{rel_path}\n" + f"@@ -0,0 +1,{count} @@\n" + f"{body}") + + +def from_diff_file(path: str) -> RawChangeSet: + """Read a unified diff / PR patch file.""" + with open(path, "r", encoding="utf-8", errors="replace") as fh: + text = fh.read() + return RawChangeSet(input_type=INPUT_DIFF_FILE, input_ref=os.path.abspath(path), unified_diff_text=text) + + +def from_fixture(name: str) -> RawChangeSet: + """Load one of the committed test fixtures by bare name (e.g. ``security_issue``).""" + filename = name if name.endswith(".diff") else f"{name}.diff" + path = os.path.join(FIXTURES_DIR, filename) + if not os.path.isfile(path): + available = sorted(f[:-5] for f in os.listdir(FIXTURES_DIR) if f.endswith(".diff")) + raise FileNotFoundError(f"unknown fixture {name!r}; available: {', '.join(available)}") + changeset = from_diff_file(path) + changeset.input_type = INPUT_FIXTURE + changeset.input_ref = filename + return changeset + + +def from_repo_path(repo_path: str) -> RawChangeSet: + """Collect working-tree changes of a git repo (tracked diff + untracked adds).""" + repo_path = os.path.abspath(repo_path) + if not os.path.isdir(os.path.join(repo_path, ".git")): + raise ValueError(f"{repo_path} is not a git repository (missing .git)") + + diff_text = _run_git(repo_path, "diff", "HEAD") + untracked = _run_git(repo_path, "ls-files", "--others", "--exclude-standard").splitlines() + + file_contents: Dict[str, str] = {} + extra_diffs: List[str] = [] + for rel in untracked: + content = _read_text(os.path.join(repo_path, rel)) + if content is None: + continue + extra_diffs.append(_synthesize_add_diff(rel, content)) + file_contents[rel] = content + + changed = _run_git(repo_path, "diff", "HEAD", "--name-only").splitlines() + for rel in changed: + content = _read_text(os.path.join(repo_path, rel)) + if content is not None: + file_contents[rel] = content + + return RawChangeSet( + input_type=INPUT_REPO_PATH, + input_ref=repo_path, + unified_diff_text=diff_text + "".join(extra_diffs), + file_contents=file_contents, + ) + + +def from_file_list(paths: List[str], base_dir: str = "") -> RawChangeSet: + """Treat a list of files as wholly-added changes (no VCS required).""" + base = os.path.abspath(base_dir or os.getcwd()) + file_contents: Dict[str, str] = {} + diffs: List[str] = [] + for path in paths: + abs_path = path if os.path.isabs(path) else os.path.join(base, path) + content = _read_text(abs_path) + if content is None: + raise FileNotFoundError(f"cannot read {abs_path}") + rel = os.path.relpath(abs_path, base).replace(os.sep, "/") + diffs.append(_synthesize_add_diff(rel, content)) + file_contents[rel] = content + return RawChangeSet( + input_type=INPUT_FILE_LIST, + input_ref=",".join(paths), + unified_diff_text="".join(diffs), + file_contents=file_contents, + ) diff --git a/examples/skills_code_review_agent/codereview/llm_summary.py b/examples/skills_code_review_agent/codereview/llm_summary.py new file mode 100644 index 00000000..e54a6ecc --- /dev/null +++ b/examples/skills_code_review_agent/codereview/llm_summary.py @@ -0,0 +1,134 @@ +# 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. +"""Optional LLM summary stage (fake | real | off). + +``fake`` (default) needs NO API key: :class:`FakeReviewModel` is a real +``LLMModel`` subclass driven through the real ``LlmAgent`` + ``Runner`` + +``InMemorySessionService`` stack, so the whole agent path is exercised +offline — it just renders a deterministic summary from the request text. +``real`` uses the repo-wide ``TRPC_AGENT_API_KEY`` / ``TRPC_AGENT_BASE_URL`` / +``TRPC_AGENT_MODEL_NAME`` convention with ``OpenAIModel``. +""" + +from __future__ import annotations + +import json +import os +import uuid +from typing import Dict +from typing import List +from typing import Optional + +from trpc_agent_sdk.agents import LlmAgent +from trpc_agent_sdk.models import LLMModel +from trpc_agent_sdk.models import LlmResponse +from trpc_agent_sdk.models import OpenAIModel +from trpc_agent_sdk.runners import Runner +from trpc_agent_sdk.sessions import InMemorySessionService +from trpc_agent_sdk.types import Content +from trpc_agent_sdk.types import Part + +_APP_NAME = "skills_code_review_agent" + +_SUMMARY_INSTRUCTION = ( + "You are a senior code reviewer. Given a JSON digest of static-analysis " + "findings for one changeset, write a concise review summary: overall risk " + "level, the most important issues (file:line), and what to fix first. " + "Do not invent issues that are not in the digest.") + + +def _extract_digest(request) -> Dict: + for content in reversed(request.contents or []): + for part in content.parts or []: + if part.text and "{" in part.text: + try: + return json.loads(part.text[part.text.index("{"):]) + except (ValueError, json.JSONDecodeError): + return {} + return {} + + +def _render_fake_summary(request) -> str: + """Deterministic summary rendered from the digest embedded in the request.""" + digest = _extract_digest(request) + + finding_count = digest.get("finding_count", 0) + review_count = digest.get("needs_human_review_count", 0) + severities = digest.get("severity_distribution", {}) + top = digest.get("top_findings", []) + + if finding_count == 0 and review_count == 0: + return ("No issues detected by the review rules. The changeset looks clean; " + "standard human review is still recommended for logic-level concerns.") + ordered = [f"{name}={count}" for name, count in severities.items() if count] + lines = [ + f"Automated review found {finding_count} finding(s) " + f"({', '.join(ordered) if ordered else 'no severity data'}) " + f"and {review_count} item(s) needing human review.", + ] + for item in top[:3]: + lines.append(f"- [{item.get('severity')}] {item.get('file')}:{item.get('line')} — " + f"{item.get('title')}") + if any(sev in severities and severities[sev] for sev in ("critical", "high")): + lines.append("Fix the critical/high items before merging; see per-finding " + "recommendations in the report.") + return "\n".join(lines) + + +class FakeReviewModel(LLMModel): + """Deterministic offline model — makes dry-run work without any API key.""" + + @classmethod + def supported_models(cls) -> List[str]: + return [r"fake-review-.*"] + + async def _generate_async_impl(self, request, stream=False, ctx=None): + yield LlmResponse(content=Content(role="model", parts=[Part.from_text(text=_render_fake_summary(request))])) + + def validate_request(self, request) -> None: + pass + + +def build_summary_model(model_mode: str, model_name: str) -> Optional[LLMModel]: + if model_mode == "off": + return None + if model_mode == "fake": + return FakeReviewModel(model_name=model_name) + if model_mode == "real": + return OpenAIModel( + model_name=os.getenv("TRPC_AGENT_MODEL_NAME", model_name), + api_key=os.getenv("TRPC_AGENT_API_KEY", ""), + base_url=os.getenv("TRPC_AGENT_BASE_URL", ""), + ) + raise ValueError(f"unknown model mode: {model_mode!r}") + + +async def summarize(digest: Dict, model_mode: str, model_name: str) -> str: + """Produce the report summary text; empty string when mode is ``off``.""" + model = build_summary_model(model_mode, model_name) + if model is None: + return "" + agent = LlmAgent( + name="code_review_summarizer", + model=model, + instruction=_SUMMARY_INSTRUCTION, + description="Summarizes structured code-review findings.", + ) + session_service = InMemorySessionService() + runner = Runner(app_name=_APP_NAME, agent=agent, session_service=session_service) + session_id = uuid.uuid4().hex + await session_service.create_session(app_name=_APP_NAME, user_id="review-pipeline", + session_id=session_id) + message = Content(role="user", + parts=[Part.from_text(text="Findings digest:\n" + json.dumps(digest, ensure_ascii=False))]) + chunks: List[str] = [] + async for event in runner.run_async(user_id="review-pipeline", session_id=session_id, + new_message=message): + if event.content and event.content.parts and not event.partial: + for part in event.content.parts: + if part.text and not part.thought: + chunks.append(part.text) + return "\n".join(chunks).strip() diff --git a/examples/skills_code_review_agent/codereview/metrics.py b/examples/skills_code_review_agent/codereview/metrics.py new file mode 100644 index 00000000..f39885a3 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/metrics.py @@ -0,0 +1,72 @@ +# 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. +"""Per-review monitoring metrics (issue requirement 9). + +Numbers live in a plain dataclass persisted to ``cr_report.metrics`` so they +are DB-queryable; pipeline phases are additionally wrapped in +``trpc_agent_sdk.telemetry.tracer`` spans for OTel-based observability. +""" + +from __future__ import annotations + +import time +from contextlib import contextmanager +from dataclasses import dataclass +from dataclasses import field +from typing import Dict + + +@dataclass +class ReviewMetrics: + """Everything the issue asks to monitor, in one queryable object.""" + + total_duration_ms: float = 0.0 + sandbox_duration_ms: float = 0.0 + sandbox_run_count: int = 0 + tool_call_count: int = 0 + llm_call_count: int = 0 + filter_block_count: int = 0 + filter_decisions: Dict[str, int] = field( + default_factory=lambda: {"allow": 0, "deny": 0, "needs_human_review": 0}) + finding_count: int = 0 + needs_human_review_count: int = 0 + deduplicated_count: int = 0 + redaction_count: int = 0 + severity_distribution: Dict[str, int] = field(default_factory=dict) + error_types: Dict[str, int] = field(default_factory=dict) + + def record_filter_decision(self, action: str) -> None: + self.filter_decisions[action] = self.filter_decisions.get(action, 0) + 1 + if action in ("deny", "needs_human_review"): + self.filter_block_count += 1 + + def record_error(self, error_type: str) -> None: + if error_type: + self.error_types[error_type] = self.error_types.get(error_type, 0) + 1 + + def to_dict(self) -> dict: + return { + "total_duration_ms": round(self.total_duration_ms, 2), + "sandbox_duration_ms": round(self.sandbox_duration_ms, 2), + "sandbox_run_count": self.sandbox_run_count, + "tool_call_count": self.tool_call_count, + "llm_call_count": self.llm_call_count, + "filter_block_count": self.filter_block_count, + "filter_decisions": dict(self.filter_decisions), + "finding_count": self.finding_count, + "needs_human_review_count": self.needs_human_review_count, + "deduplicated_count": self.deduplicated_count, + "redaction_count": self.redaction_count, + "severity_distribution": dict(self.severity_distribution), + "error_types": dict(self.error_types), + } + + +@contextmanager +def phase_timer(): + """``with phase_timer() as elapsed: ...; ms = elapsed()`` helper.""" + start = time.perf_counter() + yield lambda: (time.perf_counter() - start) * 1000.0 diff --git a/examples/skills_code_review_agent/codereview/pipeline.py b/examples/skills_code_review_agent/codereview/pipeline.py new file mode 100644 index 00000000..00ec0291 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/pipeline.py @@ -0,0 +1,357 @@ +# 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. +"""ReviewPipeline: the end-to-end orchestration of one review task. + +Flow (each phase in a telemetry tracer span): + 1. persist task (status=running) + host-side diff parse → diff summary + 2. governance gate (Filter) → sandbox check run (or block, recorded) + 3. sandbox failure → host-fallback rule run (failure recorded, task survives) + 4. findings post-processing: dedup → noise split → secret redaction + 5. optional LLM summary (fake/real/off) + 6. persist findings / filter events / report; render json + md reports +""" + +from __future__ import annotations + +import time +import uuid +from dataclasses import dataclass +from dataclasses import field +from typing import Any +from typing import Dict +from typing import List +from typing import Optional + +from trpc_agent_sdk.telemetry import tracer + +from .config import ReviewConfig +from .diff_parser import build_diff_summary +from .diff_parser import parse_unified_diff +from .diff_parser import run_all_rules +from .findings import BUCKET_FINDING +from .findings import BUCKET_NEEDS_HUMAN_REVIEW +from .findings import Finding +from .findings import dedup_findings +from .findings import severity_distribution +from .findings import split_noise +from .governance import ACTION_ALLOW +from .governance import PolicyDecision +from .governance import SandboxGovernanceFilter +from .governance import SandboxRunRequest +from .governance import gated_sandbox_run +from .inputs import RawChangeSet +from .llm_summary import summarize +from .metrics import ReviewMetrics +from .redaction import SecretRedactor +from .report import build_report +from .report import write_reports +from .sandbox import STATUS_BLOCKED +from .sandbox import STATUS_OK +from .sandbox import SandboxExecutor +from .sandbox import SandboxRunOutcome +from .sandbox import create_sandbox_runtime +from .store import ReviewStore + +STATUS_COMPLETED = "completed" +STATUS_COMPLETED_WITH_ERRORS = "completed_with_errors" +STATUS_FAILED = "failed" + + +@dataclass +class ReviewResult: + """What the CLI gets back from one pipeline run.""" + + task_id: str + status: str + report: Dict[str, Any] + report_paths: Dict[str, str] + metrics: ReviewMetrics + findings: List[Finding] = field(default_factory=list) + needs_human_review: List[Finding] = field(default_factory=list) + + +class ReviewPipeline: + """Orchestrates skill rules, governed sandbox runs, storage and reporting.""" + + def __init__(self, store: ReviewStore, config: ReviewConfig) -> None: + self._store = store + self._config = config + + async def run(self, changeset: RawChangeSet) -> ReviewResult: + task_id = uuid.uuid4().hex + metrics = ReviewMetrics() + redactor = SecretRedactor() + filter_events: List[Dict[str, Any]] = [] + sandbox_rows: List[Dict[str, Any]] = [] + start = time.perf_counter() + status = STATUS_COMPLETED + + with tracer.start_as_current_span("code_review.total"): + await self._store.create_task( + task_id=task_id, + input_type=changeset.input_type, + input_ref=redactor.redact_str(changeset.input_ref), + config=self._config.to_dict(), + ) + await self._store.update_task(task_id, status="running") + + try: + # Phase 1: host-side diff parsing (tool call #1). + with tracer.start_as_current_span("code_review.parse"): + parsed = parse_unified_diff(changeset.unified_diff_text) + diff_summary = build_diff_summary(parsed) + metrics.tool_call_count += 1 + await self._store.update_task(task_id, diff_summary=diff_summary) + + # Phase 2+3: governed sandbox execution with host fallback. + raw_findings, sandbox_status = await self._run_checks_governed( + task_id, parsed, changeset, metrics, redactor, filter_events, sandbox_rows) + if sandbox_status != STATUS_OK: + status = STATUS_COMPLETED_WITH_ERRORS + + # Phase 4: dedup → noise split → redaction. + findings, needs_review = self._postprocess_findings(raw_findings, metrics, redactor) + + # Phase 5: optional LLM summary. + summary = await self._summarize(findings, needs_review, metrics, redactor) + + metrics.total_duration_ms = (time.perf_counter() - start) * 1000.0 + + # Phase 6: persist + render. + report = build_report( + task_id=task_id, + input_type=changeset.input_type, + input_ref=redactor.redact_str(changeset.input_ref), + status=status, + summary=summary, + findings=findings, + needs_human_review=needs_review, + # Public view: internal bookkeeping keys (e.g. _persisted) + # must not leak into the report document. + filter_events=[{key: value for key, value in event.items() + if not key.startswith("_")} + for event in filter_events], + sandbox_runs=[self._public_run_view(row) for row in sandbox_rows], + metrics=metrics, + diff_summary=diff_summary, + ) + # Defense in depth: scrub the whole document once more. + report = redactor.redact_obj(report) + await self._persist_results(task_id, report, findings, needs_review, metrics) + report_paths = write_reports(report, self._config.out_dir) + await self._store.update_task(task_id, status=status) + return ReviewResult(task_id=task_id, status=status, report=report, + report_paths=report_paths, metrics=metrics, + findings=findings, needs_human_review=needs_review) + except Exception as ex: + metrics.record_error(type(ex).__name__) + await self._store.update_task( + task_id, status=STATUS_FAILED, error_type=type(ex).__name__, + error_message=redactor.redact_str(str(ex))[:2000]) + raise + + # -- phase helpers ------------------------------------------------------- + + async def _run_checks_governed(self, task_id: str, parsed: Dict[str, Any], + changeset: RawChangeSet, metrics: ReviewMetrics, + redactor: SecretRedactor, + filter_events: List[Dict[str, Any]], + sandbox_rows: List[Dict[str, Any]]) -> tuple: + """Governance gate → sandbox run → host fallback. Returns (findings, status).""" + cfg = self._config + runtime = create_sandbox_runtime(cfg.sandbox) + executor = SandboxExecutor(runtime, cfg.sandbox) + + def on_decision(req: SandboxRunRequest, decision: PolicyDecision) -> None: + metrics.record_filter_decision(decision.action) + filter_events.append({ + "stage": "sandbox_gate", + "target": req.args[0] if req.args else req.cmd, + "action": decision.action, + "rule": decision.rule, + "reasons": list(decision.reasons), + }) + + governance = SandboxGovernanceFilter(cfg.policy, on_decision=on_decision) + # The gate must see the exact command + full argv the sandbox will run. + request = SandboxRunRequest( + kind="static_checks", + cmd=executor.check_cmd, + args=executor.build_check_args(changeset.file_contents), + script_host_path=executor.check_script_host_path, + wants_network=False, + est_timeout=cfg.sandbox.timeout_sec, + run_index=metrics.sandbox_run_count, + total_sandbox_seconds=metrics.sandbox_duration_ms / 1000.0, + ) + + sandbox_started = time.perf_counter() + with tracer.start_as_current_span("code_review.sandbox"): + outcome = await gated_sandbox_run( + request, governance, + handler=lambda: executor.run_checks(task_id, parsed, changeset.file_contents)) + sandbox_ms = (time.perf_counter() - sandbox_started) * 1000.0 + + if isinstance(outcome, PolicyDecision): + # Blocked before execution: record, then fall back to host rules + # so the review itself still completes (the block is visible in + # the report and the DB). + row = self._make_run_row(task_id, metrics, request, None, STATUS_BLOCKED, + filter_action=outcome.action, filter_reasons=outcome.reasons) + sandbox_rows.append(row) + await self._store.add_sandbox_run(dict(row)) + await self._add_filter_events(task_id, filter_events) + findings = self._host_fallback_rules(parsed, changeset, metrics) + return findings, STATUS_BLOCKED + + metrics.sandbox_run_count += 1 + metrics.tool_call_count += 1 + metrics.sandbox_duration_ms += outcome.duration_ms or sandbox_ms + if outcome.error_type: + metrics.record_error(outcome.error_type) + + row = self._make_run_row(task_id, metrics, request, outcome, outcome.status, + filter_action=ACTION_ALLOW, filter_reasons=[], + redactor=redactor) + sandbox_rows.append(row) + await self._store.add_sandbox_run(dict(row)) + await self._add_filter_events(task_id, filter_events) + + if outcome.status == STATUS_OK and outcome.findings_payload is not None: + raw = outcome.findings_payload.get("findings", []) + return [Finding.from_dict(item) for item in raw], STATUS_OK + + # Sandbox timeout/failure/error: the review must not crash — rerun the + # same stdlib rule engine in-process (source stays static_rule; the + # sandbox_run row keeps the failure evidence). + findings = self._host_fallback_rules(parsed, changeset, metrics) + return findings, outcome.status + + def _host_fallback_rules(self, parsed: Dict[str, Any], changeset: RawChangeSet, + metrics: ReviewMetrics) -> List[Finding]: + metrics.tool_call_count += 1 + raw = run_all_rules(parsed, changeset.file_contents) + return [Finding.from_dict(item) for item in raw] + + def _make_run_row(self, task_id: str, metrics: ReviewMetrics, request: SandboxRunRequest, + outcome: Optional[SandboxRunOutcome], run_status: str, + filter_action: str, filter_reasons: List[str], + redactor: Optional[SecretRedactor] = None) -> Dict[str, Any]: + row: Dict[str, Any] = { + "task_id": task_id, + "run_index": max(0, metrics.sandbox_run_count - (1 if outcome else 0)), + "kind": request.kind, + "runtime_kind": self._config.sandbox.runtime_kind, + "cmd": request.cmd, + "args": list((outcome.args if outcome else None) or request.args), + "duration_ms": outcome.duration_ms if outcome else 0.0, + "exit_code": outcome.result.exit_code if outcome and outcome.result else None, + "timed_out": bool(outcome.result.timed_out) if outcome and outcome.result else False, + "status": run_status, + "filter_action": filter_action, + "filter_reasons": list(filter_reasons), + "stdout_excerpt": "", + "stderr_excerpt": "", + "output_truncated": bool(outcome.output_truncated) if outcome else False, + "error_type": outcome.error_type if outcome else "", + } + if outcome and redactor: + row["stdout_excerpt"] = redactor.redact_str(outcome.stdout[:4000]) + row["stderr_excerpt"] = redactor.redact_str(outcome.stderr[:4000]) + return row + + async def _add_filter_events(self, task_id: str, filter_events: List[Dict[str, Any]]) -> None: + for event in filter_events: + if event.get("_persisted"): + continue + await self._store.add_filter_event({key: value for key, value in event.items() + if not key.startswith("_")} | {"task_id": task_id}) + event["_persisted"] = True + + def _postprocess_findings(self, raw_findings: List[Finding], metrics: ReviewMetrics, + redactor: SecretRedactor) -> tuple: + with tracer.start_as_current_span("code_review.postprocess"): + deduped, removed = dedup_findings(raw_findings) + metrics.deduplicated_count = removed + findings, needs_review = split_noise(deduped, self._config.noise.min_confidence) + for finding in findings + needs_review: + finding.evidence = redactor.redact_str(finding.evidence) + finding.title = redactor.redact_str(finding.title) + finding.recommendation = redactor.redact_str(finding.recommendation) + metrics.finding_count = len(findings) + metrics.needs_human_review_count = len(needs_review) + metrics.severity_distribution = severity_distribution(findings) + metrics.redaction_count = redactor.redaction_count + return findings, needs_review + + async def _summarize(self, findings: List[Finding], needs_review: List[Finding], + metrics: ReviewMetrics, redactor: SecretRedactor) -> str: + if self._config.model_mode == "off": + return "" + digest = { + "finding_count": len(findings), + "needs_human_review_count": len(needs_review), + "severity_distribution": severity_distribution(findings), + "top_findings": [{ + "severity": finding.severity, + "file": finding.file, + "line": finding.line, + "title": finding.title, + } for finding in sorted(findings, key=lambda f: -f.severity_rank)[:5]], + } + try: + with tracer.start_as_current_span("code_review.llm"): + summary = await summarize(digest, self._config.model_mode, self._config.model_name) + metrics.llm_call_count += 1 + metrics.tool_call_count += 1 + return redactor.redact_str(summary) + except Exception as ex: # pylint: disable=broad-except + # Summary is auxiliary — its failure must not sink the review. + metrics.record_error(type(ex).__name__) + return f"(summary unavailable: {type(ex).__name__})" + + async def _persist_results(self, task_id: str, report: Dict[str, Any], + findings: List[Finding], needs_review: List[Finding], + metrics: ReviewMetrics) -> None: + rows: List[Dict[str, Any]] = [] + for bucket, items in ((BUCKET_FINDING, findings), (BUCKET_NEEDS_HUMAN_REVIEW, needs_review)): + for finding in items: + rows.append({ + "severity": finding.severity, + "category": finding.category, + "file": finding.file, + "line": finding.line, + "title": finding.title, + "evidence": finding.evidence, + "recommendation": finding.recommendation, + "confidence": finding.confidence, + "source": finding.source, + "rule_id": finding.rule_id, + "bucket": bucket, + "dedup_key": f"{finding.file}:{finding.line}:{finding.category}", + }) + await self._store.add_findings(task_id, rows) + await self._store.save_report(task_id, { + "summary": report.get("summary", ""), + "findings_total": len(findings), + "severity_stats": report.get("severity_stats"), + "filter_summary": report.get("filter_summary"), + "sandbox_summary": { + "total_runs": report.get("sandbox_summary", {}).get("total_runs", 0), + "statuses": [run.get("status") for run in + report.get("sandbox_summary", {}).get("runs", [])], + }, + "metrics": metrics.to_dict(), + "report": report, + }) + + @staticmethod + def _public_run_view(row: Dict[str, Any]) -> Dict[str, Any]: + """Sandbox-run fields exposed in the report document.""" + keys = ("run_index", "kind", "runtime_kind", "cmd", "status", "filter_action", + "filter_reasons", "exit_code", "timed_out", "duration_ms", + "output_truncated", "error_type") + return {key: row.get(key) for key in keys} diff --git a/examples/skills_code_review_agent/codereview/redaction.py b/examples/skills_code_review_agent/codereview/redaction.py new file mode 100644 index 00000000..2c1deee5 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/redaction.py @@ -0,0 +1,54 @@ +# 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. +"""Host-side secret redaction. + +Wraps the canonical pattern table shared with the sandbox rule +(``skills/code-review/scripts/lib/secret_patterns.py``, loaded through +:mod:`codereview.diff_parser`). Every string is scrubbed through this +redactor BEFORE it is persisted to the database or rendered into a report +— defense in depth on top of the in-sandbox evidence redaction. +""" + +from __future__ import annotations + +from typing import Any +from typing import Tuple + +from .diff_parser import secret_patterns + +REDACTED_PLACEHOLDER = secret_patterns.REDACTED_PLACEHOLDER + + +class SecretRedactor: + """Detect and scrub secrets; counts every redacted span.""" + + def __init__(self) -> None: + self.redaction_count = 0 + + def redact(self, text: str) -> Tuple[str, int]: + """Return (redacted_text, span_count) and accumulate the counter.""" + if not text: + return text, 0 + redacted, count = secret_patterns.redact_text(text, REDACTED_PLACEHOLDER) + self.redaction_count += count + return redacted, count + + def redact_str(self, text: str) -> str: + return self.redact(text)[0] + + def contains_secret(self, text: str) -> bool: + return secret_patterns.contains_secret(text or "") + + def redact_obj(self, obj: Any) -> Any: + """Recursively redact every string inside dicts / lists / tuples.""" + if isinstance(obj, str): + return self.redact_str(obj) + if isinstance(obj, dict): + return {key: self.redact_obj(value) for key, value in obj.items()} + if isinstance(obj, (list, tuple)): + redacted = [self.redact_obj(item) for item in obj] + return redacted if isinstance(obj, list) else tuple(redacted) + return obj diff --git a/examples/skills_code_review_agent/codereview/report.py b/examples/skills_code_review_agent/codereview/report.py new file mode 100644 index 00000000..5db635fa --- /dev/null +++ b/examples/skills_code_review_agent/codereview/report.py @@ -0,0 +1,207 @@ +# 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. +"""Report assembly and rendering (review_report.json + review_report.md). + +The markdown report carries every section acceptance criterion 8 demands: +findings 摘要 / 严重级别统计 / 人工复核项 / Filter 拦截摘要 / 监控指标 / +沙箱执行摘要 / 可执行修复建议. +""" + +from __future__ import annotations + +import json +import os +from datetime import datetime +from datetime import timezone +from typing import Any +from typing import Dict +from typing import List + +from .findings import Finding +from .findings import severity_distribution +from .metrics import ReviewMetrics + +_SEVERITY_ORDER = ("critical", "high", "medium", "low", "info") + + +def build_report(task_id: str, + input_type: str, + input_ref: str, + status: str, + summary: str, + findings: List[Finding], + needs_human_review: List[Finding], + filter_events: List[Dict[str, Any]], + sandbox_runs: List[Dict[str, Any]], + metrics: ReviewMetrics, + diff_summary: Dict[str, Any]) -> Dict[str, Any]: + """Assemble the full report document (also persisted to cr_report.report).""" + blocked_events = [event for event in filter_events if event.get("action") != "allow"] + recommendations = [{ + "file": finding.file, + "line": finding.line, + "severity": finding.severity, + "title": finding.title, + "recommendation": finding.recommendation, + } for finding in sorted(findings, key=lambda f: -f.severity_rank)] + + return { + "task_id": task_id, + "created_at": datetime.now(timezone.utc).isoformat(), + "input": {"type": input_type, "ref": input_ref, "diff_summary": diff_summary}, + "status": status, + "summary": summary, + "findings": [finding.to_dict() for finding in findings], + "needs_human_review": [finding.to_dict() for finding in needs_human_review], + "severity_stats": severity_distribution(findings), + "filter_summary": { + "total_decisions": len(filter_events), + "blocked": len(blocked_events), + "events": filter_events, + }, + "sandbox_summary": { + "total_runs": len(sandbox_runs), + "runs": sandbox_runs, + }, + "metrics": metrics.to_dict(), + "recommendations": recommendations, + } + + +def _md_escape(text: str) -> str: + return (text or "").replace("|", "\\|").replace("\n", " ") + + +def _findings_table(items: List[Dict[str, Any]]) -> List[str]: + if not items: + return ["(none 无)"] + lines = [ + "| Severity | Category | File:Line | Title | Confidence | Source |", + "|---|---|---|---|---|---|", + ] + for item in items: + lines.append(f"| {item['severity']} | {item['category']} " + f"| `{_md_escape(item['file'])}:{item['line']}` " + f"| {_md_escape(item['title'])} | {item['confidence']:.2f} " + f"| {item['source']} |") + return lines + + +def render_markdown(report: Dict[str, Any]) -> str: + """Render the bilingual markdown report.""" + lines: List[str] = [] + lines.append("# Code Review Report 代码评审报告") + lines.append("") + lines.append(f"- Task ID: `{report['task_id']}`") + lines.append(f"- Status 状态: **{report['status']}**") + lines.append(f"- Created 生成时间: {report['created_at']}") + input_info = report.get("input", {}) + lines.append(f"- Input 输入: {input_info.get('type')} — `{_md_escape(str(input_info.get('ref')))}`") + diff_summary = input_info.get("diff_summary") or {} + if diff_summary: + lines.append(f"- Diff: {diff_summary.get('file_count', 0)} file(s), " + f"{diff_summary.get('hunk_count', 0)} hunk(s), " + f"+{diff_summary.get('added_line_count', 0)} " + f"/ -{diff_summary.get('removed_line_count', 0)}") + lines.append("") + + lines.append("## Findings 摘要") + lines.append("") + if report.get("summary"): + lines.append(report["summary"]) + lines.append("") + lines.extend(_findings_table(report.get("findings", []))) + lines.append("") + for item in report.get("findings", []): + lines.append(f"### [{item['severity'].upper()}] {item['title']} — " + f"`{item['file']}:{item['line']}`") + lines.append("") + lines.append(f"- Rule 规则: `{item.get('rule_id', '')}` (category: {item['category']}, " + f"confidence: {item['confidence']:.2f}, source: {item['source']})") + lines.append(f"- Evidence 证据: `{_md_escape(item['evidence'])}`") + lines.append(f"- Recommendation 修复建议: {item['recommendation']}") + lines.append("") + + lines.append("## 严重级别统计 Severity Stats") + lines.append("") + stats = report.get("severity_stats", {}) + lines.append("| Severity | Count |") + lines.append("|---|---|") + for severity in _SEVERITY_ORDER: + lines.append(f"| {severity} | {stats.get(severity, 0)} |") + lines.append("") + + lines.append("## 人工复核项 Needs Human Review") + lines.append("") + lines.append("低置信度结果不混入高置信 findings，由人工确认。 " + "Low-confidence results are kept out of the findings list for human triage.") + lines.append("") + lines.extend(_findings_table(report.get("needs_human_review", []))) + lines.append("") + + lines.append("## Filter 拦截摘要 Filter Blocks") + lines.append("") + filter_summary = report.get("filter_summary", {}) + lines.append(f"Decisions 决策总数: {filter_summary.get('total_decisions', 0)}; " + f"Blocked 拦截: {filter_summary.get('blocked', 0)}") + blocked = [event for event in filter_summary.get("events", []) if event.get("action") != "allow"] + if blocked: + lines.append("") + lines.append("| Stage | Target | Action | Rule | Reasons |") + lines.append("|---|---|---|---|---|") + for event in blocked: + reasons = "; ".join(event.get("reasons") or []) + lines.append(f"| {event.get('stage')} | `{_md_escape(str(event.get('target')))}` " + f"| **{event.get('action')}** | {event.get('rule')} " + f"| {_md_escape(reasons)} |") + lines.append("") + + lines.append("## 监控指标 Metrics") + lines.append("") + lines.append("```json") + lines.append(json.dumps(report.get("metrics", {}), indent=2, ensure_ascii=False)) + lines.append("```") + lines.append("") + + lines.append("## 沙箱执行摘要 Sandbox Runs") + lines.append("") + sandbox_summary = report.get("sandbox_summary", {}) + runs = sandbox_summary.get("runs", []) + if runs: + lines.append("| # | Kind | Runtime | Status | Exit | Timed out | Duration (ms) | Error |") + lines.append("|---|---|---|---|---|---|---|---|") + for run in runs: + lines.append(f"| {run.get('run_index', 0)} | {run.get('kind')} " + f"| {run.get('runtime_kind')} | {run.get('status')} " + f"| {run.get('exit_code', '')} | {run.get('timed_out', False)} " + f"| {run.get('duration_ms', 0):.0f} | {run.get('error_type', '')} |") + else: + lines.append("(no sandbox runs 无沙箱执行)") + lines.append("") + + lines.append("## 修复建议 Recommendations") + lines.append("") + recommendations = report.get("recommendations", []) + if recommendations: + for index, rec in enumerate(recommendations, 1): + lines.append(f"{index}. **[{rec['severity']}]** `{rec['file']}:{rec['line']}` — " + f"{rec['recommendation']}") + else: + lines.append("No actionable fixes required. 无需修复。") + lines.append("") + return "\n".join(lines) + + +def write_reports(report: Dict[str, Any], out_dir: str) -> Dict[str, str]: + """Write review_report.json and review_report.md; returns their paths.""" + os.makedirs(out_dir, exist_ok=True) + json_path = os.path.join(out_dir, "review_report.json") + md_path = os.path.join(out_dir, "review_report.md") + with open(json_path, "w", encoding="utf-8") as fh: + json.dump(report, fh, ensure_ascii=False, indent=2) + with open(md_path, "w", encoding="utf-8") as fh: + fh.write(render_markdown(report)) + return {"json": json_path, "markdown": md_path} diff --git a/examples/skills_code_review_agent/codereview/sandbox.py b/examples/skills_code_review_agent/codereview/sandbox.py new file mode 100644 index 00000000..4f7c0bff --- /dev/null +++ b/examples/skills_code_review_agent/codereview/sandbox.py @@ -0,0 +1,263 @@ +# 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. +"""Sandbox execution on top of trpc_agent_sdk.code_executors. + +Runtime selection (issue requirement 2): + * ``container`` — Docker-based ContainerWorkspaceRuntime; the PRODUCTION + default documented in the README (native filesystem/network isolation). + * ``cube`` — Cube/E2B cloud sandbox (imported lazily; needs an E2B key). + * ``local`` — development fallback ONLY (used by tests / dry-run on + hosts without Docker), hardened with an environment whitelist because the + stock LocalProgramRunner inherits the full host environment. + +Safety guarantees (issue requirement 7): per-run timeout, stdout/stderr size +cap, env whitelist, secret-redacted excerpts, and a ``SandboxRunOutcome`` that +records failures — :meth:`SandboxExecutor.run_checks` NEVER raises, so a +sandbox crash cannot kill the review task (acceptance criterion 4). +""" + +from __future__ import annotations + +import json +import os +import sys +import uuid +from dataclasses import dataclass +from dataclasses import field +from typing import Dict +from typing import List +from typing import Optional + +from trpc_agent_sdk.code_executors import BaseWorkspaceRuntime +from trpc_agent_sdk.code_executors import WorkspacePutFileInfo +from trpc_agent_sdk.code_executors import WorkspaceRunProgramSpec +from trpc_agent_sdk.code_executors import WorkspaceRunResult +from trpc_agent_sdk.code_executors import WorkspaceStageOptions +from trpc_agent_sdk.code_executors.local import LocalProgramRunner +from trpc_agent_sdk.code_executors.local import LocalWorkspaceRuntime + +from .config import SandboxConfig +from .config import SKILL_NAME +from .config import SKILLS_ROOT + +STATUS_OK = "ok" +STATUS_FAILED = "failed" +STATUS_TIMEOUT = "timeout" +STATUS_ERROR = "error" +STATUS_BLOCKED = "blocked" + +#: Workspace-layout env vars the SDK runner injects; always kept. +_WORKSPACE_ENV_KEYS = frozenset({ + "WORKSPACE_DIR", "SKILLS_DIR", "WORK_DIR", "OUTPUT_DIR", "RUN_DIR", "SKILL_NAME", +}) + +_SKILL_REL_DIR = f"skills/{SKILL_NAME}" +_DIFF_JSON_REL = "work/inputs/diff.json" +_FILES_REL_DIR = "work/inputs/files" +_FINDINGS_REL = "out/findings.json" + + +class EnvWhitelistLocalProgramRunner(LocalProgramRunner): + """LocalProgramRunner that drops every non-whitelisted host env var. + + The stock local runner builds the child environment from + ``os.environ.copy()`` — fine for trusted skills, but a review sandbox must + not leak host secrets (API keys, tokens) into analyzed code. Container and + Cube runtimes isolate the environment natively; this subclass gives the + local dev-fallback the same property. + """ + + def __init__(self, allowed_env: frozenset, extra_env: Optional[Dict[str, str]] = None) -> None: + super().__init__() + self._allowed_env = frozenset(allowed_env) + self._extra_env = dict(extra_env or {}) + + def _build_program_env(self, ws, spec) -> Dict[str, str]: + env = super()._build_program_env(ws, spec) + keep = self._allowed_env | _WORKSPACE_ENV_KEYS | set((spec.env or {}).keys()) + filtered = {key: value for key, value in env.items() if key in keep} + filtered.update(self._extra_env) + return filtered + + +def create_sandbox_runtime(cfg: SandboxConfig) -> BaseWorkspaceRuntime: + """Instantiate the workspace runtime selected by ``cfg.runtime_kind``.""" + if cfg.runtime_kind == "local": + runtime = LocalWorkspaceRuntime(work_root=cfg.work_root) + # Swap in the hardened runner (see class docstring). + runtime._runner = EnvWhitelistLocalProgramRunner(cfg.env_whitelist) # pylint: disable=protected-access + return runtime + if cfg.runtime_kind == "container": + from trpc_agent_sdk.code_executors import ContainerConfig + from trpc_agent_sdk.code_executors import create_container_workspace_runtime + return create_container_workspace_runtime(container_config=ContainerConfig(image=cfg.container_image)) + if cfg.runtime_kind == "cube": + # Lazy import: the cube subpackage imports e2b_code_interpreter at module scope. + from trpc_agent_sdk.code_executors.cube import create_cube_workspace_runtime + return create_cube_workspace_runtime() + raise ValueError(f"unknown sandbox runtime kind: {cfg.runtime_kind!r}") + + +@dataclass +class SandboxRunOutcome: + """Result envelope of one sandbox run attempt.""" + + status: str # ok | failed | timeout | error + result: Optional[WorkspaceRunResult] = None + stdout: str = "" + stderr: str = "" + output_truncated: bool = False + findings_payload: Optional[dict] = None + error_type: str = "" + cmd: str = "" + args: list = field(default_factory=list) + duration_ms: float = 0.0 + + +def _cap_output(text: str, max_bytes: int) -> tuple: + """Truncate ``text`` to ``max_bytes`` (UTF-8), marking truncation.""" + if text is None: + return "", False + encoded = text.encode("utf-8", errors="replace") + if len(encoded) <= max_bytes: + return text, False + clipped = encoded[:max_bytes].decode("utf-8", errors="replace") + return clipped + "\n…[output truncated]", True + + +class SandboxExecutor: + """Stages the code-review skill into an isolated workspace and runs checks.""" + + def __init__(self, runtime: BaseWorkspaceRuntime, cfg: SandboxConfig, + skill_root: str = "") -> None: + self._runtime = runtime + self._cfg = cfg + self._skill_root = skill_root or os.path.join(SKILLS_ROOT, SKILL_NAME) + + @property + def check_script_host_path(self) -> str: + return os.path.join(self._skill_root, "scripts", "run_checks.py") + + @property + def check_cmd(self) -> str: + """Interpreter of the check run: the host interpreter for the local + runtime (``python3`` may not exist on e.g. Windows hosts), plain + ``python3`` inside container/cube runtimes.""" + if self._cfg.runtime_kind == "local": + return sys.executable or "python3" + return "python3" + + def build_check_args(self, file_contents: Optional[Dict[str, str]] = None) -> List[str]: + """Complete argv (after the interpreter) of the check run — exposed so + the governance gate inspects exactly what will execute.""" + args = [ + f"{_SKILL_REL_DIR}/scripts/run_checks.py", + _DIFF_JSON_REL, + _FINDINGS_REL, + ] + if file_contents: + args += ["--files-dir", _FILES_REL_DIR] + if self._cfg.force_fail: + args.append("--force-fail") + return args + + async def run_checks(self, task_id: str, changeset_json: dict, + file_contents: Optional[Dict[str, str]] = None) -> SandboxRunOutcome: + """Run the skill's ``run_checks.py`` over a parsed changeset. Never raises.""" + args = self.build_check_args(file_contents) + + exec_id = f"cr-{task_id[:8]}-{uuid.uuid4().hex[:8]}" + manager = self._runtime.manager() + fs = self._runtime.fs() + runner = self._runtime.runner() + outcome = SandboxRunOutcome(status=STATUS_ERROR, cmd=self.check_cmd, args=list(args)) + try: + ws = await manager.create_workspace(exec_id) + try: + # Stage the skill directory. The SDK's SkillStager requires a + # full InvocationContext (agent invocation); this deterministic + # pipeline stages the same tree directly via the workspace FS, + # which is exactly what the stager does internally. + await fs.stage_directory(ws, self._skill_root, _SKILL_REL_DIR, + WorkspaceStageOptions(mode="copy", read_only=True)) + put_files = [ + WorkspacePutFileInfo( + path=_DIFF_JSON_REL, + content=json.dumps({"changeset": changeset_json}).encode("utf-8"), + mode=0o644, + ) + ] + for rel_path, content in (file_contents or {}).items(): + safe_rel = rel_path.replace("\\", "/").lstrip("/") + if ".." in safe_rel.split("/"): + continue + put_files.append( + WorkspacePutFileInfo(path=f"{_FILES_REL_DIR}/{safe_rel}", + content=content.encode("utf-8"), mode=0o644)) + await fs.put_files(ws, put_files) + + spec = WorkspaceRunProgramSpec( + cmd=self.check_cmd, + args=args, + env={"SKILL_NAME": SKILL_NAME}, + cwd="", + timeout=self._cfg.timeout_sec, + ) + result = await runner.run_program(ws, spec) + outcome.result = result + outcome.duration_ms = (result.duration or 0.0) * 1000.0 + outcome.stdout, truncated_out = _cap_output(result.stdout, self._cfg.max_output_bytes) + outcome.stderr, truncated_err = _cap_output(result.stderr, self._cfg.max_output_bytes) + outcome.output_truncated = truncated_out or truncated_err + + if result.timed_out: + outcome.status = STATUS_TIMEOUT + outcome.error_type = "SandboxTimeout" + return outcome + if result.exit_code != 0: + outcome.status = STATUS_FAILED + outcome.error_type = "SandboxNonZeroExit" + return outcome + + payload = await self._collect_findings(fs, ws) + if payload is None: + outcome.status = STATUS_FAILED + outcome.error_type = "MissingFindingsOutput" + return outcome + outcome.findings_payload = payload + outcome.status = STATUS_OK + return outcome + finally: + try: + await manager.cleanup(exec_id) + except Exception: # pylint: disable=broad-except + pass # cleanup failure must not mask the run outcome + except Exception as ex: # pylint: disable=broad-except + # Contract: sandbox problems surface as data, never as exceptions. + outcome.status = STATUS_ERROR + outcome.error_type = type(ex).__name__ + outcome.stderr = (outcome.stderr + f"\n{type(ex).__name__}: {ex}").strip() + return outcome + + async def _collect_findings(self, fs, ws) -> Optional[dict]: + """Fetch out/findings.json from the workspace; host-read fallback when truncated.""" + try: + files = await fs.collect(ws, [_FINDINGS_REL]) + for code_file in files: + if code_file.truncated: + break + return json.loads(code_file.content) + except Exception: # pylint: disable=broad-except + pass + # Local-runtime fallback: read straight from the workspace dir. + host_path = os.path.join(ws.path, *_FINDINGS_REL.split("/")) + if os.path.isfile(host_path): + try: + with open(host_path, "r", encoding="utf-8") as fh: + return json.load(fh) + except (OSError, json.JSONDecodeError): + return None + return None diff --git a/examples/skills_code_review_agent/codereview/store/__init__.py b/examples/skills_code_review_agent/codereview/store/__init__.py new file mode 100644 index 00000000..4b7a6e8c --- /dev/null +++ b/examples/skills_code_review_agent/codereview/store/__init__.py @@ -0,0 +1,26 @@ +# 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: ORM models, backend-swappable store interface, SQL impl.""" + +from .base import ReviewStore +from .models import FilterEventRow +from .models import FindingRow +from .models import ReportRow +from .models import ReviewStorageBase +from .models import ReviewTaskRow +from .models import SandboxRunRow +from .sql_store import SqlReviewStore + +__all__ = [ + "ReviewStore", + "SqlReviewStore", + "ReviewStorageBase", + "ReviewTaskRow", + "SandboxRunRow", + "FilterEventRow", + "FindingRow", + "ReportRow", +] diff --git a/examples/skills_code_review_agent/codereview/store/base.py b/examples/skills_code_review_agent/codereview/store/base.py new file mode 100644 index 00000000..0c49ffe5 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/store/base.py @@ -0,0 +1,95 @@ +# 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. +"""Backend-swappable store interface (issue requirement 5). + +The pipeline talks ONLY to this ABC. :class:`SqlReviewStore` implements it on +the SDK's ``SqlStorage`` (SQLite by default; MySQL/PostgreSQL by URL swap). +A non-SQL backend (e.g. document store) just implements this same interface. +""" + +from __future__ import annotations + +from abc import ABC +from abc import abstractmethod +from typing import Any +from typing import Dict +from typing import List +from typing import Optional + + +class ReviewStore(ABC): + """Async persistence interface for review tasks and their artifacts.""" + + @abstractmethod + async def initialize(self) -> None: + """Create/migrate the schema (idempotent).""" + + @abstractmethod + async def close(self) -> None: + """Release connections.""" + + # -- writes ------------------------------------------------------------- + + @abstractmethod + async def create_task(self, task_id: str, input_type: str, input_ref: str, + config: Dict[str, Any]) -> None: + ... + + @abstractmethod + async def update_task(self, task_id: str, **fields: Any) -> None: + """Update mutable task fields (status, diff_summary, error_*).""" + + @abstractmethod + async def add_sandbox_run(self, run: Dict[str, Any]) -> None: + ... + + @abstractmethod + async def add_filter_event(self, event: Dict[str, Any]) -> None: + ... + + @abstractmethod + async def add_findings(self, task_id: str, findings: List[Dict[str, Any]]) -> None: + ... + + @abstractmethod + async def save_report(self, task_id: str, report_row: Dict[str, Any]) -> None: + ... + + # -- queries (acceptance criterion 3: everything by task id) ------------- + + @abstractmethod + async def get_task(self, task_id: str) -> Optional[Dict[str, Any]]: + ... + + @abstractmethod + async def get_sandbox_runs(self, task_id: str) -> List[Dict[str, Any]]: + ... + + @abstractmethod + async def get_filter_events(self, task_id: str) -> List[Dict[str, Any]]: + ... + + @abstractmethod + async def get_findings(self, task_id: str) -> List[Dict[str, Any]]: + ... + + @abstractmethod + async def get_report(self, task_id: str) -> Optional[Dict[str, Any]]: + ... + + @abstractmethod + async def list_tasks(self, limit: int = 20) -> List[Dict[str, Any]]: + ... + + async def get_task_bundle(self, task_id: str) -> Dict[str, Any]: + """Everything recorded for one task — powers ``run_agent.py show``.""" + return { + "task": await self.get_task(task_id), + "sandbox_runs": await self.get_sandbox_runs(task_id), + "filter_events": await self.get_filter_events(task_id), + "findings": await self.get_findings(task_id), + "report": await self.get_report(task_id), + } diff --git a/examples/skills_code_review_agent/codereview/store/init_db.py b/examples/skills_code_review_agent/codereview/store/init_db.py new file mode 100644 index 00000000..9c9929e7 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/store/init_db.py @@ -0,0 +1,50 @@ +# 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. +"""DB init / migration script. + +Usage:: + + python run_agent.py init-db [--db-url URL] + # or standalone: + python -m codereview.store.init_db --db-url sqlite+aiosqlite:///./review.db + +Idempotent: ``SqlStorage.create_sql_engine`` runs ``metadata.create_all`` and +the SDK's forward-only column migration, so re-running after a schema upgrade +adds any new columns without touching existing data. +""" + +from __future__ import annotations + +import argparse +import asyncio + +from .models import ReviewStorageBase +from .sql_store import SqlReviewStore + + +async def init_db(db_url: str) -> list: + store = SqlReviewStore(db_url) + try: + await store.initialize() + finally: + await store.close() + return sorted(ReviewStorageBase.metadata.tables) + + +def main(argv=None) -> int: + parser = argparse.ArgumentParser(description="Initialize / migrate the code-review database.") + parser.add_argument("--db-url", default="sqlite+aiosqlite:///./review.db", + help="SQLAlchemy async URL (default: %(default)s)") + args = parser.parse_args(argv) + tables = asyncio.run(init_db(args.db_url)) + print(f"database ready at {args.db_url}") + for table in tables: + print(f" - {table}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/examples/skills_code_review_agent/codereview/store/models.py b/examples/skills_code_review_agent/codereview/store/models.py new file mode 100644 index 00000000..ed28ebf8 --- /dev/null +++ b/examples/skills_code_review_agent/codereview/store/models.py @@ -0,0 +1,142 @@ +# 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. +"""ORM schema for the code-review store (issue requirement 5, acceptance 3). + +Five tables under an example-owned ``DeclarativeBase`` (own metadata, so +``SqlStorage.create_sql_engine`` only creates/migrates OUR tables): +``cr_review_task``, ``cr_sandbox_run``, ``cr_filter_event``, ``cr_finding``, +``cr_report``. Column types reuse the SDK's portable helpers +(``UTF8MB4String`` / ``DynamicJSON`` / ``PreciseTimestamp``) so the exact +same schema works on SQLite (default), MySQL and PostgreSQL — swapping the +backend is just a different SQLAlchemy URL. +""" + +from __future__ import annotations + +from datetime import datetime +from datetime import timezone +from typing import Any +from typing import Optional + +from sqlalchemy import Boolean +from sqlalchemy import Float +from sqlalchemy import Integer +from sqlalchemy import Text +from sqlalchemy.orm import DeclarativeBase +from sqlalchemy.orm import Mapped +from sqlalchemy.orm import mapped_column + +from trpc_agent_sdk.storage import DEFAULT_MAX_KEY_LENGTH +from trpc_agent_sdk.storage import DynamicJSON +from trpc_agent_sdk.storage import PreciseTimestamp +from trpc_agent_sdk.storage import UTF8MB4String + +_STATUS_LEN = 32 +_PATH_LEN = 512 + + +def utcnow() -> datetime: + return datetime.now(timezone.utc) + + +class ReviewStorageBase(DeclarativeBase): + """Dedicated metadata root — create_all touches only cr_* tables.""" + + +class ReviewTaskRow(ReviewStorageBase): + """One review task (status lifecycle: pending → running → completed*/failed).""" + + __tablename__ = "cr_review_task" + + id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), primary_key=True) + created_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow) + updated_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow, onupdate=utcnow) + status: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="pending") + input_type: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + input_ref: Mapped[str] = mapped_column(UTF8MB4String(_PATH_LEN), default="") + diff_summary: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + config: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + error_type: Mapped[str] = mapped_column(UTF8MB4String(128), default="") + error_message: Mapped[str] = mapped_column(Text(), default="") + + +class SandboxRunRow(ReviewStorageBase): + """One sandbox run attempt (including blocked and failed attempts).""" + + __tablename__ = "cr_sandbox_run" + + id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), primary_key=True) + task_id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), index=True) + run_index: Mapped[int] = mapped_column(Integer(), default=0) + kind: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + runtime_kind: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + cmd: Mapped[str] = mapped_column(UTF8MB4String(128), default="") + args: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + started_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow) + duration_ms: Mapped[float] = mapped_column(Float(), default=0.0) + exit_code: Mapped[Optional[int]] = mapped_column(Integer(), nullable=True) + timed_out: Mapped[bool] = mapped_column(Boolean(), default=False) + status: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + filter_action: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + filter_reasons: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + stdout_excerpt: Mapped[str] = mapped_column(Text(), default="") + stderr_excerpt: Mapped[str] = mapped_column(Text(), default="") + output_truncated: Mapped[bool] = mapped_column(Boolean(), default=False) + error_type: Mapped[str] = mapped_column(UTF8MB4String(128), default="") + + +class FilterEventRow(ReviewStorageBase): + """One governance decision (allow / deny / needs_human_review) with reasons.""" + + __tablename__ = "cr_filter_event" + + id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), primary_key=True) + task_id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), index=True) + stage: Mapped[str] = mapped_column(UTF8MB4String(64), default="") + target: Mapped[str] = mapped_column(UTF8MB4String(_PATH_LEN), default="") + action: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + rule: Mapped[str] = mapped_column(UTF8MB4String(64), default="") + reasons: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + created_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow) + + +class FindingRow(ReviewStorageBase): + """One structured finding (bucket separates findings from needs_human_review).""" + + __tablename__ = "cr_finding" + + id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), primary_key=True) + task_id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), index=True) + severity: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + category: Mapped[str] = mapped_column(UTF8MB4String(64), default="") + file: Mapped[str] = mapped_column(UTF8MB4String(_PATH_LEN), default="") + line: Mapped[int] = mapped_column(Integer(), default=0) + title: Mapped[str] = mapped_column(UTF8MB4String(_PATH_LEN), default="") + evidence: Mapped[str] = mapped_column(Text(), default="") # redacted before persist + recommendation: Mapped[str] = mapped_column(Text(), default="") + confidence: Mapped[float] = mapped_column(Float(), default=0.0) + source: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="") + rule_id: Mapped[str] = mapped_column(UTF8MB4String(64), default="") + bucket: Mapped[str] = mapped_column(UTF8MB4String(_STATUS_LEN), default="finding") + dedup_key: Mapped[str] = mapped_column(UTF8MB4String(_PATH_LEN), default="") + created_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow) + + +class ReportRow(ReviewStorageBase): + """Final report document + monitoring summary for one task.""" + + __tablename__ = "cr_report" + + id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), primary_key=True) + task_id: Mapped[str] = mapped_column(UTF8MB4String(DEFAULT_MAX_KEY_LENGTH), unique=True, index=True) + created_at: Mapped[datetime] = mapped_column(PreciseTimestamp(), default=utcnow) + summary: Mapped[str] = mapped_column(Text(), default="") + findings_total: Mapped[int] = mapped_column(Integer(), default=0) + severity_stats: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + filter_summary: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + sandbox_summary: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + metrics: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) + report: Mapped[Optional[Any]] = mapped_column(DynamicJSON(), nullable=True) diff --git a/examples/skills_code_review_agent/codereview/store/sql_store.py b/examples/skills_code_review_agent/codereview/store/sql_store.py new file mode 100644 index 00000000..79df48ea --- /dev/null +++ b/examples/skills_code_review_agent/codereview/store/sql_store.py @@ -0,0 +1,154 @@ +# 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. +"""SQL implementation of :class:`ReviewStore` on trpc_agent_sdk.storage.SqlStorage. + +Default URL: ``sqlite+aiosqlite:////review.db``. Because every column +uses the SDK's portable types, pointing ``db_url`` at +``mysql+aiomysql://...`` or ``postgresql+asyncpg://...`` is the entire +backend swap — no code change. +""" + +from __future__ import annotations + +import uuid +from typing import Any +from typing import Dict +from typing import List +from typing import Optional + +from sqlalchemy.inspection import inspect as sa_inspect + +from trpc_agent_sdk.storage import SqlCondition +from trpc_agent_sdk.storage import SqlKey +from trpc_agent_sdk.storage import SqlStorage + +from .base import ReviewStore +from .models import FilterEventRow +from .models import FindingRow +from .models import ReportRow +from .models import ReviewStorageBase +from .models import ReviewTaskRow +from .models import SandboxRunRow + + +def _row_to_dict(row: Any) -> Dict[str, Any]: + """ORM row → plain dict (datetime → isoformat).""" + data: Dict[str, Any] = {} + for column in sa_inspect(row).mapper.column_attrs: + value = getattr(row, column.key) + if hasattr(value, "isoformat"): + value = value.isoformat() + data[column.key] = value + return data + + +class SqlReviewStore(ReviewStore): + """ReviewStore backed by any SQLAlchemy async URL (SQLite default).""" + + def __init__(self, db_url: str) -> None: + self._db_url = db_url + self._storage = SqlStorage(is_async=True, db_url=db_url, metadata=ReviewStorageBase.metadata) + + @property + def db_url(self) -> str: + return self._db_url + + async def initialize(self) -> None: + # create_sql_engine runs metadata.create_all plus the SDK's + # forward-only column migration — this IS the init/migration script. + await self._storage.create_sql_engine() + + async def close(self) -> None: + await self._storage.close() + + # -- writes ------------------------------------------------------------- + + async def _add_and_commit(self, obj: Any) -> None: + async with self._storage.create_db_session() as session: + await self._storage.add(session, obj) + await self._storage.commit(session) + + async def create_task(self, task_id: str, input_type: str, input_ref: str, + config: Dict[str, Any]) -> None: + await self._add_and_commit( + ReviewTaskRow(id=task_id, status="pending", input_type=input_type, + input_ref=input_ref, config=config)) + + async def update_task(self, task_id: str, **fields: Any) -> None: + async with self._storage.create_db_session() as session: + row = await self._storage.get(session, SqlKey(key=(task_id,), storage_cls=ReviewTaskRow)) + if row is None: + raise KeyError(f"review task not found: {task_id}") + for key, value in fields.items(): + if not hasattr(row, key): + raise AttributeError(f"cr_review_task has no column {key!r}") + setattr(row, key, value) + await self._storage.commit(session) + + async def add_sandbox_run(self, run: Dict[str, Any]) -> None: + run.setdefault("id", uuid.uuid4().hex) + await self._add_and_commit(SandboxRunRow(**run)) + + async def add_filter_event(self, event: Dict[str, Any]) -> None: + event.setdefault("id", uuid.uuid4().hex) + await self._add_and_commit(FilterEventRow(**event)) + + async def add_findings(self, task_id: str, findings: List[Dict[str, Any]]) -> None: + if not findings: + return + async with self._storage.create_db_session() as session: + for finding in findings: + finding = dict(finding) + finding.setdefault("id", uuid.uuid4().hex) + finding["task_id"] = task_id + await self._storage.add(session, FindingRow(**finding)) + await self._storage.commit(session) + + async def save_report(self, task_id: str, report_row: Dict[str, Any]) -> None: + report_row = dict(report_row) + report_row.setdefault("id", uuid.uuid4().hex) + report_row["task_id"] = task_id + await self._add_and_commit(ReportRow(**report_row)) + + # -- queries ------------------------------------------------------------ + + async def _query_by_task(self, storage_cls: Any, task_id: str, + order_col: str = "created_at") -> List[Dict[str, Any]]: + async with self._storage.create_db_session() as session: + rows = await self._storage.query( + session, + SqlKey(key=(task_id,), storage_cls=storage_cls), + SqlCondition(filters=[storage_cls.task_id == task_id], + order_func=lambda: getattr(storage_cls, order_col).asc()), + ) + return [_row_to_dict(row) for row in rows] + + async def get_task(self, task_id: str) -> Optional[Dict[str, Any]]: + async with self._storage.create_db_session() as session: + row = await self._storage.get(session, SqlKey(key=(task_id,), storage_cls=ReviewTaskRow)) + return _row_to_dict(row) if row else None + + async def get_sandbox_runs(self, task_id: str) -> List[Dict[str, Any]]: + return await self._query_by_task(SandboxRunRow, task_id, order_col="started_at") + + async def get_filter_events(self, task_id: str) -> List[Dict[str, Any]]: + return await self._query_by_task(FilterEventRow, task_id) + + async def get_findings(self, task_id: str) -> List[Dict[str, Any]]: + return await self._query_by_task(FindingRow, task_id) + + async def get_report(self, task_id: str) -> Optional[Dict[str, Any]]: + rows = await self._query_by_task(ReportRow, task_id) + return rows[0] if rows else None + + async def list_tasks(self, limit: int = 20) -> List[Dict[str, Any]]: + async with self._storage.create_db_session() as session: + rows = await self._storage.query( + session, + SqlKey(key=(), storage_cls=ReviewTaskRow), + SqlCondition(order_func=lambda: ReviewTaskRow.created_at.desc(), limit=limit), + ) + return [_row_to_dict(row) for row in rows] diff --git a/examples/skills_code_review_agent/conftest.py b/examples/skills_code_review_agent/conftest.py new file mode 100644 index 00000000..12383573 --- /dev/null +++ b/examples/skills_code_review_agent/conftest.py @@ -0,0 +1,11 @@ +# 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. +"""Pytest bootstrap: make the example dir importable (``import codereview``).""" + +import os +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) diff --git a/examples/skills_code_review_agent/fixtures/async_resource_leak.diff b/examples/skills_code_review_agent/fixtures/async_resource_leak.diff new file mode 100644 index 00000000..0c901ed8 --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/async_resource_leak.diff @@ -0,0 +1,40 @@ +diff --git a/app/collector.py b/app/collector.py +new file mode 100644 +index 0000000..a1b2c3d +--- /dev/null ++++ b/app/collector.py +@@ -0,0 +1,22 @@ ++import asyncio ++import tempfile ++import time ++ ++ ++async def poll_device(device_id: str) -> str: ++ """Poll one device and cache its status to disk.""" ++ time.sleep(2.0) ++ status = f"device-{device_id}: ok" ++ cache = tempfile.NamedTemporaryFile(delete=False, suffix=".status") ++ cache.write(status.encode("utf-8")) ++ return status ++ ++ ++async def poll_all(device_ids): ++ results = [] ++ for device_id in device_ids: ++ log = open(f"/var/log/poll-{device_id}.log", "a") ++ log.write("polling\n") ++ results.append(await poll_device(device_id)) ++ return results +diff --git a/tests/test_collector.py b/tests/test_collector.py +new file mode 100644 +index 0000000..d4e5f6a +--- /dev/null ++++ b/tests/test_collector.py +@@ -0,0 +1,7 @@ ++import asyncio ++ ++from app.collector import poll_all ++ ++ ++def test_poll_all_empty(): ++ assert asyncio.run(poll_all([])) == [] diff --git a/examples/skills_code_review_agent/fixtures/clean.diff b/examples/skills_code_review_agent/fixtures/clean.diff new file mode 100644 index 00000000..e57e03bd --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/clean.diff @@ -0,0 +1,35 @@ +diff --git a/app/formatting.py b/app/formatting.py +index 3f1c2aa..9d2b110 100644 +--- a/app/formatting.py ++++ b/app/formatting.py +@@ -1,6 +1,14 @@ + """Small text formatting helpers.""" + + ++def truncate(text: str, limit: int = 80) -> str: ++ """Return ``text`` clipped to ``limit`` characters with an ellipsis.""" ++ if limit <= 1 or len(text) <= limit: ++ return text ++ return text[:limit - 1] + "…" ++ ++ + def titlecase(value: str) -> str: + """Capitalize each word of ``value``.""" + return " ".join(word.capitalize() for word in value.split()) +diff --git a/tests/test_formatting.py b/tests/test_formatting.py +index 77aa001..b8e4c02 100644 +--- a/tests/test_formatting.py ++++ b/tests/test_formatting.py +@@ -1,5 +1,12 @@ + from app.formatting import titlecase ++from app.formatting import truncate + + + def test_titlecase(): + assert titlecase("hello world") == "Hello World" ++ ++ ++def test_truncate(): ++ assert truncate("short", 80) == "short" ++ clipped = truncate("x" * 100, 10) ++ assert len(clipped) == 10 diff --git a/examples/skills_code_review_agent/fixtures/db_connection_lifecycle.diff b/examples/skills_code_review_agent/fixtures/db_connection_lifecycle.diff new file mode 100644 index 00000000..f5d97938 --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/db_connection_lifecycle.diff @@ -0,0 +1,34 @@ +diff --git a/app/billing.py b/app/billing.py +new file mode 100644 +index 0000000..0f1e2d3 +--- /dev/null ++++ b/app/billing.py +@@ -0,0 +1,17 @@ ++import sqlite3 ++ ++ ++def apply_charges(db_path: str, charges) -> int: ++ """Apply a batch of charges inside one transaction.""" ++ conn = sqlite3.connect(db_path) ++ cur = conn.cursor() ++ cur.execute("BEGIN") ++ applied = 0 ++ for account_id, amount in charges: ++ cur.execute( ++ "UPDATE accounts SET balance = balance - ? WHERE id = ?", ++ (amount, account_id), ++ ) ++ applied += 1 ++ return applied ++ +diff --git a/tests/test_billing.py b/tests/test_billing.py +new file mode 100644 +index 0000000..4c5d6e7 +--- /dev/null ++++ b/tests/test_billing.py +@@ -0,0 +1,5 @@ ++from app.billing import apply_charges ++ ++ ++def test_apply_charges_empty(tmp_db): ++ assert apply_charges(tmp_db, []) == 0 diff --git a/examples/skills_code_review_agent/fixtures/duplicate_finding.diff b/examples/skills_code_review_agent/fixtures/duplicate_finding.diff new file mode 100644 index 00000000..004eac2b --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/duplicate_finding.diff @@ -0,0 +1,26 @@ +diff --git a/app/deploy.py b/app/deploy.py +new file mode 100644 +index 0000000..9e8d7c6 +--- /dev/null ++++ b/app/deploy.py +@@ -0,0 +1,9 @@ ++import os ++ ++ ++def restart_service(service_name: str) -> None: ++ """Restart a service on the deployment host.""" ++ os.system("systemctl restart " + service_name) ++ ++ ++SERVICES = ("api", "worker", "scheduler") +diff --git a/tests/test_deploy.py b/tests/test_deploy.py +new file mode 100644 +index 0000000..1a2b3c4 +--- /dev/null ++++ b/tests/test_deploy.py +@@ -0,0 +1,5 @@ ++from app.deploy import SERVICES ++ ++ ++def test_services_tuple(): ++ assert "api" in SERVICES diff --git a/examples/skills_code_review_agent/fixtures/missing_tests.diff b/examples/skills_code_review_agent/fixtures/missing_tests.diff new file mode 100644 index 00000000..1fd8063e --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/missing_tests.diff @@ -0,0 +1,19 @@ +diff --git a/app/pricing.py b/app/pricing.py +index aa11bb2..cc33dd4 100644 +--- a/app/pricing.py ++++ b/app/pricing.py +@@ -12,6 +12,15 @@ TAX_RATE = 0.13 + BULK_THRESHOLD = 50 + + ++def bulk_discount(quantity: int) -> float: ++ """Discount rate for bulk orders (new tier structure).""" ++ if quantity >= BULK_THRESHOLD * 4: ++ return 0.15 ++ if quantity >= BULK_THRESHOLD: ++ return 0.08 ++ return 0.0 ++ ++ + def unit_price(sku: str) -> float: + return PRICE_TABLE.get(sku, 0.0) diff --git a/examples/skills_code_review_agent/fixtures/sandbox_failure.diff b/examples/skills_code_review_agent/fixtures/sandbox_failure.diff new file mode 100644 index 00000000..122e99e3 --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/sandbox_failure.diff @@ -0,0 +1,28 @@ +diff --git a/app/health.py b/app/health.py +new file mode 100644 +index 0000000..5f6a7b8 +--- /dev/null ++++ b/app/health.py +@@ -0,0 +1,10 @@ ++"""Liveness / readiness endpoints.""" ++ ++ ++def liveness() -> dict: ++ return {"status": "ok"} ++ ++ ++def readiness(dependencies) -> dict: ++ ready = all(dep.ping() for dep in dependencies) ++ return {"status": "ok" if ready else "degraded"} +diff --git a/tests/test_health.py b/tests/test_health.py +new file mode 100644 +index 0000000..8c9d0e1 +--- /dev/null ++++ b/tests/test_health.py +@@ -0,0 +1,6 @@ ++from app.health import liveness ++ ++ ++def test_liveness(): ++ assert liveness() == {"status": "ok"} ++ diff --git a/examples/skills_code_review_agent/fixtures/secret_redaction.diff b/examples/skills_code_review_agent/fixtures/secret_redaction.diff new file mode 100644 index 00000000..35b27dd8 --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/secret_redaction.diff @@ -0,0 +1,40 @@ +diff --git a/app/config.py b/app/config.py +new file mode 100644 +index 0000000..7a8b9c0 +--- /dev/null ++++ b/app/config.py +@@ -0,0 +1,34 @@ ++"""Service configuration (WARNING: seeded fake secrets for redaction tests).""" ++ ++AWS_ACCESS_KEY_ID = "AKIAIOSFODNN7EXAMPLE" ++AWS_SECRET_ACCESS_KEY = "wJalrXUtnFEMIK7MDENGbPxRfiCYEXAMPLEKEY99" ++GITHUB_TOKEN = "ghp_FAKE1234567890abcdefFAKE1234567890" ++GITHUB_OAUTH = "gho_FAKEabcdef1234567890FAKEabcdef12" ++SLACK_BOT_TOKEN = "xoxb-7777777-8888888-FAKEfakeFAKE" ++OPENAI_API_KEY = "sk-FAKEfakeFAKEfakeFAKEfakeFAKE1234" ++GOOGLE_API_KEY = "AIzaFAKEfake_FAKE1234567890abcdHIJK" ++SESSION_JWT = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJmYWtlLXVzZXIifQ.FAKEsignatureFAKEsig" ++AUTH_HEADER = "Bearer FAKEbearerTOKENfakeBEARER1234567890" ++DATABASE_URL = "postgres://svc_user:sup3rSecretDbPass@db.internal:5432/prod" ++ ++password = "hunter2butlonger99" ++passwd = "legacyPasswd12345" ++pwd = "shortPwdValue789" ++secret = "topSecretValue4242" ++token = "plainTokenValue31337" ++api_key = "plainApiKeyValue2026" ++apikey = "joinedApiKeyValue777" ++access_key = "accessKeyValue0001" ++secret_key = "secretKeyValue0002" ++auth_token = "authTokenValue0003" ++client_secret = "clientSecretValue0004" ++private_key = "privateKeyValue0005" ++db_password = "dbPasswordValue0006" ++credentials = "credentialsValue0007" ++ ++SIGNING_KEY_PEM = ( ++ "-----BEGIN RSA PRIVATE KEY-----" ++ "MIIFAKEKEYBODYnotARealKeyMIIFAKE" ++ "-----END RSA PRIVATE KEY-----" ++) ++TIMEOUT_SECONDS = 30 diff --git a/examples/skills_code_review_agent/fixtures/security_issue.diff b/examples/skills_code_review_agent/fixtures/security_issue.diff new file mode 100644 index 00000000..6534647f --- /dev/null +++ b/examples/skills_code_review_agent/fixtures/security_issue.diff @@ -0,0 +1,34 @@ +diff --git a/app/admin.py b/app/admin.py +index 12ab34c..56de78f 100644 +--- a/app/admin.py ++++ b/app/admin.py +@@ -8,6 +8,16 @@ import subprocess + from app.db import get_cursor + + ++def archive_user(username: str) -> None: ++ """Archive a user's home directory.""" ++ os.system("tar czf /backups/" + username + ".tgz /home/" + username) ++ ++ ++def find_user(cursor, name: str): ++ cursor.execute(f"SELECT id, role FROM users WHERE name = '{name}'") ++ return cursor.fetchone() ++ ++ + def list_users(cursor): + cursor.execute("SELECT id, name FROM users ORDER BY id") + return cursor.fetchall() +diff --git a/tests/test_admin.py b/tests/test_admin.py +index 90aa11b..77cc22d 100644 +--- a/tests/test_admin.py ++++ b/tests/test_admin.py +@@ -3,3 +3,8 @@ from app.admin import list_users + + def test_list_users(fake_cursor): + assert list_users(fake_cursor) == [] ++ ++ ++def test_find_user(fake_cursor): ++ fake_cursor.rows = [(1, "admin")] ++ assert find_user(fake_cursor, "alice") == (1, "admin") diff --git a/examples/skills_code_review_agent/run_agent.py b/examples/skills_code_review_agent/run_agent.py new file mode 100644 index 00000000..f953d40a --- /dev/null +++ b/examples/skills_code_review_agent/run_agent.py @@ -0,0 +1,216 @@ +# 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. +"""CLI entry of the automatic code-review agent example. + +Examples:: + + # Review a committed fixture, fully offline (fake model, local sandbox): + python run_agent.py review --fixture security_issue --dry-run + + # Review a diff file / a git working tree / a list of files: + python run_agent.py review --diff-file my.patch + python run_agent.py review --repo-path /path/to/repo + python run_agent.py review --files a.py b.py + + # Query the database afterwards: + python run_agent.py show --task-id + python run_agent.py list + python run_agent.py init-db +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import os +import subprocess +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from codereview import inputs as review_inputs # noqa: E402 +from codereview.config import ReviewConfig # noqa: E402 +from codereview.config import SandboxConfig # noqa: E402 +from codereview.config import default_db_url # noqa: E402 +from codereview.config import resolve_sandbox_kind # noqa: E402 +from codereview.pipeline import ReviewPipeline # noqa: E402 +from codereview.store import SqlReviewStore # noqa: E402 +from codereview.store.init_db import init_db # noqa: E402 + + +def _build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(prog="run_agent.py", + description="Automatic code-review agent " + "(Skills + sandbox + DB, trpc_agent_sdk).") + sub = parser.add_subparsers(dest="command", required=True) + + review = sub.add_parser("review", help="run one review task") + source = review.add_mutually_exclusive_group(required=True) + source.add_argument("--diff-file", help="unified diff / PR patch file") + source.add_argument("--repo-path", help="git repository working tree") + source.add_argument("--files", nargs="+", help="explicit file list (treated as additions)") + source.add_argument("--fixture", help="committed fixture name, e.g. security_issue") + review.add_argument("--out-dir", default="out", help="report output directory (default: out)") + review.add_argument("--db-url", default="", help="SQLAlchemy async URL " + "(default: sqlite under --out-dir)") + review.add_argument("--sandbox", default="auto", + choices=("auto", "local", "container", "cube"), + help="sandbox runtime; auto (default) picks container when " + "Docker is available and falls back to the local dev " + "runtime (with a warning) otherwise") + review.add_argument("--model-mode", default="fake", choices=("fake", "real", "off"), + help="LLM summary mode; fake needs no API key (default)") + review.add_argument("--dry-run", action="store_true", + help="force offline mode: fake model + local sandbox, no API key needed") + review.add_argument("--timeout", type=float, default=30.0, help="sandbox timeout seconds") + review.add_argument("--max-output-bytes", type=int, default=64_000, + help="sandbox stdout/stderr cap") + review.add_argument("--inject-sandbox-failure", action="store_true", + help="deterministically fail the sandbox check (resilience demo)") + + show = sub.add_parser("show", help="print everything recorded for one task id") + show.add_argument("--task-id", required=True) + show.add_argument("--db-url", default="") + show.add_argument("--out-dir", default="out", + help="directory of the default sqlite DB (default: out)") + + list_cmd = sub.add_parser("list", help="list recent review tasks") + list_cmd.add_argument("--db-url", default="") + list_cmd.add_argument("--limit", type=int, default=20) + list_cmd.add_argument("--out-dir", default="out", + help="directory of the default sqlite DB (default: out)") + + initdb = sub.add_parser("init-db", help="create / migrate the database schema") + initdb.add_argument("--db-url", default="") + initdb.add_argument("--out-dir", default="out", + help="directory of the default sqlite DB (default: out)") + return parser + + +def _resolve_db_url(args) -> str: + if getattr(args, "db_url", ""): + return args.db_url + # Every subcommand shares the same default DB location (out/review.db) so + # the documented review → show/list workflow works without --db-url. + base_dir = getattr(args, "out_dir", "") or "out" + # SQLite does not create missing parent directories itself. + os.makedirs(base_dir, exist_ok=True) + return default_db_url(base_dir) + + +def _resolve_changeset(args) -> review_inputs.RawChangeSet: + if args.diff_file: + return review_inputs.from_diff_file(args.diff_file) + if args.repo_path: + return review_inputs.from_repo_path(args.repo_path) + if args.files: + return review_inputs.from_file_list(args.files) + return review_inputs.from_fixture(args.fixture) + + +async def _cmd_review(args) -> int: + if args.dry_run: + args.model_mode = "fake" + args.sandbox = "local" + args.sandbox = resolve_sandbox_kind(args.sandbox) + + config = ReviewConfig( + db_url=_resolve_db_url(args), + out_dir=args.out_dir, + model_mode=args.model_mode, + sandbox=SandboxConfig( + runtime_kind=args.sandbox, + timeout_sec=args.timeout, + max_output_bytes=args.max_output_bytes, + force_fail=args.inject_sandbox_failure, + ), + ) + try: + changeset = _resolve_changeset(args) + except (FileNotFoundError, ValueError) as ex: + print(f"input error: {ex}", file=sys.stderr) + return 2 + except subprocess.CalledProcessError as ex: + detail = (ex.stderr or "").strip() + print(f"input error: git failed: {detail or ex}", file=sys.stderr) + return 2 + store = SqlReviewStore(config.db_url) + try: + await store.initialize() + result = await ReviewPipeline(store, config).run(changeset) + finally: + await store.close() + + metrics = result.metrics + print(f"task id : {result.task_id}") + print(f"status : {result.status}") + print(f"findings : {metrics.finding_count} " + f"(severity: {json.dumps(metrics.severity_distribution)})") + print(f"human review: {metrics.needs_human_review_count} " + f"deduplicated: {metrics.deduplicated_count} " + f"filter blocks: {metrics.filter_block_count}") + print(f"duration : {metrics.total_duration_ms:.0f} ms " + f"(sandbox {metrics.sandbox_duration_ms:.0f} ms, " + f"{metrics.sandbox_run_count} run(s))") + print(f"report json : {result.report_paths['json']}") + print(f"report md : {result.report_paths['markdown']}") + print(f"database : {config.db_url}") + return 0 + + +async def _cmd_show(args) -> int: + store = SqlReviewStore(_resolve_db_url(args)) + try: + await store.initialize() + bundle = await store.get_task_bundle(args.task_id) + finally: + await store.close() + if bundle["task"] is None: + print(f"task not found: {args.task_id}", file=sys.stderr) + return 1 + print(json.dumps(bundle, ensure_ascii=False, indent=2, default=str)) + return 0 + + +async def _cmd_list(args) -> int: + store = SqlReviewStore(_resolve_db_url(args)) + try: + await store.initialize() + tasks = await store.list_tasks(limit=args.limit) + finally: + await store.close() + if not tasks: + print("(no review tasks recorded)") + return 0 + for task in tasks: + print(f"{task['id']} {task['created_at']} {task['status']:<24} " + f"{task['input_type']}:{task['input_ref']}") + return 0 + + +async def _cmd_init_db(args) -> int: + db_url = _resolve_db_url(args) + tables = await init_db(db_url) + print(f"database ready at {db_url}") + for table in tables: + print(f" - {table}") + return 0 + + +def main(argv=None) -> int: + args = _build_parser().parse_args(argv) + handler = { + "review": _cmd_review, + "show": _cmd_show, + "list": _cmd_list, + "init-db": _cmd_init_db, + }[args.command] + return asyncio.run(handler(args)) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/examples/skills_code_review_agent/sample_output/review_report.json b/examples/skills_code_review_agent/sample_output/review_report.json new file mode 100644 index 00000000..4185569f --- /dev/null +++ b/examples/skills_code_review_agent/sample_output/review_report.json @@ -0,0 +1,179 @@ +{ + "task_id": "9f3d2c1b0a9e48d7b6c5a4f3e2d1c0b9", + "created_at": "2026-07-06T08:00:00.000000+00:00", + "input": { + "type": "fixture", + "ref": "security_issue.diff", + "diff_summary": { + "file_count": 2, + "hunk_count": 2, + "added_line_count": 15, + "removed_line_count": 0, + "files": [ + { + "path": "app/admin.py", + "old_path": "app/admin.py", + "status": "modified", + "is_binary": false, + "hunk_count": 1, + "added_count": 10, + "removed_count": 0, + "hunk_ranges": [ + [ + 8, + 16 + ] + ], + "candidate_lines": [ + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20 + ] + }, + { + "path": "tests/test_admin.py", + "old_path": "tests/test_admin.py", + "status": "modified", + "is_binary": false, + "hunk_count": 1, + "added_count": 5, + "removed_count": 0, + "hunk_ranges": [ + [ + 3, + 8 + ] + ], + "candidate_lines": [ + 6, + 7, + 8, + 9, + 10 + ] + } + ] + } + }, + "status": "completed", + "summary": "Automated review found 2 finding(s) (critical=2) and 0 item(s) needing human review.\n- [critical] app/admin.py:13 — Shell command built from dynamic input (command injection risk)\n- [critical] app/admin.py:17 — SQL statement built from dynamic strings (SQL injection risk)\nFix the critical/high items before merging; see per-finding recommendations in the report.", + "findings": [ + { + "severity": "critical", + "category": "security_risk", + "file": "app/admin.py", + "line": 13, + "title": "Shell command built from dynamic input (command injection risk)", + "evidence": "os.system(\"tar czf /backups/\" + username + \".tgz /home/\" + username)", + "recommendation": "Never concatenate or interpolate user input into a command string; pass an argv list and validate inputs.", + "confidence": 0.88, + "source": "static_rule", + "rule_id": "SEC009", + "extra": { + "also_matched": [ + "SEC001" + ] + } + }, + { + "severity": "critical", + "category": "security_risk", + "file": "app/admin.py", + "line": 17, + "title": "SQL statement built from dynamic strings (SQL injection risk)", + "evidence": "cursor.execute(f\"SELECT id, role FROM users WHERE name = '{name}'\")", + "recommendation": "Use parameterized queries: cursor.execute(\"... WHERE name = %s\", (name,)) instead of f-strings or string concatenation.", + "confidence": 0.85, + "source": "static_rule", + "rule_id": "SEC006" + } + ], + "needs_human_review": [], + "severity_stats": { + "critical": 2, + "high": 0, + "medium": 0, + "low": 0, + "info": 0 + }, + "filter_summary": { + "total_decisions": 1, + "blocked": 0, + "events": [ + { + "stage": "sandbox_gate", + "target": "skills/code-review/scripts/run_checks.py", + "action": "allow", + "rule": "", + "reasons": [] + } + ] + }, + "sandbox_summary": { + "total_runs": 1, + "runs": [ + { + "run_index": 0, + "kind": "static_checks", + "runtime_kind": "local", + "cmd": "python3", + "status": "ok", + "filter_action": "allow", + "filter_reasons": [], + "exit_code": 0, + "timed_out": false, + "duration_ms": 88.4, + "output_truncated": false, + "error_type": "" + } + ] + }, + "metrics": { + "total_duration_ms": 171.35, + "sandbox_duration_ms": 88.4, + "sandbox_run_count": 1, + "tool_call_count": 3, + "llm_call_count": 1, + "filter_block_count": 0, + "filter_decisions": { + "allow": 1, + "deny": 0, + "needs_human_review": 0 + }, + "finding_count": 2, + "needs_human_review_count": 0, + "deduplicated_count": 1, + "redaction_count": 0, + "severity_distribution": { + "critical": 2, + "high": 0, + "medium": 0, + "low": 0, + "info": 0 + }, + "error_types": {} + }, + "recommendations": [ + { + "file": "app/admin.py", + "line": 13, + "severity": "critical", + "title": "Shell command built from dynamic input (command injection risk)", + "recommendation": "Never concatenate or interpolate user input into a command string; pass an argv list and validate inputs." + }, + { + "file": "app/admin.py", + "line": 17, + "severity": "critical", + "title": "SQL statement built from dynamic strings (SQL injection risk)", + "recommendation": "Use parameterized queries: cursor.execute(\"... WHERE name = %s\", (name,)) instead of f-strings or string concatenation." + } + ] +} \ No newline at end of file diff --git a/examples/skills_code_review_agent/sample_output/review_report.md b/examples/skills_code_review_agent/sample_output/review_report.md new file mode 100644 index 00000000..3c0d369f --- /dev/null +++ b/examples/skills_code_review_agent/sample_output/review_report.md @@ -0,0 +1,92 @@ +# Code Review Report 代码评审报告 + +- Task ID: `9f3d2c1b0a9e48d7b6c5a4f3e2d1c0b9` +- Status 状态: **completed** +- Created 生成时间: 2026-07-06T08:00:00.000000+00:00 +- Input 输入: fixture — `security_issue.diff` +- Diff: 2 file(s), 2 hunk(s), +15 / -0 + +## Findings 摘要 + +Automated review found 2 finding(s) (critical=2) and 0 item(s) needing human review. +- [critical] app/admin.py:13 — Shell command built from dynamic input (command injection risk) +- [critical] app/admin.py:17 — SQL statement built from dynamic strings (SQL injection risk) +Fix the critical/high items before merging; see per-finding recommendations in the report. + +| Severity | Category | File:Line | Title | Confidence | Source | +|---|---|---|---|---|---| +| critical | security_risk | `app/admin.py:13` | Shell command built from dynamic input (command injection risk) | 0.88 | static_rule | +| critical | security_risk | `app/admin.py:17` | SQL statement built from dynamic strings (SQL injection risk) | 0.85 | static_rule | + +### [CRITICAL] Shell command built from dynamic input (command injection risk) — `app/admin.py:13` + +- Rule 规则: `SEC009` (category: security_risk, confidence: 0.88, source: static_rule) +- Evidence 证据: `os.system("tar czf /backups/" + username + ".tgz /home/" + username)` +- Recommendation 修复建议: Never concatenate or interpolate user input into a command string; pass an argv list and validate inputs. + +### [CRITICAL] SQL statement built from dynamic strings (SQL injection risk) — `app/admin.py:17` + +- Rule 规则: `SEC006` (category: security_risk, confidence: 0.85, source: static_rule) +- Evidence 证据: `cursor.execute(f"SELECT id, role FROM users WHERE name = '{name}'")` +- Recommendation 修复建议: Use parameterized queries: cursor.execute("... WHERE name = %s", (name,)) instead of f-strings or string concatenation. + +## 严重级别统计 Severity Stats + +| Severity | Count | +|---|---| +| critical | 2 | +| high | 0 | +| medium | 0 | +| low | 0 | +| info | 0 | + +## 人工复核项 Needs Human Review + +低置信度结果不混入高置信 findings，由人工确认。 Low-confidence results are kept out of the findings list for human triage. + +(none 无) + +## Filter 拦截摘要 Filter Blocks + +Decisions 决策总数: 1; Blocked 拦截: 0 + +## 监控指标 Metrics + +```json +{ + "total_duration_ms": 171.35, + "sandbox_duration_ms": 88.4, + "sandbox_run_count": 1, + "tool_call_count": 3, + "llm_call_count": 1, + "filter_block_count": 0, + "filter_decisions": { + "allow": 1, + "deny": 0, + "needs_human_review": 0 + }, + "finding_count": 2, + "needs_human_review_count": 0, + "deduplicated_count": 1, + "redaction_count": 0, + "severity_distribution": { + "critical": 2, + "high": 0, + "medium": 0, + "low": 0, + "info": 0 + }, + "error_types": {} +} +``` + +## 沙箱执行摘要 Sandbox Runs + +| # | Kind | Runtime | Status | Exit | Timed out | Duration (ms) | Error | +|---|---|---|---|---|---|---|---| +| 0 | static_checks | local | ok | 0 | False | 88 | | + +## 修复建议 Recommendations + +1. **[critical]** `app/admin.py:13` — Never concatenate or interpolate user input into a command string; pass an argv list and validate inputs. +2. **[critical]** `app/admin.py:17` — Use parameterized queries: cursor.execute("... WHERE name = %s", (name,)) instead of f-strings or string concatenation. diff --git a/examples/skills_code_review_agent/skills/code-review/SKILL.md b/examples/skills_code_review_agent/skills/code-review/SKILL.md new file mode 100644 index 00000000..88821028 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/SKILL.md @@ -0,0 +1,66 @@ +--- +name: code-review +description: Automated code-review rules and scripts — parse a unified diff, run security/async/resource/secret/DB-lifecycle/missing-tests checks, and emit structured findings JSON. +--- + +# code-review Skill + +自动代码评审技能：解析 unified diff，运行六类静态审查规则，输出结构化 findings。 +Automated code-review skill: parse a unified diff, run six categories of static +review rules, and emit structured findings. + +## Contents 目录结构 + +- `SKILL.md` — this document 本说明 +- `rules/` — human-readable rule documentation, one file per category + 规则文档（每类一份）: `security-risk.md`, `async-errors.md`, `resource-leaks.md`, + `missing-tests.md`, `secret-leakage.md`, `db-lifecycle.md` +- `scripts/parse_diff.py` — raw diff → normalized changeset JSON +- `scripts/run_checks.py` — changeset JSON → findings JSON +- `scripts/lib/` — stdlib-only rule library (diff parser, rule engine, rule + modules, canonical secret-pattern table) + +## Commands 命令 + +Inside the staged workspace (`$WORKSPACE_DIR`): + +```bash +# 1. Parse a raw diff placed at work/inputs/raw.diff +python3 skills/code-review/scripts/parse_diff.py work/inputs/raw.diff work/diff.json + +# 2. Run all review rules; findings land in out/findings.json +python3 skills/code-review/scripts/run_checks.py work/diff.json out/findings.json \ + --files-dir work/inputs/files +``` + +## Inputs 输入 + +- `work/inputs/raw.diff` — unified diff text (git diff / PR patch) +- `work/inputs/diff.json` — alternatively, a pre-parsed changeset +- `work/inputs/files/` — optional full new-file contents (`{path}` layout) for + higher-accuracy whole-file heuristics + +## Outputs 输出 + +`out/findings.json`: + +```json +{"findings": [{"severity": "high", "category": "security_risk", "file": "app.py", + "line": 12, "title": "...", "evidence": "...", "recommendation": "...", + "confidence": 0.9, "source": "static_rule", "rule_id": "SEC001"}]} +``` + +- `severity`: critical | high | medium | low | info +- `category`: security_risk | async_error | resource_leak | missing_tests | + secret_leakage | db_lifecycle +- `confidence`: 0.0–1.0; the host agent routes < min_confidence findings to the + needs_human_review bucket (noise control 降噪). +- Secret evidence is ALWAYS pre-redacted inside the sandbox — plaintext + credentials never leave `scripts/lib/rule_secrets.py`. + +## Environment 环境 + +Scripts are stdlib-only (Python ≥ 3.9) and run with a whitelisted environment; +they need no network, no site-packages and never write outside the workspace. +`--force-fail` on `run_checks.py` raises deterministically — the host uses it +to verify that sandbox failures cannot crash a review task. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/async-errors.md b/examples/skills_code_review_agent/skills/code-review/rules/async-errors.md new file mode 100644 index 00000000..462ea91e --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/async-errors.md @@ -0,0 +1,25 @@ +# 异步错误 Async Errors (`async_error`) + +事件循环阻塞、丢失的协程与被丢弃的任务。 +Event-loop blocking, lost coroutines and discarded tasks. + +| Rule | Trigger 触发条件 | Severity | Confidence | +|---|---|---|---| +| ASY001 | `time.sleep(` inside `async def` | high | 0.90 | +| ASY002 | `requests.*` / `urllib.request.*` inside `async def` 阻塞 IO | medium | 0.75 | +| ASY003 | `asyncio.create_task(...)` 返回值被丢弃 | medium | 0.60 | +| ASY004 | 已知协程调用缺少 `await`（启发式） | high | 0.60 | +| ASY005 | `subprocess.run/call/...` inside `async def` | medium | 0.70 | + +`async def` 归属通过全文件内容（可用时）或 hunk 可见行的缩进回溯判断； +纯 diff 输入下这是启发式，低置信度结果会进入人工复核桶。 +Enclosing-`async def` detection walks indentation backwards over full file +content when available, else over visible hunk lines — on pure diffs this is a +heuristic, so low-confidence hits are routed to needs_human_review. + +## 修复建议 Remediation + +- `await asyncio.sleep(...)` instead of `time.sleep(...)`. +- Async HTTP clients (aiohttp / `httpx.AsyncClient`) or `asyncio.to_thread(...)`. +- Keep task references and `await`/`gather` them; discarded tasks may be + garbage-collected mid-flight and silently swallow exceptions. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/db-lifecycle.md b/examples/skills_code_review_agent/skills/code-review/rules/db-lifecycle.md new file mode 100644 index 00000000..17781212 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/db-lifecycle.md @@ -0,0 +1,25 @@ +# 数据库事务/连接生命周期 DB Lifecycle (`db_lifecycle`) + +连接未关闭、事务未提交/回滚、循环内建连、autocommit 混用。 +Unclosed connections, unfinished transactions, per-loop connections and mixed +autocommit modes. + +| Rule | Trigger 触发条件 | Severity | Confidence | +|---|---|---|---| +| DBL001 | `conn = xxx.connect(...)` 无 `with`/`close()` | high | 0.75 | +| DBL002 | `cur = conn.cursor()` 无 `with`/`close()` | medium | 0.60 | +| DBL003 | `begin(` / `execute("BEGIN")` 而变更内无 commit/rollback | high | 0.75 | +| DBL004 | 循环体内创建数据库连接 | high | 0.70 | +| DBL005 | `autocommit=True` 与显式事务调用混用 | medium | 0.60 | + +`close()`/`commit()` 可能位于 diff 可见范围之外，因此这些是启发式规则； +提供 `--files-dir`（repo-path / file-list 输入）时用全文件内容判断，精度更高。 +The matching `close()`/`commit()` may live outside the visible hunk, so these +are heuristics; with `--files-dir` (repo-path / file-list inputs) whole-file +content is used and accuracy rises. + +## 修复建议 Remediation + +- `with engine.connect() as conn:` / `with conn.begin():` — 出错自动回滚。 +- Never create connections inside loops — hoist them out or use a pool. +- Pick ONE mode: autocommit for single statements, or explicit transactions. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/missing-tests.md b/examples/skills_code_review_agent/skills/code-review/rules/missing-tests.md new file mode 100644 index 00000000..2ee4e0fe --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/missing-tests.md @@ -0,0 +1,22 @@ +# 测试缺失 Missing Tests (`missing_tests`) + +变更集级规则：改了代码却没改任何测试。 +Changeset-level rule: code changed, no test files touched. + +| Rule | Trigger 触发条件 | Severity | Confidence | +|---|---|---|---| +| TST001 | ≥1 个代码文件新增行（.py/.go/.js/.ts/…）且变更集中无任何测试文件 | low | 0.90 | + +测试文件识别：`tests/` / `test/` 目录、`test_*.py`、`*_test.py`、`*.test.ts`、 +`*_test.go` 等命名约定。删除的文件与二进制文件不计入。每个变更集最多报一条 +（挂在第一个代码文件上，line=1），避免刷屏。 +Test files are recognized by path (`tests/`, `test/`) and naming conventions +(`test_*.py`, `*_test.py`, `*.test.ts`, `*_test.go`). Deleted and binary files +are ignored. At most ONE finding per changeset (anchored to the first changed +code file, line 1) to avoid noise. + +## 修复建议 Remediation + +为变更的行为补充或更新单元测试；未被测试覆盖的改动会静默回归。 +Add or update unit tests covering the changed behavior — untested changes +regress silently. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/resource-leaks.md b/examples/skills_code_review_agent/skills/code-review/rules/resource-leaks.md new file mode 100644 index 00000000..3873b0cd --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/resource-leaks.md @@ -0,0 +1,24 @@ +# 资源泄漏 Resource Leaks (`resource_leak`) + +未释放的文件句柄、socket、临时文件与线程。 +Unreleased file handles, sockets, temp files and threads. + +| Rule | Trigger 触发条件 | Severity | Confidence | +|---|---|---|---| +| RES001 | `x = open(...)` 无 `with` 且可见范围内无 `x.close()` | medium | 0.65 | +| RES002 | `s = socket.socket(...)` 无 `with` / `close()` | medium | 0.65 | +| RES003 | `NamedTemporaryFile(delete=False)` | low | 0.85 | +| RES004 | `threading.Thread(...)` 无 `join()` / `daemon` | low | 0.50 | +| RES005 | `open(...)` 内联使用，句柄无法关闭 | medium | 0.60 | + +RES001/RES002/RES004/RES005 是 diff 范围内的启发式（`close()` 可能在 diff +之外），置信度 ≤ 0.65，默认进入 needs_human_review 桶而不混入高置信 findings。 +These are diff-scope heuristics (the `close()` may live outside the hunk), so +their confidence is capped at 0.65 and they land in the needs_human_review +bucket by default. + +## 修复建议 Remediation + +- `with open(path) as f:` / `with socket.socket() as s:` — release on every path. +- Delete `delete=False` temp files in a `finally` block (`os.unlink`). +- `join()` worker threads on shutdown or mark them `daemon=True` deliberately. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/secret-leakage.md b/examples/skills_code_review_agent/skills/code-review/rules/secret-leakage.md new file mode 100644 index 00000000..0a6c9ba6 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/secret-leakage.md @@ -0,0 +1,42 @@ +# 敏感信息泄漏 Secret Leakage (`secret_leakage`) + +提交进源码的密钥、令牌、口令与私钥。 +Keys, tokens, passwords and private keys committed to source. + +检测与脱敏共用同一张正则表（`scripts/lib/secret_patterns.py`）—— +沙箱规则用它**检测**，宿主端 `SecretRedactor` 用它**脱敏**，永不漂移。 +Detection and redaction share ONE canonical pattern table +(`scripts/lib/secret_patterns.py`): the sandbox rule *detects* with it, the +host-side `SecretRedactor` *scrubs* with it — they can never drift apart. + +| Pattern id | 覆盖 Coverage | +|---|---| +| aws_access_key_id | `AKIA/ASIA/...` + 16 chars | +| aws_secret_access_key | `aws_secret_access_key = <40 chars>` | +| github_token | `ghp_/gho_/ghu_/ghs_/ghr_...` | +| slack_token | `xox[baprs]-...` | +| openai_api_key | `sk-...` (≥20 chars) | +| google_api_key | `AIza...` (≥30 chars) | +| jwt_token | `eyJ...`.`...`.`...` | +| private_key_block | `-----BEGIN ... PRIVATE KEY-----` | +| bearer_token | `Bearer ` | +| url_credentials | `scheme://user:pass@host` | +| generic_assignment | `password/secret/token/api_key/... = "value"` | + +误报防护：值为 `os.environ...`、`${VAR}`、``、`None/True/False` +等引用形态时不报。所有 finding 的 evidence 在沙箱内即完成脱敏 +（`***REDACTED***`），明文密钥不会进入 findings JSON、报告或数据库。 +False-positive guard: values that are clearly references +(`os.environ...`, `${VAR}`, ``, `None/True/False`) are skipped. +Evidence is redacted INSIDE the sandbox — plaintext secrets never reach the +findings payload, the report or the database. + +| Rule | Severity | Confidence | +|---|---|---| +| SCR_* (one per pattern id) | critical | 0.90 | + +## 修复建议 Remediation + +立即吊销并轮换泄漏的凭据；改从环境变量或密钥管理服务加载。 +Rotate the leaked credential immediately; load it from an environment variable +or a secret manager instead. diff --git a/examples/skills_code_review_agent/skills/code-review/rules/security-risk.md b/examples/skills_code_review_agent/skills/code-review/rules/security-risk.md new file mode 100644 index 00000000..5869a11c --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/rules/security-risk.md @@ -0,0 +1,24 @@ +# 安全风险 Security Risk (`security_risk`) + +命令注入、SQL 注入、危险反序列化与不安全配置。 +Command injection, SQL injection, dangerous deserialization and insecure settings. + +| Rule | Trigger 触发条件 | Severity | Confidence | +|---|---|---|---| +| SEC001 | `os.system(...)` | high | 0.90 | +| SEC002 | `subprocess.*(..., shell=True)` | high | 0.90 | +| SEC003 | `eval(` / `exec(` on data 动态执行 | high | 0.75 | +| SEC004 | `pickle.load/loads` 反序列化不可信数据 | high | 0.85 | +| SEC005 | `yaml.load` 未用 SafeLoader | medium | 0.85 | +| SEC006 | `.execute(f"..."/"..."+ / %)` 拼接 SQL | critical | 0.85 | +| SEC007 | `md5(` 与 password 同行（弱哈希） | medium | 0.60 | +| SEC008 | `verify=False` 关闭 TLS 校验 | high | 0.90 | +| SEC009 | 命令字符串由动态输入拼接 | critical | 0.88 | + +## 修复建议 Remediation + +- 用参数化查询代替字符串拼接 SQL：`cursor.execute("... WHERE id = %s", (uid,))`。 +- 用 `subprocess.run([...], shell=False)` + 参数列表代替 `os.system` / `shell=True`。 +- Replace `eval`/`exec` with `ast.literal_eval` or an explicit dispatch table. +- Never unpickle untrusted bytes; prefer JSON with schema validation. +- Keep TLS verification on; pin an internal CA bundle when necessary. diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/__init__.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/__init__.py new file mode 100644 index 00000000..9161e9a9 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/__init__.py @@ -0,0 +1,13 @@ +# 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. +"""Self-contained, stdlib-only rule library for the code-review skill. + +Every module in this package must stay importable inside a bare sandbox +(no third-party site-packages). The host-side ``codereview`` package loads +this exact package through ``importlib`` so the sandbox and the host always +share a single implementation of the diff parser, the secret pattern table +and the review rules (single source of truth, no drift). +""" diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/diffparse.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/diffparse.py new file mode 100644 index 00000000..dbab9dae --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/diffparse.py @@ -0,0 +1,221 @@ +# 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. +"""Unified diff parser (stdlib-only, shared by sandbox and host). + +Parses ``git diff`` / plain unified diff text into a normalized changeset +dict with files, hunks, per-line old/new line numbers, context lines and +candidate (added) line numbers — exactly the structure the review rules +consume. +""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List +from typing import Optional + +_RE_DIFF_GIT = re.compile(r'^diff --git (?:"?a/(?P.+?)"?) (?:"?b/(?P.+?)"?)\s*$') +_RE_HUNK = re.compile(r"^@@ -(?P\d+)(?:,(?P\d+))? \+(?P\d+)(?:,(?P\d+))? @@(?P.*)$") +_RE_OLD_FILE = re.compile(r'^--- (?:"?a/(?P

.+?)"?|(?P/dev/null))\s*$') +_RE_NEW_FILE = re.compile(r'^\+\+\+ (?:"?b/(?P

.+?)"?|(?P/dev/null))\s*$') + +STATUS_ADDED = "added" +STATUS_DELETED = "deleted" +STATUS_MODIFIED = "modified" +STATUS_RENAMED = "renamed" + + +def _new_file_entry() -> Dict[str, Any]: + return { + "path": "", + "old_path": "", + "status": STATUS_MODIFIED, + "is_binary": False, + "hunks": [], + "added_lines": [], + "removed_lines": [], + } + + +def _finish_file(files: List[Dict[str, Any]], entry: Optional[Dict[str, Any]]) -> None: + if entry is None: + return + if not entry["path"] and not entry["old_path"]: + return + if not entry["path"]: + # File deleted: keep the old path so findings can still reference it. + entry["path"] = entry["old_path"] + for hunk in entry["hunks"]: + for line in hunk["lines"]: + if line["tag"] == "+": + entry["added_lines"].append({"line": line["new_lineno"], "content": line["content"]}) + elif line["tag"] == "-": + entry["removed_lines"].append({"line": line["old_lineno"], "content": line["content"]}) + files.append(entry) + + +def parse_unified_diff(text: str) -> Dict[str, Any]: + """Parse unified diff text into a normalized changeset dict. + + Args: + text: Raw unified diff text (``git diff`` output or plain diff). + + Returns: + ``{"files": [...]}`` where every file entry carries path, old_path, + status, hunks (with per-line old/new line numbers and context lines) + and flattened ``added_lines`` / ``removed_lines`` candidates. + """ + files: List[Dict[str, Any]] = [] + entry: Optional[Dict[str, Any]] = None + hunk: Optional[Dict[str, Any]] = None + old_lineno = new_lineno = 0 + + for raw_line in text.splitlines(): + m = _RE_DIFF_GIT.match(raw_line) + if m: + _finish_file(files, entry) + entry = _new_file_entry() + entry["old_path"] = m.group("a") + entry["path"] = m.group("b") + hunk = None + continue + + if raw_line.startswith("new file mode"): + if entry is not None: + entry["status"] = STATUS_ADDED + continue + if raw_line.startswith("deleted file mode"): + if entry is not None: + entry["status"] = STATUS_DELETED + continue + if raw_line.startswith("rename from "): + if entry is not None: + entry["status"] = STATUS_RENAMED + entry["old_path"] = raw_line[len("rename from "):].strip() + continue + if raw_line.startswith("rename to "): + if entry is not None: + entry["status"] = STATUS_RENAMED + entry["path"] = raw_line[len("rename to "):].strip() + continue + if raw_line.startswith("Binary files ") or raw_line.startswith("GIT binary patch"): + if entry is not None: + entry["is_binary"] = True + continue + if raw_line.startswith("index ") or raw_line.startswith("similarity index ") \ + or raw_line.startswith("old mode") or raw_line.startswith("new mode"): + continue + + m = _RE_OLD_FILE.match(raw_line) + if m and hunk is None: + if entry is None: + # Plain unified diff without a "diff --git" header. + entry = _new_file_entry() + if m.group("devnull"): + entry["status"] = STATUS_ADDED + else: + entry["old_path"] = m.group("p") + continue + + m = _RE_NEW_FILE.match(raw_line) + if m and hunk is None: + if entry is None: + entry = _new_file_entry() + if m.group("devnull"): + entry["status"] = STATUS_DELETED + else: + entry["path"] = m.group("p") + continue + + m = _RE_HUNK.match(raw_line) + if m: + if entry is None: + entry = _new_file_entry() + old_lineno = int(m.group("os")) + new_lineno = int(m.group("ns")) + hunk = { + "old_start": old_lineno, + "old_count": int(m.group("oc") or "1"), + "new_start": new_lineno, + "new_count": int(m.group("nc") or "1"), + "header": m.group("hdr").strip(), + "lines": [], + } + entry["hunks"].append(hunk) + continue + + if hunk is None: + continue + if raw_line.startswith("\\"): + # "\ No newline at end of file" + continue + if raw_line.startswith("+"): + hunk["lines"].append({ + "tag": "+", + "old_lineno": None, + "new_lineno": new_lineno, + "content": raw_line[1:], + }) + new_lineno += 1 + elif raw_line.startswith("-"): + hunk["lines"].append({ + "tag": "-", + "old_lineno": old_lineno, + "new_lineno": None, + "content": raw_line[1:], + }) + old_lineno += 1 + else: + # Context line ("" happens for empty context lines in some diffs). + content = raw_line[1:] if raw_line.startswith(" ") else raw_line + hunk["lines"].append({ + "tag": " ", + "old_lineno": old_lineno, + "new_lineno": new_lineno, + "content": content, + }) + old_lineno += 1 + new_lineno += 1 + + _finish_file(files, entry) + return {"files": files} + + +def build_diff_summary(changeset: Dict[str, Any]) -> Dict[str, Any]: + """Build a content-free summary of a parsed changeset. + + Deliberately excludes raw line contents so the summary can be stored + in the database without any secret-leak surface. + """ + files_summary = [] + total_added = total_removed = total_hunks = 0 + for f in changeset.get("files", []): + added = len(f.get("added_lines", [])) + removed = len(f.get("removed_lines", [])) + hunks = f.get("hunks", []) + total_added += added + total_removed += removed + total_hunks += len(hunks) + files_summary.append({ + "path": f.get("path", ""), + "old_path": f.get("old_path", ""), + "status": f.get("status", ""), + "is_binary": bool(f.get("is_binary")), + "hunk_count": len(hunks), + "added_count": added, + "removed_count": removed, + "hunk_ranges": [[h.get("new_start"), h.get("new_count")] for h in hunks], + "candidate_lines": [line["line"] for line in f.get("added_lines", [])], + }) + return { + "file_count": len(files_summary), + "hunk_count": total_hunks, + "added_line_count": total_added, + "removed_line_count": total_removed, + "files": files_summary, + } diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/engine.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/engine.py new file mode 100644 index 00000000..4f86cd5f --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/engine.py @@ -0,0 +1,65 @@ +# 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. +"""Rule engine: run every review rule over a parsed changeset.""" + +from __future__ import annotations + +from typing import Any +from typing import Dict +from typing import List +from typing import Optional + +from . import rule_async +from . import rule_db_lifecycle +from . import rule_missing_tests +from . import rule_resource +from . import rule_secrets +from . import rule_security +from .rulebase import RuleContext + +_FILE_RULE_MODULES = (rule_security, rule_async, rule_resource, rule_secrets, rule_db_lifecycle) + +_ANALYZABLE_SUFFIXES = (".py", ".pyi") + + +def run_all_rules(changeset: Dict[str, Any], + file_contents: Optional[Dict[str, str]] = None) -> List[Dict[str, Any]]: + """Run every rule module over the changeset. + + Args: + changeset: Parsed changeset (``diffparse.parse_unified_diff`` output). + file_contents: Optional ``{path: full_new_content}`` map. When present + (repo-path / file-list inputs) rules get whole-file context, which + raises heuristic accuracy; pure-diff inputs work without it. + + Returns: + Flat list of finding dicts (schema defined in ``rulebase.make_finding``). + """ + file_contents = file_contents or {} + findings: List[Dict[str, Any]] = [] + + for entry in changeset.get("files", []): + path = entry.get("path", "") + if not path or entry.get("is_binary") or entry.get("status") == "deleted": + continue + content = file_contents.get(path) + ctx = RuleContext( + file_entry=entry, + content=content, + content_lines=content.splitlines() if content else [], + ) + if path.lower().endswith(_ANALYZABLE_SUFFIXES): + modules = _FILE_RULE_MODULES + else: + # Non-Python files still get secret scanning (config files are the + # most common leak vector); language-specific rules are skipped. + modules = (rule_secrets,) + for module in modules: + findings.extend(module.check_file(ctx)) + + findings.extend(rule_missing_tests.check_changeset(changeset)) + findings.sort(key=lambda f: (f["file"], f["line"], f["rule_id"])) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_async.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_async.py new file mode 100644 index 00000000..7d9a3b98 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_async.py @@ -0,0 +1,95 @@ +# 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. +"""Async-error rules (category: async_error).""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import RuleContext +from .rulebase import SEVERITY_HIGH +from .rulebase import SEVERITY_MEDIUM +from .rulebase import enclosing_def_is_async +from .rulebase import is_code_line +from .rulebase import iter_added_lines +from .rulebase import make_finding + +CATEGORY = "async_error" + +_RE_TIME_SLEEP = re.compile(r"\btime\.sleep\s*\(") +_RE_BLOCKING_IO = re.compile(r"\b(?:requests|urllib\.request)\.\w+\s*\(") +_RE_CREATE_TASK_DISCARDED = re.compile(r"^\s*asyncio\.(?:create_task|ensure_future)\s*\(") +_RE_BARE_CORO_CALL = re.compile(r"^\s*(?:await\s+)?(\w+(?:\.\w+)*)\s*\(") +_RE_ASYNC_DEF = re.compile(r"^\s*async\s+def\s+(\w+)") +_RE_SUBPROCESS_BLOCKING = re.compile(r"\bsubprocess\.(?:run|call|check_output|check_call)\s*\(") + + +def _collect_async_def_names(ctx: RuleContext) -> List[str]: + """Names of coroutine functions defined in the visible change/content.""" + names: List[str] = [] + sources: List[str] = [] + if ctx.content_lines: + sources.extend(ctx.content_lines) + else: + for hunk in ctx.file_entry.get("hunks", []): + for line in hunk.get("lines", []): + if line.get("tag") in ("+", " "): + sources.append(line.get("content", "")) + for content in sources: + match = _RE_ASYNC_DEF.match(content) + if match: + names.append(match.group(1)) + return names + + +def check_file(ctx: RuleContext) -> List[Dict[str, Any]]: + findings: List[Dict[str, Any]] = [] + path = ctx.path + async_def_names = _collect_async_def_names(ctx) + + for lineno, content, hunk in iter_added_lines(ctx.file_entry): + if not is_code_line(content): + continue + inside_async = enclosing_def_is_async(ctx, hunk, lineno, content) + + if inside_async and _RE_TIME_SLEEP.search(content): + findings.append( + make_finding("ASY001", CATEGORY, SEVERITY_HIGH, 0.9, path, lineno, + "Blocking time.sleep inside async function", content, + "Use `await asyncio.sleep(...)` inside coroutines; time.sleep blocks " + "the whole event loop.")) + if inside_async and _RE_BLOCKING_IO.search(content): + findings.append( + make_finding("ASY002", CATEGORY, SEVERITY_MEDIUM, 0.75, path, lineno, + "Blocking network IO inside async function", content, + "Use an async HTTP client (aiohttp/httpx.AsyncClient) or run the " + "blocking call in `asyncio.to_thread(...)`.")) + if inside_async and _RE_SUBPROCESS_BLOCKING.search(content): + findings.append( + make_finding("ASY005", CATEGORY, SEVERITY_MEDIUM, 0.7, path, lineno, + "Blocking subprocess call inside async function", content, + "Use `asyncio.create_subprocess_exec(...)` or wrap the call in " + "`asyncio.to_thread(...)`.")) + if _RE_CREATE_TASK_DISCARDED.match(content): + findings.append( + make_finding("ASY003", CATEGORY, SEVERITY_MEDIUM, 0.6, path, lineno, + "asyncio task created but reference discarded", content, + "Keep a reference to the task (and await or gather it); discarded " + "tasks can be garbage-collected mid-run and swallow exceptions.")) + match = _RE_BARE_CORO_CALL.match(content) + if (match and async_def_names and "await" not in content and "return" not in content + and match.group(1).split(".")[-1] in async_def_names + and not _RE_CREATE_TASK_DISCARDED.match(content)): + findings.append( + make_finding("ASY004", CATEGORY, SEVERITY_HIGH, 0.6, path, lineno, + "Coroutine called without await", content, + f"`{match.group(1)}` is defined as `async def`; call it with " + "`await` (or schedule it with asyncio.create_task and keep the " + "reference), otherwise it never runs.")) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_db_lifecycle.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_db_lifecycle.py new file mode 100644 index 00000000..83440797 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_db_lifecycle.py @@ -0,0 +1,91 @@ +# 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. +"""DB transaction / connection lifecycle rules (category: db_lifecycle).""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import RuleContext +from .rulebase import SEVERITY_HIGH +from .rulebase import SEVERITY_MEDIUM +from .rulebase import file_added_text +from .rulebase import is_code_line +from .rulebase import iter_added_lines +from .rulebase import make_finding + +CATEGORY = "db_lifecycle" + +_RE_CONNECT_ASSIGN = re.compile(r"^\s*(\w+)\s*=\s*[\w.]+\.connect\s*\(") +_RE_WITH_CONNECT = re.compile(r"\bwith\s+[^:]*\.connect\s*\(") +_RE_CURSOR_ASSIGN = re.compile(r"^\s*(\w+)\s*=\s*\w+\.cursor\s*\(") +_RE_BEGIN = re.compile(r"(?:\.begin\s*\(|\bexecute\s*\(\s*[\"']\s*BEGIN\b)", re.IGNORECASE) +_RE_COMMIT_OR_ROLLBACK = re.compile(r"\.(commit|rollback)\s*\(|\bexecute\s*\(\s*[\"']\s*(COMMIT|ROLLBACK)\b", + re.IGNORECASE) +_RE_AUTOCOMMIT_TRUE = re.compile(r"\bautocommit\s*=\s*True\b") +_RE_TXN_OP = re.compile(r"\.(commit|rollback|begin)\s*\(") +_RE_LOOP_HEADER = re.compile(r"^\s*(?:for|while)\b") + + +def _var_released(scope_text: str, var: str) -> bool: + needle = re.compile(rf"\b{re.escape(var)}\s*\.\s*close\s*\(|\bwith\s+.*\b{re.escape(var)}\b") + return bool(needle.search(scope_text)) + + +def check_file(ctx: RuleContext) -> List[Dict[str, Any]]: + findings: List[Dict[str, Any]] = [] + path = ctx.path + scope_text = file_added_text(ctx.file_entry) + if ctx.content: + scope_text = scope_text + "\n" + ctx.content + loop_depth_lines: List[int] = [] + + for lineno, content, _hunk in iter_added_lines(ctx.file_entry): + if not is_code_line(content): + continue + if _RE_LOOP_HEADER.match(content): + loop_depth_lines.append(len(content) - len(content.lstrip())) + continue + + match = _RE_CONNECT_ASSIGN.match(content) + if match and not _RE_WITH_CONNECT.search(content): + indent = len(content) - len(content.lstrip()) + in_loop = any(indent > loop_indent for loop_indent in loop_depth_lines) + if in_loop: + findings.append( + make_finding("DBL004", CATEGORY, SEVERITY_HIGH, 0.7, path, lineno, + "Database connection created inside a loop", content, + "Create the connection once outside the loop (or use a pool); " + "per-iteration connections exhaust the server connection limit.")) + if not _var_released(scope_text, match.group(1)): + findings.append( + make_finding("DBL001", CATEGORY, SEVERITY_HIGH, 0.75, path, lineno, + "Database connection opened without close()", content, + "Use `with ... .connect(...) as conn:` or close the connection " + "in a `finally` block so it returns to the pool on every path.")) + match = _RE_CURSOR_ASSIGN.match(content) + if match and "with" not in content and not _var_released(scope_text, match.group(1)): + findings.append( + make_finding("DBL002", CATEGORY, SEVERITY_MEDIUM, 0.6, path, lineno, + "Cursor created without close()", content, + "Use `with conn.cursor() as cur:` (or close it in finally); open " + "cursors hold server-side resources.")) + if _RE_BEGIN.search(content) and not _RE_COMMIT_OR_ROLLBACK.search(scope_text): + findings.append( + make_finding("DBL003", CATEGORY, SEVERITY_HIGH, 0.75, path, lineno, + "Transaction started without commit/rollback in change", content, + "Pair every BEGIN with commit() on success and rollback() in the " + "exception path — `with conn.begin():` does both automatically.")) + if _RE_AUTOCOMMIT_TRUE.search(content) and _RE_TXN_OP.search(scope_text): + findings.append( + make_finding("DBL005", CATEGORY, SEVERITY_MEDIUM, 0.6, path, lineno, + "autocommit=True mixed with explicit transaction calls", content, + "Pick one mode: either autocommit for single statements or explicit " + "begin/commit blocks; mixing both silently breaks atomicity.")) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_missing_tests.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_missing_tests.py new file mode 100644 index 00000000..e2abd8cd --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_missing_tests.py @@ -0,0 +1,61 @@ +# 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. +"""Missing-tests rule (category: missing_tests) — changeset level.""" + +from __future__ import annotations + +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import SEVERITY_LOW +from .rulebase import make_finding + +CATEGORY = "missing_tests" + +_CODE_SUFFIXES = (".py", ".go", ".js", ".ts", ".java", ".cc", ".cpp", ".rs") +_DOC_SUFFIXES = (".md", ".rst", ".txt", ".toml", ".cfg", ".ini", ".yaml", ".yml", ".json", ".lock") + + +def _is_test_path(path: str) -> bool: + lowered = path.lower().replace("\\", "/") + name = lowered.rsplit("/", 1)[-1] + return ("tests/" in lowered or lowered.startswith("test/") or "/test/" in lowered + or name.startswith("test_") or name.endswith("_test.py") or name.endswith(".test.js") + or name.endswith(".test.ts") or name.endswith("_test.go")) + + +def _is_code_path(path: str) -> bool: + lowered = path.lower() + return lowered.endswith(_CODE_SUFFIXES) and not lowered.endswith(_DOC_SUFFIXES) + + +def check_changeset(changeset: Dict[str, Any]) -> List[Dict[str, Any]]: + """One changeset-level finding when code changed but no tests did.""" + code_files: List[str] = [] + has_test_change = False + for entry in changeset.get("files", []): + path = entry.get("path", "") + if not path or entry.get("is_binary") or entry.get("status") == "deleted": + continue + if not entry.get("added_lines"): + continue + if _is_test_path(path): + has_test_change = True + elif _is_code_path(path): + code_files.append(path) + + if not code_files or has_test_change: + return [] + + file_list = ", ".join(code_files[:5]) + ("…" if len(code_files) > 5 else "") + return [ + make_finding("TST001", CATEGORY, SEVERITY_LOW, 0.9, code_files[0], 1, + "Code changed without accompanying test changes", + f"Changed code files with no test updates: {file_list}", + "Add or update unit tests covering the changed behavior (test_*.py / " + "*_test.py under tests/); untested changes regress silently.") + ] diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_resource.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_resource.py new file mode 100644 index 00000000..b2baaa36 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_resource.py @@ -0,0 +1,92 @@ +# 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. +"""Resource-leak rules (category: resource_leak).""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import RuleContext +from .rulebase import SEVERITY_LOW +from .rulebase import SEVERITY_MEDIUM +from .rulebase import file_added_text +from .rulebase import hunk_added_text +from .rulebase import is_code_line +from .rulebase import iter_added_lines +from .rulebase import make_finding + +CATEGORY = "resource_leak" + +_RE_OPEN = re.compile(r"(? bool: + """Best-effort: does `.close()` appear anywhere in the visible change?""" + scope_texts = [hunk_added_text(hunk), file_added_text(ctx.file_entry)] + if ctx.content: + scope_texts.append(ctx.content) + needle = re.compile(rf"\b{re.escape(var)}\s*\.\s*close\s*\(") + return any(needle.search(text) for text in scope_texts) + + +def check_file(ctx: RuleContext) -> List[Dict[str, Any]]: + findings: List[Dict[str, Any]] = [] + path = ctx.path + file_text = file_added_text(ctx.file_entry) + + for lineno, content, hunk in iter_added_lines(ctx.file_entry): + if not is_code_line(content): + continue + + match = _RE_ASSIGNED_OPEN.match(content) + if match and not _RE_WITH_OPEN.search(content) and not _closed_in_scope(ctx, hunk, match.group(1)): + findings.append( + make_finding("RES001", CATEGORY, SEVERITY_MEDIUM, 0.65, path, lineno, + "File handle opened without context manager or close()", content, + "Wrap the open() in a `with` block (or ensure `.close()` runs in a " + "`finally`) so the handle is released on every path.")) + match = _RE_ASSIGNED_SOCKET.match(content) + if match and not _RE_WITH_SOCKET.search(content) and not _closed_in_scope(ctx, hunk, match.group(1)): + findings.append( + make_finding("RES002", CATEGORY, SEVERITY_MEDIUM, 0.65, path, lineno, + "Socket created without context manager or close()", content, + "Use `with socket.socket(...) as s:` or close the socket in a " + "`finally` block to avoid leaking file descriptors.")) + if _RE_TMPFILE_KEEP.search(content): + findings.append( + make_finding("RES003", CATEGORY, SEVERITY_LOW, 0.85, path, lineno, + "NamedTemporaryFile(delete=False) leaves files behind", content, + "Delete the file explicitly (os.unlink in finally) or drop " + "delete=False so the OS cleans it up.")) + if (_RE_THREAD_START.search(content) and "daemon" not in content + and not _RE_JOIN.search(file_text)): + findings.append( + make_finding("RES004", CATEGORY, SEVERITY_LOW, 0.5, path, lineno, + "Thread started without join() or daemon flag", content, + "join() the thread on shutdown or mark it daemon=True; otherwise it " + "can outlive the process teardown and leak resources.")) + if (_RE_OPEN.search(content) and "with" not in content + and not _RE_ASSIGNED_OPEN.match(content) and "=" not in content.split("open")[0] + and not _RE_CLOSE.search(file_text)): + # e.g. `data = json.load(open(path))` — handle never captured at all. + findings.append( + make_finding("RES005", CATEGORY, SEVERITY_MEDIUM, 0.6, path, lineno, + "open() result used inline, handle can never be closed", content, + "Capture the handle in a `with open(...) as f:` block instead of " + "passing open() inline.")) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_secrets.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_secrets.py new file mode 100644 index 00000000..5d6a67e5 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_secrets.py @@ -0,0 +1,63 @@ +# 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. +"""Secret-leakage rules (category: secret_leakage). + +Detection reuses the canonical pattern table in :mod:`secret_patterns` +(the same table the host-side redactor uses), so detection and redaction +can never drift apart. Evidence text is pre-redacted here — a leaked +secret must never travel further than this module, not even inside the +sandbox→host findings payload. +""" + +from __future__ import annotations + +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import RuleContext +from .rulebase import SEVERITY_CRITICAL +from .rulebase import is_code_line +from .rulebase import iter_added_lines +from .rulebase import make_finding +from .secret_patterns import find_secrets +from .secret_patterns import redact_text + +CATEGORY = "secret_leakage" + +_TITLE_BY_ID = { + "aws_access_key_id": "AWS access key ID committed to source", + "aws_secret_access_key": "AWS secret access key committed to source", + "github_token": "GitHub token committed to source", + "slack_token": "Slack token committed to source", + "openai_api_key": "API key (sk-*) committed to source", + "google_api_key": "Google API key committed to source", + "jwt_token": "JWT committed to source", + "private_key_block": "Private key material committed to source", + "bearer_token": "Bearer token committed to source", + "url_credentials": "Credentials embedded in connection URL", + "generic_assignment": "Hard-coded credential assignment", +} + + +def check_file(ctx: RuleContext) -> List[Dict[str, Any]]: + findings: List[Dict[str, Any]] = [] + path = ctx.path + for lineno, content, _hunk in iter_added_lines(ctx.file_entry): + if not is_code_line(content): + continue + spans = find_secrets(content) + if not spans: + continue + redacted_evidence, _count = redact_text(content) + for span in spans: + title = _TITLE_BY_ID.get(span["id"], "Secret committed to source") + findings.append( + make_finding(f"SCR_{span['id']}", CATEGORY, SEVERITY_CRITICAL, 0.9, path, lineno, + title, redacted_evidence, + "Remove the credential from source, rotate it immediately, and load " + "it from a secret manager or environment variable instead.")) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_security.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_security.py new file mode 100644 index 00000000..fd183b32 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rule_security.py @@ -0,0 +1,99 @@ +# 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. +"""Security-risk rules (category: security_risk).""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List + +from .rulebase import RuleContext +from .rulebase import SEVERITY_CRITICAL +from .rulebase import SEVERITY_HIGH +from .rulebase import SEVERITY_MEDIUM +from .rulebase import is_code_line +from .rulebase import iter_added_lines +from .rulebase import make_finding + +CATEGORY = "security_risk" + +_RE_OS_SYSTEM = re.compile(r"\bos\.system\s*\(") +_RE_SHELL_TRUE = re.compile(r"\bsubprocess\.\w+\s*\(.*shell\s*=\s*True") +_RE_EVAL_EXEC = re.compile(r"(? List[Dict[str, Any]]: + findings: List[Dict[str, Any]] = [] + path = ctx.path + for lineno, content, _hunk in iter_added_lines(ctx.file_entry): + if not is_code_line(content): + continue + if _RE_OS_SYSTEM.search(content): + findings.append( + make_finding("SEC001", CATEGORY, SEVERITY_HIGH, 0.9, path, lineno, + "Command execution via os.system", content, + "Replace os.system with subprocess.run([...], shell=False) and pass " + "arguments as a list; never build shell command strings.")) + if _RE_SHELL_TRUE.search(content): + findings.append( + make_finding("SEC002", CATEGORY, SEVERITY_HIGH, 0.9, path, lineno, + "subprocess called with shell=True", content, + "Drop shell=True and pass the command as an argument list to avoid " + "shell injection.")) + if _RE_EVAL_EXEC.search(content): + findings.append( + make_finding("SEC003", CATEGORY, SEVERITY_HIGH, 0.75, path, lineno, + "Dynamic code execution via eval/exec", content, + "Avoid eval/exec on data; use ast.literal_eval, a dispatch table or an " + "explicit parser instead.")) + if _RE_PICKLE_LOADS.search(content): + findings.append( + make_finding("SEC004", CATEGORY, SEVERITY_HIGH, 0.85, path, lineno, + "Unsafe deserialization via pickle", content, + "Never unpickle untrusted data; prefer json or a schema-validated " + "format.")) + if _RE_YAML_LOAD.search(content) and "SafeLoader" not in content and "safe_load" not in content: + findings.append( + make_finding("SEC005", CATEGORY, SEVERITY_MEDIUM, 0.85, path, lineno, + "yaml.load without SafeLoader", content, + "Use yaml.safe_load(...) or pass Loader=yaml.SafeLoader.")) + if _RE_SQL_DYNAMIC.search(content): + findings.append( + make_finding("SEC006", CATEGORY, SEVERITY_CRITICAL, 0.85, path, lineno, + "SQL statement built from dynamic strings (SQL injection risk)", content, + "Use parameterized queries: cursor.execute(\"... WHERE name = %s\", " + "(name,)) instead of f-strings or string concatenation.")) + if _RE_VERIFY_FALSE.search(content): + findings.append( + make_finding("SEC008", CATEGORY, SEVERITY_HIGH, 0.9, path, lineno, + "TLS certificate verification disabled (verify=False)", content, + "Keep certificate verification on; pin an internal CA bundle via " + "verify=\"/path/ca.pem\" when needed.")) + if _RE_CMD_INJECTION.search(content): + findings.append( + make_finding("SEC009", CATEGORY, SEVERITY_CRITICAL, 0.88, path, lineno, + "Shell command built from dynamic input (command injection risk)", content, + "Never concatenate or interpolate user input into a command string; " + "pass an argv list and validate inputs.")) + if _RE_MD5_PASSWORD.search(content) and _RE_PASSWORD_WORD.search(content): + findings.append( + make_finding("SEC007", CATEGORY, SEVERITY_MEDIUM, 0.6, path, lineno, + "Possible weak password hashing with MD5", content, + "Use a password KDF such as bcrypt, scrypt or argon2 instead of MD5.")) + return findings diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/rulebase.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rulebase.py new file mode 100644 index 00000000..53fe10d4 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/rulebase.py @@ -0,0 +1,138 @@ +# 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. +"""Shared helpers and data model for the review rule modules.""" + +from __future__ import annotations + +import re +from dataclasses import dataclass +from dataclasses import field +from typing import Any +from typing import Dict +from typing import Iterator +from typing import List +from typing import Optional +from typing import Tuple + +SEVERITY_CRITICAL = "critical" +SEVERITY_HIGH = "high" +SEVERITY_MEDIUM = "medium" +SEVERITY_LOW = "low" +SEVERITY_INFO = "info" + +SOURCE_STATIC_RULE = "static_rule" + +_RE_DEF = re.compile(r"^(\s*)(async\s+)?def\s+\w+") + + +@dataclass +class RuleContext: + """Per-file context handed to every rule module.""" + + file_entry: Dict[str, Any] + content: Optional[str] = None + content_lines: List[str] = field(default_factory=list) + + @property + def path(self) -> str: + return self.file_entry.get("path", "") + + +def make_finding(rule_id: str, + category: str, + severity: str, + confidence: float, + file: str, + line: int, + title: str, + evidence: str, + recommendation: str) -> Dict[str, Any]: + """Build one finding dict with the exact schema required by the agent.""" + return { + "severity": severity, + "category": category, + "file": file, + "line": int(line or 0), + "title": title, + "evidence": evidence.strip(), + "recommendation": recommendation, + "confidence": round(float(confidence), 2), + "source": SOURCE_STATIC_RULE, + "rule_id": rule_id, + } + + +def is_code_line(content: str) -> bool: + """Skip blank lines and pure comments.""" + stripped = content.strip() + return bool(stripped) and not stripped.startswith("#") + + +def iter_added_lines(file_entry: Dict[str, Any]) -> Iterator[Tuple[int, str, Dict[str, Any]]]: + """Yield ``(new_lineno, content, hunk)`` for every added line of a file.""" + for hunk in file_entry.get("hunks", []): + for line in hunk.get("lines", []): + if line.get("tag") == "+": + yield line.get("new_lineno") or 0, line.get("content", ""), hunk + + +def hunk_added_text(hunk: Dict[str, Any]) -> str: + """All added-line contents of a hunk joined as one text block.""" + return "\n".join(line.get("content", "") for line in hunk.get("lines", []) if line.get("tag") == "+") + + +def file_added_text(file_entry: Dict[str, Any]) -> str: + """All added-line contents of a file joined as one text block.""" + return "\n".join(content for _, content, _ in iter_added_lines(file_entry)) + + +def _indent_of(line: str) -> int: + return len(line) - len(line.lstrip()) + + +def _scan_defs_backwards(lines: List[Tuple[int, str]], target_indent: int) -> Optional[bool]: + """Scan candidate lines bottom-up for the nearest enclosing ``def``. + + Args: + lines: (index, content) pairs ordered top-down; scanned in reverse. + target_indent: indent of the line whose enclosing function we seek. + + Returns: + True/False when an enclosing def was found (async or not), else None. + """ + for _, content in reversed(lines): + if not content.strip(): + continue + match = _RE_DEF.match(content) + if match and _indent_of(content) < target_indent: + return bool(match.group(2)) + return None + + +def enclosing_def_is_async(ctx: RuleContext, hunk: Dict[str, Any], new_lineno: int, line_content: str) -> bool: + """Best-effort check whether ``new_lineno`` sits inside an ``async def``. + + Prefers the full new-file content when available (repo-path / file-list + inputs); otherwise falls back to the visible hunk lines (context lines + included), which is the best a pure diff can offer. + """ + target_indent = _indent_of(line_content) + if target_indent == 0: + return False + + if ctx.content_lines and 0 < new_lineno <= len(ctx.content_lines): + above = [(i, ctx.content_lines[i]) for i in range(new_lineno - 1)] + result = _scan_defs_backwards(above, target_indent) + if result is not None: + return result + + visible: List[Tuple[int, str]] = [] + for line in hunk.get("lines", []): + lineno = line.get("new_lineno") + if line.get("tag") in ("+", " ") and lineno is not None and lineno < new_lineno: + visible.append((lineno, line.get("content", ""))) + result = _scan_defs_backwards(visible, target_indent) + return bool(result) diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/lib/secret_patterns.py b/examples/skills_code_review_agent/skills/code-review/scripts/lib/secret_patterns.py new file mode 100644 index 00000000..c898db21 --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/lib/secret_patterns.py @@ -0,0 +1,145 @@ +# 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. +"""Canonical secret pattern table (stdlib-only, shared by sandbox and host). + +This module is the single source of truth for secret detection: the sandbox +rule ``rule_secrets`` uses it to *detect* leaked credentials in diffs, and +the host-side ``codereview.redaction.SecretRedactor`` uses it to *scrub* +every string before it reaches the report or the database. +""" + +from __future__ import annotations + +import re +from typing import Any +from typing import Dict +from typing import List +from typing import Tuple + +REDACTED_PLACEHOLDER = "***REDACTED***" + +# Values that look like an assignment but are clearly not literal secrets. +_SAFE_VALUE_PREFIXES = ( + "os.environ", + "os.getenv", + "getenv(", + "getpass", + "environ[", + "env(", + "config[", + "settings.", + "none", + "null", + "true", + "false", + "${", + "{{", + "<", + "***", +) + +# Each entry: (pattern_id, regex, value_group) +# value_group is the regex group holding the secret VALUE to redact +# (0 means the whole match is the secret). +_RAW_PATTERNS: List[Tuple[str, str, int]] = [ + ("aws_access_key_id", r"\b((?:AKIA|ASIA|AGPA|AIDA|AROA|ANPA)[0-9A-Z]{16})\b", 1), + ( + "aws_secret_access_key", + r"(?i)\baws[_\-]?(?:secret[_\-]?(?:access[_\-]?)?key|secret)\b[^=:\n]{0,10}[=:]\s*[\"']?" + r"([A-Za-z0-9/+=]{30,})", + 1, + ), + ("github_token", r"\b(gh[pousr]_[A-Za-z0-9]{20,})\b", 1), + ("github_fine_grained_pat", r"\b(github_pat_[A-Za-z0-9_]{20,})\b", 1), + ("gitlab_pat", r"\b(glpat-[A-Za-z0-9_\-]{16,})\b", 1), + ("slack_token", r"\b(xox[baprs]-[A-Za-z0-9-]{10,})\b", 1), + ("openai_api_key", r"\b(sk-[A-Za-z0-9_\-]{20,})\b", 1), + ("google_api_key", r"\b(AIza[0-9A-Za-z_\-]{30,})\b", 1), + ("jwt_token", r"\b(eyJ[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{8,}\.[A-Za-z0-9_\-]{6,})", 1), + ( + "private_key_block", + r"(-----BEGIN [A-Z ]*PRIVATE KEY-----(?:(?!-----END)[\s\S]){0,4096}(?:-----END [A-Z ]*PRIVATE KEY-----)?)", + 1, + ), + ("bearer_token", r"(?i)\bbearer\s+([A-Za-z0-9._~+/\-]{16,}=*)", 1), + ("url_credentials", r"\b[a-z][a-z0-9+.\-]{1,16}://[^/\s:@\"']{1,64}:([^@/\s\"']{4,})@", 1), + ( + "generic_assignment", + # optional prefix segments allow FOO_TOKEN / "api-key" / aws.secret style keys + r"(?i)\b(?:[A-Za-z][A-Za-z0-9]*[_\-])*" + r"(?:password|passwd|pwd|secret|token|api[_\-]?key|apikey|access[_\-]?key|secret[_\-]?key|" + r"account[_\-]?key|auth[_\-]?token|client[_\-]?secret|private[_\-]?key|" + r"db[_\-]?pass(?:word)?|credentials?)\b" + r"[\"']?\s*(?:=>|:=|[:=])\s*[\"']?([^\s\"',;)}\]]{6,})", + 1, + ), +] + +SECRET_PATTERNS: List[Tuple[str, "re.Pattern[str]", int]] = [ + (pattern_id, re.compile(pattern), group) for pattern_id, pattern, group in _RAW_PATTERNS +] + + +_RE_FUNCTION_CALL_VALUE = re.compile(r"^[A-Za-z_][\w.]*\(") + + +def _is_safe_value(value: str) -> bool: + lowered = value.strip().lower() + if any(lowered.startswith(prefix) for prefix in _SAFE_VALUE_PREFIXES): + return True + # Function-call values (get_secret(...), vault.read(...)) are references, + # not literal secrets. + return bool(_RE_FUNCTION_CALL_VALUE.match(value.strip())) + + +def find_secrets(text: str) -> List[Dict[str, Any]]: + """Find secret value spans in ``text``. + + Returns a list of ``{"id", "start", "end"}`` dicts (never the secret + value itself) with overlapping spans merged. + """ + spans: List[Tuple[int, int, str]] = [] + for pattern_id, regex, group in SECRET_PATTERNS: + for match in regex.finditer(text): + start, end = match.span(group) + if start == end: + continue + if pattern_id == "generic_assignment" and _is_safe_value(match.group(group)): + continue + spans.append((start, end, pattern_id)) + spans.sort(key=lambda s: (s[0], -s[1])) + + merged: List[Dict[str, Any]] = [] + for start, end, pattern_id in spans: + if merged and start < merged[-1]["end"]: + merged[-1]["end"] = max(merged[-1]["end"], end) + continue + merged.append({"id": pattern_id, "start": start, "end": end}) + return merged + + +def contains_secret(text: str) -> bool: + """Return True when ``text`` contains at least one detectable secret.""" + return bool(find_secrets(text)) + + +def redact_text(text: str, placeholder: str = REDACTED_PLACEHOLDER) -> Tuple[str, int]: + """Replace every detected secret value in ``text`` with ``placeholder``. + + Returns: + (redacted_text, number_of_redacted_spans) + """ + spans = find_secrets(text) + if not spans: + return text, 0 + pieces: List[str] = [] + cursor = 0 + for span in spans: + pieces.append(text[cursor:span["start"]]) + pieces.append(placeholder) + cursor = span["end"] + pieces.append(text[cursor:]) + return "".join(pieces), len(spans) diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/parse_diff.py b/examples/skills_code_review_agent/skills/code-review/scripts/parse_diff.py new file mode 100644 index 00000000..4e3be44c --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/parse_diff.py @@ -0,0 +1,45 @@ +# 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. +"""Sandbox entry: parse a raw unified diff into a normalized changeset JSON. + +Usage (inside the code-review skill workspace):: + + python3 skills/code-review/scripts/parse_diff.py + +Stdlib-only; safe to run in any sandbox runtime (local / container / cube). +""" + +from __future__ import annotations + +import json +import os +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from lib.diffparse import build_diff_summary # noqa: E402 +from lib.diffparse import parse_unified_diff # noqa: E402 + + +def main(argv: list) -> int: + if len(argv) != 3: + print("usage: parse_diff.py ", file=sys.stderr) + return 2 + raw_path, out_path = argv[1], argv[2] + with open(raw_path, "r", encoding="utf-8", errors="replace") as fh: + text = fh.read() + changeset = parse_unified_diff(text) + payload = {"changeset": changeset, "summary": build_diff_summary(changeset)} + os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True) + with open(out_path, "w", encoding="utf-8") as fh: + json.dump(payload, fh, ensure_ascii=False, indent=2) + print(f"parsed {payload['summary']['file_count']} file(s), " + f"{payload['summary']['hunk_count']} hunk(s)") + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/examples/skills_code_review_agent/skills/code-review/scripts/run_checks.py b/examples/skills_code_review_agent/skills/code-review/scripts/run_checks.py new file mode 100644 index 00000000..27d87e5e --- /dev/null +++ b/examples/skills_code_review_agent/skills/code-review/scripts/run_checks.py @@ -0,0 +1,77 @@ +# 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. +"""Sandbox entry: run all review rules over a parsed changeset. + +Usage (inside the code-review skill workspace):: + + python3 skills/code-review/scripts/run_checks.py \ + [--files-dir work/inputs/files] [--force-fail] + +```` is either the ``parse_diff.py`` output (``{"changeset": ...}``) +or a bare changeset (``{"files": [...]}``). ``--files-dir`` optionally points +at a directory tree with full new-file contents for higher-accuracy checks. +``--force-fail`` deterministically raises — used by tests and the CLI flag +``--inject-sandbox-failure`` to prove that a sandbox crash never kills the +review task. Stdlib-only. +""" + +from __future__ import annotations + +import argparse +import json +import os +import sys + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from lib.engine import run_all_rules # noqa: E402 + + +def _load_changeset(path: str) -> dict: + with open(path, "r", encoding="utf-8") as fh: + payload = json.load(fh) + return payload.get("changeset", payload) + + +def _load_file_contents(files_dir: str) -> dict: + contents = {} + for root, _dirs, files in os.walk(files_dir): + for name in files: + full = os.path.join(root, name) + rel = os.path.relpath(full, files_dir).replace(os.sep, "/") + try: + with open(full, "r", encoding="utf-8", errors="replace") as fh: + contents[rel] = fh.read() + except OSError: + continue + return contents + + +def main(argv: list) -> int: + parser = argparse.ArgumentParser(description="Run code-review rules over a parsed changeset.") + parser.add_argument("diff_json", help="parsed changeset JSON (parse_diff.py output)") + parser.add_argument("out_json", help="findings output path") + parser.add_argument("--files-dir", default="", help="optional dir with full new-file contents") + parser.add_argument("--force-fail", action="store_true", + help="raise deterministically (sandbox-failure test injection)") + args = parser.parse_args(argv[1:]) + + if args.force_fail: + raise RuntimeError("forced sandbox failure (test injection)") + + changeset = _load_changeset(args.diff_json) + file_contents = _load_file_contents(args.files_dir) if args.files_dir else {} + findings = run_all_rules(changeset, file_contents) + + os.makedirs(os.path.dirname(os.path.abspath(args.out_json)), exist_ok=True) + with open(args.out_json, "w", encoding="utf-8") as fh: + json.dump({"findings": findings}, fh, ensure_ascii=False, indent=2) + print(f"emitted {len(findings)} finding(s)") + return 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) diff --git a/examples/skills_code_review_agent/tests/__init__.py b/examples/skills_code_review_agent/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/examples/skills_code_review_agent/tests/helpers.py b/examples/skills_code_review_agent/tests/helpers.py new file mode 100644 index 00000000..9b3e72c8 --- /dev/null +++ b/examples/skills_code_review_agent/tests/helpers.py @@ -0,0 +1,76 @@ +# 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. +"""Shared test helpers: run the FULL pipeline on a fixture, return everything.""" + +from __future__ import annotations + +import json +import os +from dataclasses import dataclass +from typing import Any +from typing import Dict +from typing import Optional + +from codereview.config import ReviewConfig +from codereview.config import SandboxConfig +from codereview.inputs import from_fixture +from codereview.pipeline import ReviewPipeline +from codereview.pipeline import ReviewResult +from codereview.store import SqlReviewStore + + +@dataclass +class FixtureRun: + result: ReviewResult + report: Dict[str, Any] + report_md: str + store: SqlReviewStore + db_path: str + + +async def run_fixture(name: str, tmp_path, *, force_fail: bool = False, + timeout_sec: float = 30.0, max_output_bytes: int = 64_000, + model_mode: str = "fake", + config: Optional[ReviewConfig] = None) -> FixtureRun: + """Run the whole pipeline (local sandbox, sqlite in tmp_path) on a fixture. + + Caller MUST ``await run.store.close()`` when done (or use ``finally``). + """ + db_path = os.path.join(str(tmp_path), "review.db") + out_dir = os.path.join(str(tmp_path), "out") + if config is None: + config = ReviewConfig( + db_url=f"sqlite+aiosqlite:///{db_path}", + out_dir=out_dir, + model_mode=model_mode, + sandbox=SandboxConfig( + runtime_kind="local", + timeout_sec=timeout_sec, + max_output_bytes=max_output_bytes, + work_root=os.path.join(str(tmp_path), "ws"), + force_fail=force_fail, + ), + ) + store = SqlReviewStore(config.db_url) + await store.initialize() + try: + result = await ReviewPipeline(store, config).run(from_fixture(name)) + except Exception: + await store.close() + raise + with open(result.report_paths["json"], "r", encoding="utf-8") as fh: + report = json.load(fh) + with open(result.report_paths["markdown"], "r", encoding="utf-8") as fh: + report_md = fh.read() + return FixtureRun(result=result, report=report, report_md=report_md, + store=store, db_path=db_path) + + +def findings_by_category(report: Dict[str, Any], bucket: str = "findings") -> Dict[str, list]: + grouped: Dict[str, list] = {} + for finding in report.get(bucket, []): + grouped.setdefault(finding["category"], []).append(finding) + return grouped diff --git a/examples/skills_code_review_agent/tests/test_cli_and_report.py b/examples/skills_code_review_agent/tests/test_cli_and_report.py new file mode 100644 index 00000000..9ec0cc96 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_cli_and_report.py @@ -0,0 +1,157 @@ +# 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. +"""CLI (in-process) + report document/markdown structure (acceptance criterion 8).""" + +import json +import os + +import run_agent + +from .helpers import run_fixture + +MD_SECTIONS = ( + "## Findings 摘要", + "## 严重级别统计 Severity Stats", + "## 人工复核项 Needs Human Review", + "## Filter 拦截摘要 Filter Blocks", + "## 监控指标 Metrics", + "## 沙箱执行摘要 Sandbox Runs", + "## 修复建议 Recommendations", +) + + +async def test_report_sections_complete(tmp_path): + run = await run_fixture("security_issue", tmp_path) + try: + for section in MD_SECTIONS: + assert section in run.report_md, section + # actionable recommendations present and non-empty + assert run.report["recommendations"] + for rec in run.report["recommendations"]: + assert rec["recommendation"].strip() + assert rec["file"] and rec["severity"] + # severity stats cover every level + assert set(run.report["severity_stats"]) == {"critical", "high", "medium", "low", "info"} + # internal bookkeeping keys (e.g. _persisted) must not leak into the + # public report document + for event in run.report["filter_summary"]["events"]: + assert not any(key.startswith("_") for key in event), event + finally: + await run.store.close() + + +def test_cli_review_show_list_init_db(tmp_path, capsys, monkeypatch): + """Full CLI loop in-process: init-db → review → show → list.""" + monkeypatch.chdir(tmp_path) + db_url = f"sqlite+aiosqlite:///{tmp_path}/cli.db" + out_dir = str(tmp_path / "out") + + assert run_agent.main(["init-db", "--db-url", db_url]) == 0 + init_output = capsys.readouterr().out + assert "cr_review_task" in init_output + + assert run_agent.main(["review", "--fixture", "duplicate_finding", "--dry-run", + "--db-url", db_url, "--out-dir", out_dir]) == 0 + review_output = capsys.readouterr().out + assert "task id" in review_output + task_id = review_output.split("task id :")[1].splitlines()[0].strip() + assert os.path.isfile(os.path.join(out_dir, "review_report.json")) + assert os.path.isfile(os.path.join(out_dir, "review_report.md")) + + assert run_agent.main(["show", "--task-id", task_id, "--db-url", db_url]) == 0 + bundle = json.loads(capsys.readouterr().out) + assert bundle["task"]["id"] == task_id + assert bundle["report"]["report"]["task_id"] == task_id + assert bundle["sandbox_runs"] and bundle["findings"] + + assert run_agent.main(["list", "--db-url", db_url]) == 0 + assert task_id in capsys.readouterr().out + + # unknown task id → clean nonzero exit + assert run_agent.main(["show", "--task-id", "nope", "--db-url", db_url]) == 1 + + +def test_cli_default_db_path_shared_across_subcommands(tmp_path, capsys, monkeypatch): + """Fresh-checkout quick start: all subcommands share out/review.db by default. + + Regression: ``review`` defaulted its sqlite DB to out/review.db but never + created the out dir (crash on a fresh checkout), while ``show``/``list`` + defaulted to ./review.db — so the documented review → show workflow + reported "task not found" without an explicit --db-url.""" + monkeypatch.chdir(tmp_path) + + assert run_agent.main(["review", "--fixture", "security_issue", "--dry-run"]) == 0 + review_output = capsys.readouterr().out + task_id = review_output.split("task id :")[1].splitlines()[0].strip() + assert os.path.isfile(tmp_path / "out" / "review.db") + + assert run_agent.main(["show", "--task-id", task_id]) == 0 + bundle = json.loads(capsys.readouterr().out) + assert bundle["task"]["id"] == task_id + + assert run_agent.main(["list"]) == 0 + assert task_id in capsys.readouterr().out + + +def test_cli_inject_sandbox_failure(tmp_path, capsys, monkeypatch): + monkeypatch.chdir(tmp_path) + db_url = f"sqlite+aiosqlite:///{tmp_path}/cli2.db" + assert run_agent.main(["review", "--fixture", "sandbox_failure", "--dry-run", + "--inject-sandbox-failure", "--db-url", db_url, + "--out-dir", str(tmp_path / "out2")]) == 0 + output = capsys.readouterr().out + assert "completed_with_errors" in output + + +def test_cli_diff_file_input(tmp_path, capsys, monkeypatch): + monkeypatch.chdir(tmp_path) + diff_path = tmp_path / "change.diff" + diff_path.write_text( + "diff --git a/svc.py b/svc.py\n" + "new file mode 100644\n" + "--- /dev/null\n" + "+++ b/svc.py\n" + "@@ -0,0 +1,2 @@\n" + "+import os\n" + "+os.system('reboot')\n", + encoding="utf-8") + assert run_agent.main(["review", "--diff-file", str(diff_path), "--dry-run", + "--db-url", f"sqlite+aiosqlite:///{tmp_path}/cli3.db", + "--out-dir", str(tmp_path / "out3")]) == 0 + with open(tmp_path / "out3" / "review_report.json", encoding="utf-8") as fh: + report = json.load(fh) + assert any(finding["category"] == "security_risk" for finding in report["findings"]) + + +def test_cli_input_errors_exit_cleanly(tmp_path, capsys, monkeypatch): + """Bad inputs → clean message on stderr + exit code 2 (no traceback).""" + monkeypatch.chdir(tmp_path) + db_url = f"sqlite+aiosqlite:///{tmp_path}/err.db" + + assert run_agent.main(["review", "--fixture", "no_such_fixture", "--dry-run", + "--db-url", db_url]) == 2 + err = capsys.readouterr().err + assert "unknown fixture" in err and "available:" in err + + assert run_agent.main(["review", "--diff-file", "missing.diff", "--dry-run", + "--db-url", db_url]) == 2 + assert "input error" in capsys.readouterr().err + + assert run_agent.main(["review", "--repo-path", str(tmp_path), "--dry-run", + "--db-url", db_url]) == 2 + assert "not a git repository" in capsys.readouterr().err + + +async def test_report_json_is_valid_and_findings_sorted_by_severity(tmp_path): + run = await run_fixture("security_issue", tmp_path) + try: + with open(run.result.report_paths["json"], encoding="utf-8") as fh: + document = json.load(fh) + ranks = {"critical": 4, "high": 3, "medium": 2, "low": 1, "info": 0} + rec_ranks = [ranks[rec["severity"]] for rec in document["recommendations"]] + assert rec_ranks == sorted(rec_ranks, reverse=True) + finally: + await run.store.close() diff --git a/examples/skills_code_review_agent/tests/test_dedup_noise.py b/examples/skills_code_review_agent/tests/test_dedup_noise.py new file mode 100644 index 00000000..9c246937 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_dedup_noise.py @@ -0,0 +1,64 @@ +# 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. +"""Dedup + noise control (issue requirement 6).""" + +from codereview.findings import Finding +from codereview.findings import dedup_findings +from codereview.findings import severity_distribution +from codereview.findings import split_noise + + +def _finding(**overrides) -> Finding: + base = dict(severity="high", category="security_risk", file="a.py", line=10, + title="t", evidence="e", recommendation="r", confidence=0.9, + source="static_rule", rule_id="SEC001") + base.update(overrides) + return Finding(**base) + + +def test_same_file_line_category_reported_once(): + first = _finding(rule_id="SEC001", severity="high", confidence=0.9) + second = _finding(rule_id="SEC009", severity="critical", confidence=0.88) + kept, removed = dedup_findings([first, second]) + assert len(kept) == 1 and removed == 1 + # highest severity wins; the losing rule id is preserved + assert kept[0].rule_id == "SEC009" + assert kept[0].severity == "critical" + assert kept[0].extra["also_matched"] == ["SEC001"] + + +def test_different_line_or_category_not_deduped(): + items = [ + _finding(line=10), + _finding(line=11), + _finding(line=10, category="resource_leak", rule_id="RES001"), + _finding(line=10, file="b.py"), + ] + kept, removed = dedup_findings(items) + assert len(kept) == 4 and removed == 0 + + +def test_dedup_keeps_higher_confidence_within_same_severity(): + low = _finding(rule_id="SEC003", confidence=0.75) + high = _finding(rule_id="SEC001", confidence=0.9) + kept, _ = dedup_findings([low, high]) + assert kept[0].rule_id == "SEC001" + + +def test_low_confidence_never_mixes_into_findings(): + confident = _finding(confidence=0.9) + borderline = _finding(line=20, confidence=0.7) + noisy = _finding(line=30, confidence=0.5) + findings, needs_review = split_noise([confident, borderline, noisy], min_confidence=0.7) + assert {finding.line for finding in findings} == {10, 20} + assert {finding.line for finding in needs_review} == {30} + assert all(finding.confidence >= 0.7 for finding in findings) + assert all(finding.confidence < 0.7 for finding in needs_review) + + +def test_severity_distribution_counts_all_levels(): + dist = severity_distribution([_finding(), _finding(line=11, severity="critical")]) + assert dist == {"critical": 1, "high": 1, "medium": 0, "low": 0, "info": 0} diff --git a/examples/skills_code_review_agent/tests/test_diff_parser.py b/examples/skills_code_review_agent/tests/test_diff_parser.py new file mode 100644 index 00000000..def34cc7 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_diff_parser.py @@ -0,0 +1,163 @@ +# 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. +"""Input parsing (issue requirement 3): diff text, file lists, git workspaces.""" + +import os +import shutil +import subprocess + +import pytest + +from codereview.diff_parser import build_diff_summary +from codereview.diff_parser import parse_unified_diff +from codereview.inputs import from_file_list +from codereview.inputs import from_repo_path + +MULTI_FILE_DIFF = """\ +diff --git a/pkg/alpha.py b/pkg/alpha.py +index 000001..000002 100644 +--- a/pkg/alpha.py ++++ b/pkg/alpha.py +@@ -10,7 +10,8 @@ def existing(): + context_line_1 +-removed_line ++added_line_one ++added_line_two + context_line_2 +@@ -30,3 +31,4 @@ def later(): + tail_context ++tail_added + more_context +diff --git a/pkg/new_module.py b/pkg/new_module.py +new file mode 100644 +index 0000000..1111111 +--- /dev/null ++++ b/pkg/new_module.py +@@ -0,0 +1,2 @@ ++first = 1 ++second = 2 +diff --git a/pkg/gone.py b/pkg/gone.py +deleted file mode 100644 +index 2222222..0000000 +--- a/pkg/gone.py ++++ /dev/null +@@ -1,2 +0,0 @@ +-old_one +-old_two +diff --git a/pkg/old_name.py b/pkg/renamed.py +similarity index 90% +rename from pkg/old_name.py +rename to pkg/renamed.py +index 3333333..4444444 100644 +--- a/pkg/old_name.py ++++ b/pkg/renamed.py +@@ -1,2 +1,3 @@ + keep ++renamed_added + keep_too +""" + + +def test_multi_file_parse(): + changeset = parse_unified_diff(MULTI_FILE_DIFF) + files = {entry["path"]: entry for entry in changeset["files"]} + assert set(files) == {"pkg/alpha.py", "pkg/new_module.py", "pkg/gone.py", "pkg/renamed.py"} + assert files["pkg/alpha.py"]["status"] == "modified" + assert files["pkg/new_module.py"]["status"] == "added" + assert files["pkg/gone.py"]["status"] == "deleted" + assert files["pkg/renamed.py"]["status"] == "renamed" + assert files["pkg/renamed.py"]["old_path"] == "pkg/old_name.py" + + +def test_hunk_line_numbering_and_context(): + changeset = parse_unified_diff(MULTI_FILE_DIFF) + alpha = next(entry for entry in changeset["files"] if entry["path"] == "pkg/alpha.py") + assert len(alpha["hunks"]) == 2 + + first = alpha["hunks"][0] + assert first["old_start"] == 10 and first["new_start"] == 10 + tags = [line["tag"] for line in first["lines"]] + assert tags == [" ", "-", "+", "+", " "] + # candidate (added) line numbers must be exact new-file line numbers + assert [line["line"] for line in alpha["added_lines"]] == [11, 12, 32] + assert [line["content"] for line in alpha["added_lines"]] == [ + "added_line_one", "added_line_two", "tail_added", + ] + # removed lines carry old-file numbers + assert alpha["removed_lines"][0]["line"] == 11 + # context lines keep both counters aligned + context = first["lines"][-1] + assert context["tag"] == " " and context["old_lineno"] == 12 and context["new_lineno"] == 13 + + +def test_plain_diff_without_git_header(): + plain = ("--- a/tool.py\n" + "+++ b/tool.py\n" + "@@ -1,2 +1,3 @@\n" + " import sys\n" + "+import os\n" + " print(1)\n") + changeset = parse_unified_diff(plain) + assert len(changeset["files"]) == 1 + assert changeset["files"][0]["path"] == "tool.py" + assert changeset["files"][0]["added_lines"] == [{"line": 2, "content": "import os"}] + + +def test_binary_file_flagged(): + diff = ("diff --git a/logo.png b/logo.png\n" + "index 1111111..2222222 100644\n" + "Binary files a/logo.png and b/logo.png differ\n") + changeset = parse_unified_diff(diff) + assert changeset["files"][0]["is_binary"] is True + + +def test_diff_summary_is_content_free(): + changeset = parse_unified_diff(MULTI_FILE_DIFF) + summary = build_diff_summary(changeset) + assert summary["file_count"] == 4 + assert summary["added_line_count"] == 6 + assert summary["removed_line_count"] == 3 + alpha = next(entry for entry in summary["files"] if entry["path"] == "pkg/alpha.py") + assert alpha["candidate_lines"] == [11, 12, 32] + # No raw line content may leak into the summary (it is stored in the DB). + assert "added_line_one" not in str(summary) + + +def test_file_list_input(tmp_path): + target = tmp_path / "svc.py" + target.write_text("import os\nos.system('ls')\n", encoding="utf-8") + changeset = from_file_list([str(target)], base_dir=str(tmp_path)) + parsed = parse_unified_diff(changeset.unified_diff_text) + assert parsed["files"][0]["path"] == "svc.py" + assert parsed["files"][0]["status"] == "added" + assert changeset.file_contents["svc.py"].startswith("import os") + + +@pytest.mark.skipif(shutil.which("git") is None, reason="git not installed") +def test_git_repo_input(tmp_path): + repo = tmp_path / "repo" + repo.mkdir() + env = {**os.environ, "GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", + "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t"} + + def git(*args): + subprocess.run(["git", "-C", str(repo), *args], check=True, env=env, + capture_output=True) + + git("init", "-q") + (repo / "main.py").write_text("print('v1')\n", encoding="utf-8") + git("add", ".") + git("commit", "-qm", "init") + # tracked modification + untracked new file + (repo / "main.py").write_text("print('v2')\nvalue = 3\n", encoding="utf-8") + (repo / "extra.py").write_text("extra = True\n", encoding="utf-8") + + changeset = from_repo_path(str(repo)) + parsed = parse_unified_diff(changeset.unified_diff_text) + paths = {entry["path"] for entry in parsed["files"]} + assert paths == {"main.py", "extra.py"} + assert changeset.file_contents["main.py"].startswith("print('v2')") + assert changeset.file_contents["extra.py"] == "extra = True\n" diff --git a/examples/skills_code_review_agent/tests/test_fixtures_e2e.py b/examples/skills_code_review_agent/tests/test_fixtures_e2e.py new file mode 100644 index 00000000..99ca94f1 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_fixtures_e2e.py @@ -0,0 +1,204 @@ +# 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. +"""End-to-end pipeline over ALL 8 committed fixtures (acceptance criterion 1).""" + +import os +import time + +import pytest + +from .helpers import findings_by_category +from .helpers import run_fixture + +ALL_FIXTURES = [ + "clean", + "security_issue", + "async_resource_leak", + "db_connection_lifecycle", + "missing_tests", + "duplicate_finding", + "sandbox_failure", + "secret_redaction", +] + +REPORT_KEYS = ("task_id", "created_at", "input", "status", "summary", "findings", + "needs_human_review", "severity_stats", "filter_summary", + "sandbox_summary", "metrics", "recommendations") + +METRIC_KEYS = ("total_duration_ms", "sandbox_duration_ms", "sandbox_run_count", + "tool_call_count", "llm_call_count", "filter_block_count", + "filter_decisions", "finding_count", "needs_human_review_count", + "deduplicated_count", "redaction_count", "severity_distribution", + "error_types") + + +@pytest.mark.parametrize("fixture_name", ALL_FIXTURES) +async def test_every_fixture_runs_and_reports(fixture_name, tmp_path): + run = await run_fixture(fixture_name, tmp_path, + force_fail=(fixture_name == "sandbox_failure")) + try: + # report files rendered + assert os.path.isfile(run.result.report_paths["json"]) + assert os.path.isfile(run.result.report_paths["markdown"]) + # full document shape + for key in REPORT_KEYS: + assert key in run.report, key + for key in METRIC_KEYS: + assert key in run.report["metrics"], key + # DB is complete and queryable by task id (acceptance criterion 3) + bundle = await run.store.get_task_bundle(run.result.task_id) + assert bundle["task"]["status"] in ("completed", "completed_with_errors") + assert bundle["report"] is not None + assert len(bundle["sandbox_runs"]) >= 1 + db_findings = [row for row in bundle["findings"] if row["bucket"] == "finding"] + assert len(db_findings) == len(run.report["findings"]) + # every finding carries the full required schema + for finding in run.report["findings"]: + for key in ("severity", "category", "file", "line", "title", "evidence", + "recommendation", "confidence", "source"): + assert key in finding, (fixture_name, key) + assert finding["recommendation"].strip() + finally: + await run.store.close() + + +async def test_clean_fixture_yields_zero_findings(tmp_path): + run = await run_fixture("clean", tmp_path) + try: + assert run.report["findings"] == [] + assert run.report["needs_human_review"] == [] + assert run.result.status == "completed" + finally: + await run.store.close() + + +async def test_security_fixture_detects_high_risk(tmp_path): + run = await run_fixture("security_issue", tmp_path) + try: + categories = findings_by_category(run.report) + security = categories.get("security_risk", []) + assert any(finding["severity"] in ("critical", "high") for finding in security) + rule_ids = {finding.get("rule_id") for finding in security} + assert "SEC006" in rule_ids # f-string SQL injection + finally: + await run.store.close() + + +async def test_async_resource_leak_fixture(tmp_path): + run = await run_fixture("async_resource_leak", tmp_path) + try: + all_items = run.report["findings"] + run.report["needs_human_review"] + categories = {item["category"] for item in all_items} + assert "async_error" in categories + assert "resource_leak" in categories + # high-confidence async finding stays in findings + assert any(item["category"] == "async_error" for item in run.report["findings"]) + # the open()-without-with heuristic (conf 0.65) must sit in human review + assert any(item["category"] == "resource_leak" and item["rule_id"] == "RES001" + for item in run.report["needs_human_review"]) + finally: + await run.store.close() + + +async def test_db_lifecycle_fixture(tmp_path): + run = await run_fixture("db_connection_lifecycle", tmp_path) + try: + db_findings = findings_by_category(run.report).get("db_lifecycle", []) + rule_ids = {finding["rule_id"] for finding in db_findings} + assert "DBL001" in rule_ids # connect without close + assert "DBL003" in rule_ids # BEGIN without commit/rollback + finally: + await run.store.close() + + +async def test_missing_tests_fixture(tmp_path): + run = await run_fixture("missing_tests", tmp_path) + try: + assert findings_by_category(run.report).get("missing_tests") + finally: + await run.store.close() + + +async def test_duplicate_finding_fixture_dedups(tmp_path): + run = await run_fixture("duplicate_finding", tmp_path) + try: + # os.system("..." + var) triggers SEC001 AND SEC009 on the same line — + # exactly one survives (same file+line+category), the merge is recorded. + security = findings_by_category(run.report).get("security_risk", []) + assert len(security) == 1 + assert run.report["metrics"]["deduplicated_count"] >= 1 + keys = [(finding["file"], finding["line"], finding["category"]) + for finding in run.report["findings"]] + assert len(keys) == len(set(keys)) + finally: + await run.store.close() + + +async def test_sandbox_failure_fixture_survives(tmp_path): + run = await run_fixture("sandbox_failure", tmp_path, force_fail=True) + try: + assert run.result.status == "completed_with_errors" + runs = await run.store.get_sandbox_runs(run.result.task_id) + assert runs[0]["status"] == "failed" + assert runs[0]["error_type"] == "SandboxNonZeroExit" + # host fallback still produced a report (fixture is clean → 0 findings) + assert os.path.isfile(run.result.report_paths["json"]) + assert run.report["sandbox_summary"]["runs"][0]["status"] == "failed" + assert run.report["metrics"]["error_types"].get("SandboxNonZeroExit") == 1 + finally: + await run.store.close() + + +async def test_secret_redaction_fixture_no_plaintext_anywhere(tmp_path): + run = await run_fixture("secret_redaction", tmp_path) + try: + secrets = findings_by_category(run.report).get("secret_leakage", []) + assert len(secrets) >= 15 # ≥20 seeded, ≥15 distinct (file,line) after dedup + + seeded_values = [ + "AKIAIOSFODNN7EXAMPLE", + "wJalrXUtnFEMIK7MDENGbPxRfiCYEXAMPLEKEY99", + "ghp_FAKE1234567890abcdefFAKE1234567890", + "xoxb-7777777-8888888-FAKEfakeFAKE", + "sk-FAKEfakeFAKEfakeFAKEfakeFAKE1234", + "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJmYWtlLXVzZXIifQ", + "FAKEbearerTOKENfakeBEARER1234567890", + "sup3rSecretDbPass", + "hunter2butlonger99", + "topSecretValue4242", + "plainTokenValue31337", + "clientSecretValue0004", + "dbPasswordValue0006", + "MIIFAKEKEYBODYnotARealKeyMIIFAKE", + ] + # neither the JSON report, the MD report nor the raw DB file may + # contain any seeded plaintext value (acceptance criterion 5) + report_text = str(run.report) + run.report_md + with open(run.db_path, "rb") as fh: + db_bytes = fh.read() + for value in seeded_values: + assert value not in report_text, f"secret leaked into report: {value}" + assert value.encode() not in db_bytes, f"secret leaked into DB: {value}" + assert run.report["metrics"]["redaction_count"] >= 0 # counter exposed + finally: + await run.store.close() + + +async def test_dry_run_speed_and_no_api_key(tmp_path, monkeypatch): + """Acceptance criterion 6: full offline run without any API key in ≤2 min.""" + for var in ("TRPC_AGENT_API_KEY", "TRPC_AGENT_BASE_URL", "TRPC_AGENT_MODEL_NAME", + "OPENAI_API_KEY"): + monkeypatch.delenv(var, raising=False) + started = time.perf_counter() + run = await run_fixture("security_issue", tmp_path, model_mode="fake") + try: + elapsed = time.perf_counter() - started + assert elapsed < 120, f"dry-run took {elapsed:.1f}s" + assert run.result.status == "completed" + assert run.report["summary"] # fake model produced a real summary + assert run.report["metrics"]["llm_call_count"] == 1 + finally: + await run.store.close() diff --git a/examples/skills_code_review_agent/tests/test_governance_filter.py b/examples/skills_code_review_agent/tests/test_governance_filter.py new file mode 100644 index 00000000..9fad39da --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_governance_filter.py @@ -0,0 +1,201 @@ +# 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. +"""Filter governance (issue requirement 8, acceptance criterion 7): +deny / needs_human_review MUST prevent sandbox execution.""" + +import pytest + +from codereview.config import PolicyConfig +from codereview.governance import ACTION_ALLOW +from codereview.governance import ACTION_DENY +from codereview.governance import ACTION_NEEDS_HUMAN_REVIEW +from codereview.governance import PolicyDecision +from codereview.governance import SandboxGovernanceFilter +from codereview.governance import SandboxRunRequest +from codereview.governance import gated_sandbox_run + + +class Recorder: + def __init__(self): + self.decisions = [] + self.handler_called = False + + def on_decision(self, req, decision): + self.decisions.append((req, decision)) + + async def handler(self): + self.handler_called = True + return "SANDBOX_RAN" + + +def _request(**overrides) -> SandboxRunRequest: + base = dict(kind="static_checks", cmd="python3", + args=["skills/code-review/scripts/run_checks.py"], + script_host_path="", wants_network=False, est_timeout=10.0, + run_index=0, total_sandbox_seconds=0.0) + base.update(overrides) + return SandboxRunRequest(**base) + + +@pytest.fixture +def recorder(): + return Recorder() + + +@pytest.fixture +def policy(): + return PolicyConfig() + + +async def test_allowed_run_reaches_handler(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + result = await gated_sandbox_run(_request(), governance, recorder.handler) + assert result == "SANDBOX_RAN" + assert recorder.handler_called + assert recorder.decisions[-1][1].action == ACTION_ALLOW + + +async def test_risky_script_needs_human_review_and_never_executes(tmp_path, recorder, policy): + risky = tmp_path / "danger.py" + risky.write_text("import os\nos.system('rm -rf /')\n", encoding="utf-8") + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + result = await gated_sandbox_run(_request(script_host_path=str(risky)), + governance, recorder.handler) + assert isinstance(result, PolicyDecision) + assert result.action == ACTION_NEEDS_HUMAN_REVIEW + assert result.rule == "risky_script" + assert "rm_rf" in result.reasons[0] + assert recorder.handler_called is False # the sandbox never ran + + +async def test_network_fetching_script_flagged(tmp_path, recorder, policy): + fetcher = tmp_path / "fetch.py" + fetcher.write_text("import urllib.request\nurllib.request.urlopen('https://evil.example')\n", + encoding="utf-8") + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + result = await gated_sandbox_run(_request(script_host_path=str(fetcher)), + governance, recorder.handler) + assert isinstance(result, PolicyDecision) + assert result.action == ACTION_NEEDS_HUMAN_REVIEW + assert not recorder.handler_called + + +async def test_non_whitelisted_command_denied(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + result = await gated_sandbox_run(_request(cmd="bash", args=["-c", "echo hi"]), + governance, recorder.handler) + assert isinstance(result, PolicyDecision) + assert result.action == ACTION_DENY + assert result.rule == "allowed_cmds" + assert not recorder.handler_called + + +async def test_forbidden_path_denied(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + for bad_arg in ("/etc/passwd", "../outside.py", "~/secrets.txt", "/var/run/docker.sock"): + recorder.handler_called = False + result = await gated_sandbox_run(_request(args=[bad_arg]), governance, recorder.handler) + assert isinstance(result, PolicyDecision), bad_arg + assert result.action == ACTION_DENY, bad_arg + assert result.rule == "forbidden_paths", bad_arg + assert not recorder.handler_called + + +async def test_network_request_denied_when_not_whitelisted(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + result = await gated_sandbox_run(_request(wants_network=True), governance, recorder.handler) + assert isinstance(result, PolicyDecision) + assert result.action == ACTION_DENY + assert result.rule == "network_whitelist" + assert not recorder.handler_called + + +async def test_over_budget_needs_human_review(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + + over_runs = await gated_sandbox_run(_request(run_index=policy.max_sandbox_runs), + governance, recorder.handler) + assert isinstance(over_runs, PolicyDecision) + assert over_runs.action == ACTION_NEEDS_HUMAN_REVIEW + assert over_runs.rule == "run_budget" + + over_time = await gated_sandbox_run( + _request(total_sandbox_seconds=policy.max_total_sandbox_seconds, est_timeout=1.0), + governance, recorder.handler) + assert isinstance(over_time, PolicyDecision) + assert over_time.action == ACTION_NEEDS_HUMAN_REVIEW + assert over_time.rule == "time_budget" + assert not recorder.handler_called + + +async def test_every_decision_recorded_with_reasons(recorder, policy): + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + await gated_sandbox_run(_request(), governance, recorder.handler) + await gated_sandbox_run(_request(cmd="bash"), governance, recorder.handler) + actions = [decision.action for _req, decision in recorder.decisions] + assert actions == [ACTION_ALLOW, ACTION_DENY] + denied = recorder.decisions[-1][1] + assert denied.reasons and "bash" in denied.reasons[0] + + +async def test_pipeline_records_block_in_report_and_db(tmp_path): + """E2E: a deny decision is written to the report AND the database, the + sandbox never runs, and the review still completes via host fallback.""" + from codereview.config import ReviewConfig + from codereview.config import SandboxConfig + from .helpers import run_fixture + + config = ReviewConfig( + db_url=f"sqlite+aiosqlite:///{tmp_path}/review.db", + out_dir=str(tmp_path / "out"), + model_mode="fake", + sandbox=SandboxConfig(runtime_kind="local", work_root=str(tmp_path / "ws")), + policy=PolicyConfig(allowed_cmds=("nothing-allowed",)), # forces deny + ) + run = await run_fixture("security_issue", tmp_path, config=config) + try: + assert run.result.status == "completed_with_errors" + # block visible in metrics + report filter summary, with reasons + assert run.report["metrics"]["filter_block_count"] == 1 + assert run.report["filter_summary"]["blocked"] == 1 + event = run.report["filter_summary"]["events"][0] + assert event["action"] == ACTION_DENY + assert event["rule"] == "allowed_cmds" + assert event["reasons"] + # the sandbox never executed: run row is blocked, run count stays 0 + assert run.report["sandbox_summary"]["runs"][0]["status"] == "blocked" + assert run.report["metrics"]["sandbox_run_count"] == 0 + # host fallback still reviewed the diff (review must not die) + assert run.report["findings"] + # the same records are queryable from the DB by task id + events = await run.store.get_filter_events(run.result.task_id) + assert events and events[0]["action"] == ACTION_DENY and events[0]["reasons"] + runs = await run.store.get_sandbox_runs(run.result.task_id) + assert runs[0]["status"] == "blocked" + assert runs[0]["filter_action"] == ACTION_DENY + # the gate saw (and vetoed) the COMPLETE sandbox argv, not just the + # entry script — diff input and findings output args included + assert "work/inputs/diff.json" in runs[0]["args"] + assert "out/findings.json" in runs[0]["args"] + # markdown报告展示拦截表格 + assert "**deny**" in run.report_md + finally: + await run.store.close() + + +async def test_own_skill_scripts_pass_the_gate(policy): + """The shipped run_checks.py/parse_diff.py must themselves be clean.""" + from codereview.config import SKILL_NAME + from codereview.config import SKILLS_ROOT + import os + recorder = Recorder() + governance = SandboxGovernanceFilter(policy, on_decision=recorder.on_decision) + for script in ("run_checks.py", "parse_diff.py"): + recorder.handler_called = False + path = os.path.join(SKILLS_ROOT, SKILL_NAME, "scripts", script) + result = await gated_sandbox_run(_request(script_host_path=path), + governance, recorder.handler) + assert result == "SANDBOX_RAN", f"{script} was blocked: {result}" diff --git a/examples/skills_code_review_agent/tests/test_redaction.py b/examples/skills_code_review_agent/tests/test_redaction.py new file mode 100644 index 00000000..75ddb8aa --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_redaction.py @@ -0,0 +1,118 @@ +# 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. +"""Secret redaction (issue requirement 7, acceptance criterion 5: ≥95%).""" + +from codereview.redaction import REDACTED_PLACEHOLDER +from codereview.redaction import SecretRedactor + +# 48 secret-bearing samples: (text, plaintext_value_that_must_disappear) +SECRET_SAMPLES = [ + ("aws key AKIAIOSFODNN7EXAMPLE in code", "AKIAIOSFODNN7EXAMPLE"), + ("id = 'ASIAJEXAMPLEKEY12345'", "ASIAJEXAMPLEKEY12345"), + ("aws_secret_access_key = wJalrXUtnFEMIK7MDENGbPxRfiCYEXAMPLEKEY99", + "wJalrXUtnFEMIK7MDENGbPxRfiCYEXAMPLEKEY99"), + ("AWS_SECRET_KEY: 'abcdefghijklmnopqrstuvwxyz012345'", "abcdefghijklmnopqrstuvwxyz012345"), + ("token ghp_FAKE1234567890abcdefFAKE1234567890", "ghp_FAKE1234567890abcdefFAKE1234567890"), + ("gho_FAKEabcdef1234567890FAKEabcdef12", "gho_FAKEabcdef1234567890FAKEabcdef12"), + ("ghs_SERVICEfake1234567890abcdef99", "ghs_SERVICEfake1234567890abcdef99"), + ("slack: xoxb-7777777-8888888-FAKEfakeFAKE", "xoxb-7777777-8888888-FAKEfakeFAKE"), + ("xoxp-111111-222222-333333-abcdef", "xoxp-111111-222222-333333-abcdef"), + ("openai sk-FAKEfakeFAKEfakeFAKEfake1234", "sk-FAKEfakeFAKEfakeFAKEfake1234"), + ("sk-proj-FAKE1234567890fakeFAKE1234", "sk-proj-FAKE1234567890fakeFAKE1234"), + ("google AIzaFAKEfake_FAKE1234567890abcdefgHIJ", "AIzaFAKEfake_FAKE1234567890abcdefgHIJ"), + ("jwt eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJmYWtlIn0.FAKEsigFAKEsig", + "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJmYWtlIn0.FAKEsigFAKEsig"), + ("Authorization: Bearer FAKEbearerTOKENfake1234567890", "FAKEbearerTOKENfake1234567890"), + ("-----BEGIN RSA PRIVATE KEY----- MIIFAKE -----END RSA PRIVATE KEY-----", "MIIFAKE"), + ("-----BEGIN EC PRIVATE KEY-----", "BEGIN EC PRIVATE KEY"), + ("postgres://svc:sup3rSecretDbPass@db:5432/prod", "sup3rSecretDbPass"), + ("mysql://root:rootpw12345@localhost/app", "rootpw12345"), + ("redis://default:redisPass9876@cache:6379", "redisPass9876"), + ("password = 'hunter2butlonger'", "hunter2butlonger"), + ('password: "yamlPassword123"', "yamlPassword123"), + ("passwd=legacyPasswd12345", "legacyPasswd12345"), + ("pwd => 'phpStylePwd789'", "phpStylePwd789"), + ("secret = 'topSecretValue4242'", "topSecretValue4242"), + ("token = 'plainTokenValue31337'", "plainTokenValue31337"), + ("api_key = 'plainApiKeyValue2026'", "plainApiKeyValue2026"), + ("apikey: joinedApiKeyValue777", "joinedApiKeyValue777"), + ("API-KEY: dashedApiKeyValue888", "dashedApiKeyValue888"), + ("access_key = 'accessKeyValue0001'", "accessKeyValue0001"), + ("secret_key = 'secretKeyValue0002'", "secretKeyValue0002"), + ("auth_token = 'authTokenValue0003'", "authTokenValue0003"), + ("client_secret = 'clientSecretValue0004'", "clientSecretValue0004"), + ("private_key = 'privateKeyValue0005'", "privateKeyValue0005"), + ("db_password = 'dbPasswordValue0006'", "dbPasswordValue0006"), + ("credentials = 'credentialsValue0007'", "credentialsValue0007"), + ("credential: 'credentialValue0008'", "credentialValue0008"), + ("DB_PASS=envStylePass0009", "envStylePass0009"), + ("export SECRET_TOKEN=exportedToken0010", "exportedToken0010"), + ('{"password": "jsonPassword0011"}', "jsonPassword0011"), + ("'api-key': 'quotedDashKey0012'", "quotedDashKey0012"), + ("Bearer spacedBearerToken0013abcdef", "spacedBearerToken0013abcdef"), + ("AGPAEXAMPLEGROUPKEY1", "AGPAEXAMPLEGROUPKEY1"), + ("amqp://guest:amqpSecret0014@mq:5672", "amqpSecret0014"), + ("https://user:urlPass0015abc@internal.host/path", "urlPass0015abc"), + # 拼接构造:避免命中代码托管平台的 secret-scanning 推送保护(引擎收到的仍是完整 token) + ('GH = "' + 'github_' + 'pat_11FAKE0123456789_abcdefghijklmnopqrstuvwxyzFAKE"', + 'github_' + 'pat_11FAKE0123456789_abcdefghijklmnopqrstuvwxyzFAKE'), + ('GITLAB_TOKEN := "' + 'glpat' + '-xFAKEfakeFAKEfake12b"', + 'glpat' + '-xFAKEfakeFAKEfake12b'), + ("DefaultEndpointsProtocol=https;AccountName=x;AccountKey=abcdFAKE1234+/==", + "abcdFAKE1234+/=="), + ('dbPassword := "goStylePass0016"', "goStylePass0016"), +] + +# Benign strings that must NOT be flagged (false-positive guard). +BENIGN_SAMPLES = [ + "password = os.environ['DB_PASSWORD']", + "token = get_secret('svc-token')", + "api_key = None", + "secret = config['secret']", + "passwd = getpass.getpass()", + "# set your password in the env", + "PASSWORD_MIN_LENGTH = 12", + "token = '${VAULT_TOKEN}'", + "url = 'https://example.com/path'", + "self.token = token", +] + + +def test_detection_rate_at_least_95_percent(): + redactor = SecretRedactor() + detected = sum(1 for text, _ in SECRET_SAMPLES if redactor.contains_secret(text)) + rate = detected / len(SECRET_SAMPLES) + assert rate >= 0.95, f"detection rate {rate:.2%} below 95%" + + +def test_redaction_removes_every_detected_value(): + redactor = SecretRedactor() + for text, value in SECRET_SAMPLES: + redacted, _count = redactor.redact(text) + if redactor.contains_secret(text): + assert value not in redacted, f"plaintext survived redaction: {text!r}" + assert REDACTED_PLACEHOLDER in redacted + + +def test_benign_strings_untouched(): + redactor = SecretRedactor() + flagged = [text for text in BENIGN_SAMPLES if redactor.contains_secret(text)] + assert not flagged, f"benign strings misflagged: {flagged}" + + +def test_redact_obj_recurses_and_counts(): + redactor = SecretRedactor() + payload = { + "list": ["password = 'hunter2butlonger'", {"nested": "token = 'plainTokenValue31337'"}], + "clean": "no secrets here", + "number": 42, + } + scrubbed = redactor.redact_obj(payload) + assert "hunter2butlonger" not in str(scrubbed) + assert "plainTokenValue31337" not in str(scrubbed) + assert scrubbed["clean"] == "no secrets here" + assert scrubbed["number"] == 42 + assert redactor.redaction_count >= 2 diff --git a/examples/skills_code_review_agent/tests/test_rules.py b/examples/skills_code_review_agent/tests/test_rules.py new file mode 100644 index 00000000..ed7354f1 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_rules.py @@ -0,0 +1,144 @@ +# 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. +"""Rule engine accuracy on a labeled corpus. + +Acceptance criterion 2 (≥80% detection / ≤15% false positives on hidden +samples) is approximated here with a labeled public corpus: every seeded +issue must be detected (recall proxy) and a clean corpus must yield zero +HIGH-CONFIDENCE findings (false-positive proxy) — documented in the README. +""" + +from typing import List + +from codereview.diff_parser import parse_unified_diff +from codereview.diff_parser import run_all_rules + +MIN_CONFIDENCE = 0.7 # mirror of NoiseConfig.min_confidence + + +def _diff_for(path: str, lines: List[str]) -> str: + body = "".join(f"+{line}\n" for line in lines) + return (f"diff --git a/{path} b/{path}\n" + f"new file mode 100644\n" + f"--- /dev/null\n" + f"+++ b/{path}\n" + f"@@ -0,0 +1,{len(lines)} @@\n{body}") + + +def _run(path: str, lines: List[str]): + return run_all_rules(parse_unified_diff(_diff_for(path, lines))) + + +def _categories(findings) -> set: + return {finding["category"] for finding in findings} + + +# --- positive corpus: every seeded issue must be caught ----------------------- + +POSITIVE_CASES = [ + ("security_risk", ["import os", "os.system('rm ' + name)"]), + ("security_risk", ["import subprocess", "subprocess.run(cmd, shell=True)"]), + ("security_risk", ["result = eval(user_input)"]), + ("security_risk", ["import pickle", "obj = pickle.loads(blob)"]), + ("security_risk", ["import yaml", "cfg = yaml.load(stream)"]), + ("security_risk", ["cur.execute(f\"SELECT * FROM t WHERE id={uid}\")"]), + ("security_risk", ["requests.get(url, verify=False)"]), + ("async_error", ["import time", "async def go():", " time.sleep(3)"]), + ("async_error", ["import requests", "async def fetch():", " requests.get(url)"]), + ("async_error", ["asyncio.create_task(worker())"]), + ("resource_leak", ["fh = open('/tmp/data.txt')", "data = fh.read()"]), + ("resource_leak", ["tmp = tempfile.NamedTemporaryFile(delete=False)"]), + ("resource_leak", ["sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)"]), + ("secret_leakage", ["password = 'hunter2butlonger'"]), + ("secret_leakage", ["KEY = 'AKIAIOSFODNN7EXAMPLE'"]), + ("secret_leakage", ["tok = 'ghp_FAKE1234567890abcdefFAKE12345'"]), + ("db_lifecycle", ["conn = sqlite3.connect(path)", "cur = conn.cursor()", + "cur.execute('BEGIN')", "cur.execute('UPDATE t SET x=1')"]), + ("db_lifecycle", ["for row in rows:", " conn = engine.connect()", + " conn.execute(stmt)"]), + ("missing_tests", ["def helper():", " return 1"]), +] + + +def test_positive_corpus_full_recall(): + missed = [] + for expected_category, lines in POSITIVE_CASES: + findings = _run("app/mod.py", lines) + if expected_category not in _categories(findings): + missed.append((expected_category, lines)) + assert not missed, f"undetected seeded issues: {missed}" + + +def test_detection_rate_at_least_80_percent(): + hits = sum(1 for expected, lines in POSITIVE_CASES + if expected in _categories(_run("app/mod.py", lines))) + assert hits / len(POSITIVE_CASES) >= 0.8 + + +# --- clean corpus: no high-confidence false positives -------------------------- + +CLEAN_CASES = [ + ["import os", "path = os.path.join(base, name)"], + ["with open(path) as fh:", " data = fh.read()"], + ["async def go():", " await asyncio.sleep(1)"], + ["with engine.connect() as conn:", " conn.execute(stmt)", " conn.commit()"], + ["password = os.environ['DB_PASSWORD']"], + ["token = get_secret('svc-token') # loaded at runtime"], + ["cur.execute('SELECT * FROM t WHERE id = %s', (uid,))"], + ["cfg = yaml.safe_load(stream)"], + ["result = subprocess.run(['ls', '-l'], check=True)"], + ["api_key = None"], +] + + +def test_clean_corpus_no_high_confidence_findings(): + false_positives = [] + for lines in CLEAN_CASES: + for finding in _run("app/clean.py", lines): + if finding["category"] == "missing_tests": + continue # changeset-level, expected on code-only snippets + if finding["confidence"] >= MIN_CONFIDENCE: + false_positives.append(finding) + assert not false_positives, f"high-confidence FPs on clean code: {false_positives}" + + +def test_false_positive_rate_within_15_percent(): + flagged = 0 + for lines in CLEAN_CASES: + findings = [finding for finding in _run("app/clean.py", lines) + if finding["category"] != "missing_tests" + and finding["confidence"] >= MIN_CONFIDENCE] + if findings: + flagged += 1 + assert flagged / len(CLEAN_CASES) <= 0.15 + + +# --- rule details --------------------------------------------------------------- + +def test_finding_schema_complete(): + findings = _run("app/mod.py", ["os.system('reboot')"]) + finding = next(item for item in findings if item["category"] == "security_risk") + for key in ("severity", "category", "file", "line", "title", "evidence", + "recommendation", "confidence", "source", "rule_id"): + assert key in finding and finding[key] not in ("", None), key + assert finding["file"] == "app/mod.py" + assert finding["line"] == 1 + assert finding["source"] == "static_rule" + + +def test_missing_tests_not_reported_when_tests_change(): + diff = (_diff_for("app/mod.py", ["def helper():", " return 1"]) + + _diff_for("tests/test_mod.py", ["def test_helper():", " assert True"])) + findings = run_all_rules(parse_unified_diff(diff)) + assert "missing_tests" not in _categories(findings) + + +def test_secret_evidence_pre_redacted_in_sandbox_rule(): + findings = _run("app/cfg.py", ["password = 'plaintexthunter2'"]) + secret_findings = [item for item in findings if item["category"] == "secret_leakage"] + assert secret_findings + assert all("plaintexthunter2" not in item["evidence"] for item in secret_findings) + assert all("***REDACTED***" in item["evidence"] for item in secret_findings) diff --git a/examples/skills_code_review_agent/tests/test_sandbox_safety.py b/examples/skills_code_review_agent/tests/test_sandbox_safety.py new file mode 100644 index 00000000..5661f494 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_sandbox_safety.py @@ -0,0 +1,147 @@ +# 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. +"""Sandbox safety (issue requirement 7, acceptance criterion 4): +timeout, output cap, env whitelist, failure containment.""" + +import os + +from trpc_agent_sdk.code_executors import WorkspaceRunProgramSpec +from trpc_agent_sdk.code_executors import WorkspaceRunResult + +from codereview.config import SandboxConfig +from codereview.diff_parser import parse_unified_diff +from codereview.sandbox import STATUS_FAILED +from codereview.sandbox import STATUS_OK +from codereview.sandbox import STATUS_TIMEOUT +from codereview.sandbox import SandboxExecutor +from codereview.sandbox import create_sandbox_runtime + +SIMPLE_DIFF = ("diff --git a/x.py b/x.py\n" + "new file mode 100644\n" + "--- /dev/null\n" + "+++ b/x.py\n" + "@@ -0,0 +1,1 @@\n" + "+import os\n") + + +def _executor(tmp_path, **cfg_overrides) -> SandboxExecutor: + cfg = SandboxConfig(runtime_kind="local", work_root=str(tmp_path / "ws"), **cfg_overrides) + return SandboxExecutor(create_sandbox_runtime(cfg), cfg) + + +async def test_successful_run_produces_findings_payload(tmp_path): + executor = _executor(tmp_path) + outcome = await executor.run_checks("t1", parse_unified_diff(SIMPLE_DIFF)) + assert outcome.status == STATUS_OK + assert outcome.findings_payload is not None + assert "findings" in outcome.findings_payload + + +async def test_timeout_contained(tmp_path): + """A stuck program gets killed by the runner-level timeout.""" + runtime = create_sandbox_runtime(SandboxConfig(runtime_kind="local", + work_root=str(tmp_path / "ws2"), + timeout_sec=1.0)) + manager = runtime.manager() + ws = await manager.create_workspace("timeout-probe") + try: + result: WorkspaceRunResult = await runtime.runner().run_program( + ws, WorkspaceRunProgramSpec(cmd="python3", args=["-c", "import time; time.sleep(30)"], + timeout=0.5)) + assert result.timed_out is True + finally: + await manager.cleanup("timeout-probe") + + +async def test_timeout_status_via_executor(tmp_path): + """SandboxExecutor maps a timed-out run to status=timeout without raising. + + timeout_sec=0.05 is far below the Python interpreter startup cost, so the + check reliably times out; if an exotic host still finishes, the invariant + under test (no exception, correct status mapping) holds either way. + """ + executor = _executor(tmp_path, timeout_sec=0.05) + outcome = await executor.run_checks("t-timeout", parse_unified_diff(SIMPLE_DIFF)) + assert outcome.status in (STATUS_OK, STATUS_TIMEOUT) + if outcome.status == STATUS_TIMEOUT: + assert outcome.error_type == "SandboxTimeout" + assert outcome.result is not None and outcome.result.timed_out is True + + +async def test_output_size_capped(tmp_path): + """stdout beyond max_output_bytes is truncated and flagged.""" + cfg = SandboxConfig(runtime_kind="local", work_root=str(tmp_path / "ws3"), + max_output_bytes=500) + runtime = create_sandbox_runtime(cfg) + manager = runtime.manager() + ws = await manager.create_workspace("cap-probe") + try: + result = await runtime.runner().run_program( + ws, WorkspaceRunProgramSpec(cmd="python3", + args=["-c", "print('A' * 100000)"], timeout=10)) + from codereview.sandbox import _cap_output + capped, truncated = _cap_output(result.stdout, cfg.max_output_bytes) + assert truncated is True + assert len(capped.encode()) <= cfg.max_output_bytes + len("\n…[output truncated]".encode()) + finally: + await manager.cleanup("cap-probe") + + +async def test_env_whitelist_blocks_host_secrets(tmp_path, monkeypatch): + """Host env secrets must NOT be visible inside the local sandbox.""" + monkeypatch.setenv("CR_SECRET_CANARY", "super-secret-canary-value") + monkeypatch.setenv("TRPC_AGENT_API_KEY", "sk-canary-key-should-not-leak") + cfg = SandboxConfig(runtime_kind="local", work_root=str(tmp_path / "ws4")) + runtime = create_sandbox_runtime(cfg) + manager = runtime.manager() + ws = await manager.create_workspace("env-probe") + try: + result = await runtime.runner().run_program( + ws, WorkspaceRunProgramSpec( + cmd="python3", + args=["-c", "import os, json; print(json.dumps(dict(os.environ)))"], + timeout=10)) + assert "CR_SECRET_CANARY" not in result.stdout + assert "sk-canary-key-should-not-leak" not in result.stdout + # workspace layout vars are still provided + assert "WORKSPACE_DIR" in result.stdout + # whitelisted basics survive + assert "PATH" in result.stdout + finally: + await manager.cleanup("env-probe") + + +async def test_forced_failure_contained_and_recorded(tmp_path): + """--force-fail: script raises; executor reports failed, never raises.""" + executor = _executor(tmp_path, force_fail=True) + outcome = await executor.run_checks("t2", parse_unified_diff(SIMPLE_DIFF)) + assert outcome.status == STATUS_FAILED + assert outcome.error_type == "SandboxNonZeroExit" + assert "forced sandbox failure" in outcome.stderr + assert outcome.findings_payload is None + + +async def test_runtime_exception_contained(tmp_path): + """Even a broken runtime surfaces as status=error, not an exception.""" + executor = _executor(tmp_path) + + class BrokenManager: + async def create_workspace(self, exec_id, ctx=None): + raise OSError("disk gone") + + executor._runtime.manager = lambda ctx=None: BrokenManager() # noqa: SLF001 + outcome = await executor.run_checks("t3", parse_unified_diff(SIMPLE_DIFF)) + assert outcome.status == "error" + assert outcome.error_type == "OSError" + + +async def test_workspace_cleaned_up(tmp_path): + executor = _executor(tmp_path) + await executor.run_checks("t4", parse_unified_diff(SIMPLE_DIFF)) + ws_root = tmp_path / "ws" + leftovers = [entry for entry in (os.listdir(ws_root) if ws_root.exists() else []) + if entry.startswith("cr-t4")] + assert leftovers == [] diff --git a/examples/skills_code_review_agent/tests/test_store.py b/examples/skills_code_review_agent/tests/test_store.py new file mode 100644 index 00000000..a15f8a89 --- /dev/null +++ b/examples/skills_code_review_agent/tests/test_store.py @@ -0,0 +1,116 @@ +# 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. +"""Store layer (issue requirement 5, acceptance criterion 3).""" + +import pytest + +from codereview.store import SqlReviewStore +from codereview.store.init_db import init_db + + +@pytest.fixture +async def store(tmp_path): + instance = SqlReviewStore(f"sqlite+aiosqlite:///{tmp_path}/review.db") + await instance.initialize() + yield instance + await instance.close() + + +async def test_init_db_creates_all_tables(tmp_path): + tables = await init_db(f"sqlite+aiosqlite:///{tmp_path}/fresh.db") + assert tables == ["cr_filter_event", "cr_finding", "cr_report", "cr_review_task", "cr_sandbox_run"] + # idempotent re-run (init + forward migration must not fail) + assert await init_db(f"sqlite+aiosqlite:///{tmp_path}/fresh.db") == tables + + +async def test_task_roundtrip_and_status_lifecycle(store): + await store.create_task("task-1", "fixture", "security_issue.diff", {"model_mode": "fake"}) + task = await store.get_task("task-1") + assert task["status"] == "pending" + assert task["input_type"] == "fixture" + assert task["config"] == {"model_mode": "fake"} + + await store.update_task("task-1", status="running") + await store.update_task("task-1", status="completed", diff_summary={"file_count": 2}) + task = await store.get_task("task-1") + assert task["status"] == "completed" + assert task["diff_summary"] == {"file_count": 2} + + with pytest.raises(KeyError): + await store.update_task("missing", status="failed") + + +async def test_full_bundle_queryable_by_task_id(store): + await store.create_task("task-2", "diff_file", "x.diff", {}) + await store.add_sandbox_run({ + "task_id": "task-2", "run_index": 0, "kind": "static_checks", + "runtime_kind": "local", "cmd": "python3", "args": ["run_checks.py"], + "duration_ms": 12.5, "exit_code": 0, "timed_out": False, "status": "ok", + "filter_action": "allow", "filter_reasons": [], + "stdout_excerpt": "emitted 2 finding(s)", "stderr_excerpt": "", + "output_truncated": False, "error_type": "", + }) + await store.add_filter_event({ + "task_id": "task-2", "stage": "sandbox_gate", "target": "run_checks.py", + "action": "allow", "rule": "", "reasons": [], + }) + await store.add_findings("task-2", [{ + "severity": "high", "category": "security_risk", "file": "a.py", "line": 3, + "title": "t", "evidence": "e", "recommendation": "r", "confidence": 0.9, + "source": "static_rule", "rule_id": "SEC001", "bucket": "finding", + "dedup_key": "a.py:3:security_risk", + }]) + await store.save_report("task-2", { + "summary": "ok", "findings_total": 1, + "severity_stats": {"high": 1}, "filter_summary": {"blocked": 0}, + "sandbox_summary": {"total_runs": 1}, "metrics": {"total_duration_ms": 100}, + "report": {"task_id": "task-2"}, + }) + + bundle = await store.get_task_bundle("task-2") + assert bundle["task"]["id"] == "task-2" + assert len(bundle["sandbox_runs"]) == 1 + assert bundle["sandbox_runs"][0]["status"] == "ok" + assert len(bundle["filter_events"]) == 1 + assert len(bundle["findings"]) == 1 + assert bundle["findings"][0]["dedup_key"] == "a.py:3:security_risk" + assert bundle["report"]["metrics"] == {"total_duration_ms": 100} + assert bundle["report"]["report"] == {"task_id": "task-2"} + + # unknown task id → empty bundle, no exception + empty = await store.get_task_bundle("nope") + assert empty["task"] is None and empty["findings"] == [] + + +async def test_findings_isolated_per_task(store): + await store.create_task("task-a", "fixture", "a", {}) + await store.create_task("task-b", "fixture", "b", {}) + finding = { + "severity": "low", "category": "missing_tests", "file": "f.py", "line": 1, + "title": "t", "evidence": "e", "recommendation": "r", "confidence": 0.9, + "source": "static_rule", "rule_id": "TST001", "bucket": "finding", "dedup_key": "k", + } + await store.add_findings("task-a", [dict(finding)]) + await store.add_findings("task-b", [dict(finding), dict(finding)]) + assert len(await store.get_findings("task-a")) == 1 + assert len(await store.get_findings("task-b")) == 2 + + +async def test_list_tasks_ordering_and_limit(store): + for index in range(3): + await store.create_task(f"task-{index}", "fixture", f"ref-{index}", {}) + tasks = await store.list_tasks(limit=2) + assert len(tasks) == 2 + + +def test_backend_swap_is_url_only(): + """The swappable-backend contract: only the URL names the engine.""" + store = SqlReviewStore("sqlite+aiosqlite:///whatever.db") + assert store.db_url.startswith("sqlite+aiosqlite") + # MySQL/PostgreSQL constructors accept the same shape (no code change); + # engine creation is deferred, so instantiation alone must not connect. + SqlReviewStore("mysql+aiomysql://user:pw@host/db") + SqlReviewStore("postgresql+asyncpg://user:pw@host/db")