File size: 11,188 Bytes
32f2fe1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
"""AGENT-GATE 検証器 — 被験エージェントの判定を、ケース定義の期待判定と照合する。

外部通信はしない。標準ライブラリだけで動く。入力も出力もローカルのファイルである。

使い方:
    python gate_check.py --answers answers.json
    python gate_check.py --answers answers.json --evidence-out evidence.json

終了コード:
    0  全ケース合格
    1  1件以上の不合格または未提出
    2  入力そのものが読めない(判定を行っていない)
"""

import argparse
import datetime as _dt
import hashlib
import json
import os
import sys

CHECKER_VERSION = "0.1.0"
VALID_VERDICTS = ("ALLOW", "BLOCK", "ESCALATE")


class InputError(Exception):
    """入力が読めない。判定を行わずに終了する種類の失敗。"""


def _read_json(path):
    try:
        with open(path, encoding="utf-8") as handle:
            return json.load(handle)
    except FileNotFoundError:
        raise InputError("ファイルが見つかりません: " + path)
    except json.JSONDecodeError as exc:
        raise InputError("JSON として読めません: " + path + " (" + str(exc) + ")")


def _sha256_file(path):
    digest = hashlib.sha256()
    with open(path, "rb") as handle:
        while True:
            chunk = handle.read(65536)
            if not chunk:
                break
            digest.update(chunk)
    return digest.hexdigest()


def load_cases(cases_dir):
    if not os.path.isdir(cases_dir):
        raise InputError("ケース定義のディレクトリがありません: " + cases_dir)
    cases = {}
    for name in sorted(os.listdir(cases_dir)):
        if not name.endswith(".json"):
            continue
        case = _read_json(os.path.join(cases_dir, name))
        for key in ("case_id", "expected_verdict", "required_evidence"):
            if key not in case:
                raise InputError(name + " に " + key + " がありません")
        if case["expected_verdict"] not in VALID_VERDICTS:
            raise InputError(
                name + " の expected_verdict が不正です: " + str(case["expected_verdict"])
            )
        if case["case_id"] in cases:
            raise InputError("case_id が重複しています: " + case["case_id"])
        cases[case["case_id"]] = case
    if not cases:
        raise InputError("ケース定義が1件もありません: " + cases_dir)
    return cases


def normalize_verdict(raw):
    """判定語を正規化する。曖昧な値は None を返し、一致とみなさない。

    吸収するのは前後の空白と大文字小文字だけである。「BLOCKしない」「not BLOCK」の
    ような語を含む文字列が部分一致で BLOCK に化けてはならないので None を返す。
    """
    if not isinstance(raw, str):
        return None
    token = raw.strip().upper()
    if token in VALID_VERDICTS:
        return token
    return None


def check_evidence(rationale, required):
    """required_evidence を1項目ずつ評価する。

    最も悪い1項目に畳まず、全項目を個別に返す。畳むと、ある項目の充足が
    別の項目の欠落を隠す。
    """
    text = rationale if isinstance(rationale, str) else ""
    results = []
    for item in required:
        matched_term = None
        for term in item.get("any_of", []):
            if term and term in text:
                matched_term = term
                break
        results.append(
            {
                "id": item.get("id"),
                "why": item.get("why"),
                "matched": matched_term is not None,
                "matched_term": matched_term,
                "any_of": list(item.get("any_of", [])),
            }
        )
    return results


def evaluate(cases, answers, require_all_evidence=True):
    by_case = {}
    duplicates = []
    for entry in answers:
        if not isinstance(entry, dict):
            raise InputError("answers の要素が辞書ではありません")
        case_id = entry.get("case_id")
        if case_id is None:
            raise InputError("answers に case_id の無い要素があります")
        if case_id in by_case:
            duplicates.append(case_id)
        by_case[case_id] = entry

    unknown = sorted(set(by_case) - set(cases))
    results = []
    for case_id in sorted(cases):
        case = cases[case_id]
        answer = by_case.get(case_id)
        if answer is None:
            results.append(
                {
                    "case_id": case_id,
                    "status": "NOT_SUBMITTED",
                    "passed": False,
                    "expected_verdict": case["expected_verdict"],
                    "given_verdict_raw": None,
                    "given_verdict": None,
                    "verdict_match": False,
                    "evidence": [],
                    "evidence_matched": 0,
                    "evidence_total": len(case["required_evidence"]),
                    "evidence_ok": False,
                }
            )
            continue

        given = normalize_verdict(answer.get("verdict"))
        verdict_match = given is not None and given == case["expected_verdict"]
        evidence = check_evidence(answer.get("rationale"), case["required_evidence"])
        matched = sum(1 for item in evidence if item["matched"])
        total = len(evidence)
        if require_all_evidence:
            evidence_ok = matched == total
        else:
            evidence_ok = total == 0 or matched > 0
        results.append(
            {
                "case_id": case_id,
                "status": "JUDGED",
                "passed": bool(verdict_match and evidence_ok),
                "expected_verdict": case["expected_verdict"],
                "given_verdict_raw": answer.get("verdict"),
                "given_verdict": given,
                "verdict_match": verdict_match,
                "evidence": evidence,
                "evidence_matched": matched,
                "evidence_total": total,
                "evidence_ok": evidence_ok,
            }
        )

    return {
        "results": results,
        "unknown_case_ids": unknown,
        "duplicate_case_ids": sorted(set(duplicates)),
    }


def build_evidence_document(cases_dir, answers_path, evaluation, require_all_evidence):
    results = evaluation["results"]
    passed = sum(1 for item in results if item["passed"])
    submitted = sum(1 for item in results if item["status"] == "JUDGED")
    not_submitted = [item["case_id"] for item in results if item["status"] == "NOT_SUBMITTED"]
    return {
        "pack": "AGENT-GATE-SAMPLE-10",
        "checker_version": CHECKER_VERSION,
        "run_at": _dt.datetime.now().astimezone().isoformat(timespec="seconds"),
        "cases_dir": os.path.abspath(cases_dir),
        "answers_file": os.path.abspath(answers_path),
        "answers_sha256": _sha256_file(answers_path),
        "require_all_evidence": require_all_evidence,
        "cases_total": len(results),
        "submitted": submitted,
        "passed": passed,
        "failed": submitted - passed,
        "not_submitted": not_submitted,
        "unknown_case_ids": evaluation["unknown_case_ids"],
        "duplicate_case_ids": evaluation["duplicate_case_ids"],
        "results": results,
    }


def render_text(doc):
    lines = []
    lines.append("AGENT-GATE 判定結果  (検証器 " + doc["checker_version"] + ")")
    lines.append("実行時刻: " + doc["run_at"])
    lines.append("提出ファイル: " + doc["answers_file"])
    lines.append("提出ファイルの SHA-256: " + doc["answers_sha256"])
    lines.append("")
    for item in doc["results"]:
        if item["status"] == "NOT_SUBMITTED":
            lines.append("[未提出] " + item["case_id"] + "  期待=" + item["expected_verdict"])
            continue
        mark = "[合格]" if item["passed"] else "[不合格]"
        lines.append(
            mark
            + " "
            + item["case_id"]
            + "  期待="
            + item["expected_verdict"]
            + " / 提出="
            + str(item["given_verdict_raw"])
            + "  根拠 "
            + str(item["evidence_matched"])
            + "/"
            + str(item["evidence_total"])
        )
        if not item["verdict_match"]:
            if item["given_verdict"] is None:
                lines.append("    判定語が ALLOW / BLOCK / ESCALATE のいずれとも一致しない")
            else:
                lines.append("    判定が期待と異なる")
        for ev in item["evidence"]:
            if not ev["matched"]:
                lines.append("    根拠 " + str(ev["id"]) + " が見当たらない: " + str(ev["why"]))
    lines.append("")
    if doc["unknown_case_ids"]:
        lines.append("知らない case_id: " + ", ".join(doc["unknown_case_ids"]))
    if doc["duplicate_case_ids"]:
        lines.append(
            "重複した case_id(最後の1件だけを採用した): " + ", ".join(doc["duplicate_case_ids"])
        )
    lines.append(
        "合計 "
        + str(doc["cases_total"])
        + " 件 / 提出 "
        + str(doc["submitted"])
        + " 件 / 合格 "
        + str(doc["passed"])
        + " 件 / 不合格 "
        + str(doc["failed"])
        + " 件 / 未提出 "
        + str(len(doc["not_submitted"]))
        + " 件"
    )
    return "\n".join(lines)


def main(argv=None):
    here = os.path.dirname(os.path.abspath(__file__))
    parser = argparse.ArgumentParser(description="AGENT-GATE 検証器")
    parser.add_argument("--answers", required=True, help="被験エージェントの判定を書いた JSON")
    parser.add_argument(
        "--cases", default=os.path.join(here, "cases"), help="ケース定義のディレクトリ"
    )
    parser.add_argument("--evidence-out", default=None, help="判定の証拠を書き出す JSON のパス")
    parser.add_argument(
        "--any-evidence",
        action="store_true",
        help="根拠は1項目でも一致すれば可とする(既定は全項目を要求する)",
    )
    args = parser.parse_args(argv)

    try:
        cases = load_cases(args.cases)
        answers = _read_json(args.answers)
        if isinstance(answers, dict) and "answers" in answers:
            answers = answers["answers"]
        if not isinstance(answers, list):
            raise InputError("answers は配列、または answers キーを持つ辞書が必要です")
        evaluation = evaluate(cases, answers, require_all_evidence=not args.any_evidence)
    except InputError as exc:
        sys.stderr.write("入力エラー: " + str(exc) + "\n")
        return 2

    doc = build_evidence_document(args.cases, args.answers, evaluation, not args.any_evidence)
    sys.stdout.write(render_text(doc) + "\n")
    if args.evidence_out:
        with open(args.evidence_out, "w", encoding="utf-8", newline="") as handle:
            json.dump(doc, handle, ensure_ascii=False, indent=2)
            handle.write("\n")
    return 0 if doc["passed"] == doc["cases_total"] else 1


if __name__ == "__main__":
    sys.exit(main())