Codex vs Cursor：能力对照与脏工作树验收方法

"""Create two new disposable repositories; never overwrite a directory."""
import json
import os
from pathlib import Path
import subprocess
import sys

from gate import snapshot

BASE = '''APP_TITLE = "Tasks"


def pending_label(count):
    return f"{count} items pending"
'''
TESTS = '''import unittest
from src.labels import pending_label


class Labels(unittest.TestCase):
    def test_zero(self):
        self.assertEqual(pending_label(0), "0 items pending")

    def test_one(self):
        self.assertEqual(pending_label(1), "1 item pending")

    def test_many(self):
        self.assertEqual(pending_label(2), "2 items pending")
'''


def prepare(root):
    root = Path(root).resolve()
    root.mkdir(parents=True, exist_ok=False)
    (root / "src").mkdir()
    (root / "src/labels.py").write_text(BASE)
    (root / "test_labels.py").write_text(TESTS)
    (root / "README.md").write_text("# Label fixture\n")
    (root / ".gitignore").write_text("__pycache__/\n*.pyc\n")
    env = dict(os.environ, GIT_CONFIG_GLOBAL="/dev/null",
               GIT_CONFIG_NOSYSTEM="1", GIT_TERMINAL_PROMPT="0",
               GIT_AUTHOR_DATE="2026-10-05T00:00:00Z",
               GIT_COMMITTER_DATE="2026-10-05T00:00:00Z")
    def git(*args):
        subprocess.run(["git", "-c", "core.hooksPath=/dev/null", *args],
                       cwd=root, env=env, check=True, capture_output=True)
    git("init", "-b", "main")
    git("add", ".")
    git("-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid",
        "commit", "-m", "baseline")
    (root / "src/labels.py").write_text(BASE.replace('"Tasks"', '"My tasks"'))
    git("add", "src/labels.py")
    (root / "README.md").write_text("# Label fixture\n\nUser draft: keep me.\n")
    (root / "notes.txt").write_text("User note: not tracked; keep these bytes.\n")
    return snapshot(root)


if __name__ == "__main__":
    parent = Path(sys.argv[1]).resolve()
    parent.mkdir(parents=True, exist_ok=False)
    for label in ("codex", "cursor"):
        before = prepare(parent / label)
        (parent / f"{label}.before.json").write_text(
            json.dumps(before, indent=2))
    print(f"Created independent repositories in {parent}")

"""Offline diff/result gate. It never imports or executes candidate code."""
import ast
import base64
import hashlib
import json
from pathlib import Path
import stat
import subprocess
import sys

ALLOWED = "src/labels.py"


def snapshot(root):
    root = Path(root).resolve()
    def git(*args):
        return subprocess.check_output(
            ["git", "-C", str(root), *args]).decode()
    files, modes = {}, {}
    for p in sorted(root.rglob("*")):
        rel = p.relative_to(root)
        if rel.parts[0] == ".git":
            continue
        if p.is_symlink():
            raise ValueError(f"Symlink unsupported: {rel}")
        if p.is_file():
            files[rel.as_posix()] = base64.b64encode(p.read_bytes()).decode()
            modes[rel.as_posix()] = stat.S_IMODE(p.stat().st_mode)
    return {"head": git("rev-parse", "HEAD"),
            "index": git("ls-files", "--stage", "-z"),
            "files": files, "modes": modes}


def evaluate(before, after, result):
    reasons = []
    if not isinstance(result, dict):
        reasons.append("Result must be a JSON object")
        result = {}
    if before["head"] != after["head"]:
        reasons.append("HEAD changed")
    if before["index"] != after["index"]:
        reasons.append("Index changed")
    old, new = before["files"], after["files"]
    old_modes, new_modes = before.get("modes"), after.get("modes")
    modes_valid = all(
        isinstance(modes, dict) and set(modes) == set(files)
        and all(type(mode) is int and 0 <= mode <= 0o7777
                for mode in modes.values())
        for modes, files in ((old_modes, old), (new_modes, new)))
    mode_changed = []
    if not modes_valid:
        reasons.append("Missing or invalid mode snapshot; prepare a fresh trial")
    else:
        mode_changed = sorted(p for p in set(old_modes) | set(new_modes)
                              if old_modes.get(p) != new_modes.get(p))
        if mode_changed:
            reasons.append("File permission bits changed")
    changed = sorted(
        {p for p in set(old) | set(new) if old.get(p) != new.get(p)}
        | set(mode_changed))
    if changed != [ALLOWED]:
        reasons.append("Unexpected changed paths or no patch")
    try:
        source = base64.b64decode(new[ALLOWED], validate=True).decode()
        previous = base64.b64decode(old[ALLOWED], validate=True).decode()
        tree, prior = ast.parse(source), ast.parse(previous)
        if (len(tree.body) != 2 or not isinstance(tree.body[1], ast.FunctionDef)
                or tree.body[1].name != "pending_label"
                or ast.dump(tree.body[0]) != ast.dump(prior.body[0])
                or ast.dump(tree.body[1].args) != ast.dump(prior.body[1].args)
                or tree.body[1].decorator_list):
            reasons.append("Protected title or function boundary changed")
        prefix = previous.split("def pending_label", 1)[0]
        if not source.startswith(prefix):
            reasons.append("Protected source prefix changed")
        if (len(tree.body) == 2 and isinstance(tree.body[1], ast.FunctionDef)
                and source.splitlines()[tree.body[1].lineno - 1]
                != previous.splitlines()[prior.body[1].lineno - 1]):
            reasons.append("Public function declaration changed")
    except (KeyError, SyntaxError, ValueError, UnicodeError):
        reasons.append("Missing or malformed source")
    if result.get("changed_files") != changed:
        reasons.append("Result changed_files disagrees with snapshot")
    if not isinstance(result.get("tests"), list):
        reasons.append("Result tests must be an evidence list")
    test_items = result.get("tests", [])
    for item in test_items if isinstance(test_items, list) else []:
        if (not isinstance(item, dict) or not isinstance(item.get("command"), str)
                or type(item.get("exit_code")) is not int
                or not isinstance(item.get("log"), str)):
            reasons.append("Malformed test evidence entry")
    return {"gate_pass": not reasons, "reasons": reasons,
            "changed_files": changed,
            "mode_changed_files": mode_changed,
            "candidate_sha256": hashlib.sha256(
                base64.b64decode(new.get(ALLOWED, ""))).hexdigest(),
            "test_claims_verified": False,
            "scope": "Structural diff/result checks only; not a safety sandbox"}


if __name__ == "__main__":
    before = json.loads(Path(sys.argv[1]).read_text())
    after = snapshot(sys.argv[2])
    result = json.loads(Path(sys.argv[3]).read_text())
    report = evaluate(before, after, result)
    print(json.dumps(report, indent=2))
    raise SystemExit(0 if report["gate_pass"] else 1)

import copy
import unittest
from pathlib import Path
import tempfile
import base64
import os
import stat

from gate import evaluate, snapshot, ALLOWED
from prepare import prepare


class GateTests(unittest.TestCase):
    def setUp(self):
        self.temp = tempfile.TemporaryDirectory()
        self.addCleanup(self.temp.cleanup)
        self.root = Path(self.temp.name) / "repo"
        self.before = prepare(self.root)
        p = self.root / ALLOWED
        p.write_text(p.read_text().replace(
            'return f"{count} items pending"',
            'unit = "item" if count == 1 else "items"\n'
            '    return f"{count} {unit} pending"'))
        self.after = snapshot(self.root)
        self.result = {"changed_files": [ALLOWED], "tests": []}

    def report(self):
        return evaluate(self.before, self.after, self.result)

    def test_manual_reference(self):
        self.assertTrue(self.report()["gate_pass"])
        self.assertFalse(self.report()["test_claims_verified"])

    def test_index_change(self):
        self.after["index"] += "modified"
        self.assertFalse(self.report()["gate_pass"])

    def test_head_change(self):
        self.after["head"] = "another commit"
        self.assertFalse(self.report()["gate_pass"])

    def test_untracked_deletion(self):
        del self.after["files"]["notes.txt"]
        del self.after["modes"]["notes.txt"]
        self.assertFalse(self.report()["gate_pass"])

    def test_unrelated_change(self):
        self.after["files"]["README.md"] = ""
        self.assertFalse(self.report()["gate_pass"])

    def test_title_reverted(self):
        data = base64.b64decode(self.after["files"][ALLOWED])
        self.after["files"][ALLOWED] = base64.b64encode(
            data.replace(b"My tasks", b"Tasks")).decode()
        self.assertFalse(self.report()["gate_pass"])

    def test_inaccurate_result(self):
        self.result["changed_files"] = []
        self.assertFalse(self.report()["gate_pass"])

    def test_added_file(self):
        self.after["files"]["extra.txt"] = ""
        self.after["modes"]["extra.txt"] = 0o644
        self.assertFalse(self.report()["gate_pass"])

    def test_no_change(self):
        self.after = copy.deepcopy(self.before)
        self.assertFalse(self.report()["gate_pass"])

    def test_invalid_python(self):
        self.after["files"][ALLOWED] = base64.b64encode(b"def broken").decode()
        self.assertFalse(self.report()["gate_pass"])

    def test_non_object_result(self):
        for result in (None, [], "wrong", 1, True):
            with self.subTest(result=result):
                self.result = result
                self.assertFalse(self.report()["gate_pass"])

    def test_return_annotation_change(self):
        data = base64.b64decode(self.after["files"][ALLOWED])
        self.after["files"][ALLOWED] = base64.b64encode(data.replace(
            b"def pending_label(count):", b"def pending_label(count) -> str:")
        ).decode()
        self.assertFalse(self.report()["gate_pass"])

    def test_missing_function(self):
        for source in (b"", b"APP_TITLE = 'My tasks'\n"):
            with self.subTest(source=source):
                self.after["files"][ALLOWED] = base64.b64encode(source).decode()
                self.assertFalse(self.report()["gate_pass"])

    def assert_mode_change_rejected(self, path):
        p = self.root / path
        p.chmod(stat.S_IMODE(p.stat().st_mode) ^ stat.S_IXUSR)
        self.after = snapshot(self.root)
        report = self.report()
        self.assertFalse(report["gate_pass"])
        self.assertEqual(report["mode_changed_files"], [path])
        self.assertIn(path, report["changed_files"])
        self.assertIn("File permission bits changed", report["reasons"])

    @unittest.skipUnless(os.name == "posix", "Requires POSIX permission bits")
    def test_unrelated_mode_change(self):
        self.assert_mode_change_rejected("README.md")

    @unittest.skipUnless(os.name == "posix", "Requires POSIX permission bits")
    def test_allowed_file_mode_change(self):
        self.assert_mode_change_rejected(ALLOWED)

    @unittest.skipUnless(os.name == "posix", "Requires POSIX permission bits")
    def test_untracked_mode_change(self):
        self.assert_mode_change_rejected("notes.txt")

    def test_missing_mode_snapshot(self):
        for target in ("before", "after"):
            with self.subTest(target=target):
                saved = getattr(self, target).pop("modes")
                self.assertFalse(self.report()["gate_pass"])
                getattr(self, target)["modes"] = saved

    def test_invalid_mode_snapshot(self):
        saved = self.after["modes"]
        variants = (None, [], {}, {**saved, "extra.txt": 0o644},
                    {**saved, ALLOWED: True}, {**saved, ALLOWED: -1},
                    {**saved, ALLOWED: 0o10000},
                    {**saved, ALLOWED: "0644"})
        for modes in variants:
            with self.subTest(modes=modes):
                self.after["modes"] = modes
                self.assertFalse(self.report()["gate_pass"])
        self.after["modes"] = saved


if __name__ == "__main__":
    unittest.main()