from harbor.environments.base import BaseEnvironment

from harbor.models.agent.context import AgentContext

_TARBALL = Path(__file__).resolve().parent.parent / "openagentsinc-cli-0.3.5.tgz"

def _find_tarball() -> Path:

    """The packed CLI, whatever version it is.

    Pinning the version here meant a version bump silently broke every graded

    run: the adapter looked for a tarball nobody packs any more and every trial

    errored in install with a message about the old number. The pack step

    produces exactly one tarball, so find it rather than predict its name; if

    there are several, take the newest, because that is the one just built.

    """

    bench = Path(__file__).resolve().parent.parent

    candidates = sorted(

        bench.glob("openagentsinc-cli-*.tgz"),

        key=lambda path: path.stat().st_mtime,

        reverse=True,

    )

    return candidates[0] if candidates else bench / "openagentsinc-cli-<version>.tgz"

_TARBALL = _find_tarball()

_REMOTE_TARBALL = "/installed-agent/openagents-cli.tgz"

_DEFAULT_API_URL = "http://host.docker.internal:4000"

_EXPORT_DIR = "$HOME/.openagents/exports"

{

  "format": "weka-trace-v1",

  "thread_id": "transcript-001",

  "event_count": 3,

  "events": [

    { "id": 1, "event_type": "turn.user",      "emitted_at": "2026-08-25T00:00:00Z", "role": "user",      "block_count": 2, "blocks": ["a1", "a2"] },

    { "id": 2, "event_type": "turn.assistant", "emitted_at": "2026-08-25T00:00:01Z", "role": "assistant", "block_count": 1, "blocks": ["b1"] },

    { "id": 3, "event_type": "turn.user",      "emitted_at": "2026-08-25T00:00:02Z", "role": "user",      "block_count": 1, "blocks": ["c1"] }

  ]

}

    return _get(ev, _HASH_KEYS) or []

def _analyze_session(events: List[Dict[str, Any]]) -> Dict[str, Any]:

def _analyze_session(events: List[Dict[str, Any]], context: str = "accumulate") -> Dict[str, Any]:

    """Per-turn prefix reuse for one session.

    Two corpora shapes exist and they mean different things by a turn's block

    list, so the model is explicit rather than guessed:

    - `accumulate` (the default, and what `weka-trace-v1` exports): each event

      carries only its OWN new content. The request context at turn N is

      everything the session has said up to and including N, so the re-sent

      prefix is the accumulation of turns 1..N-1. This is where the reuse

      lives, and reading each event's list as if it were the whole context

      reports zero reuse for a session that is almost entirely prefix.

    - `explicit`: each turn's list already IS the full context sent for that

      request, repeats included. Used by corpora that record requests rather

      than transcripts.

    """

    indexed = sorted(enumerate(events), key=lambda x: (_sortable_time(_get(x[1], _TIME_KEYS)), x[0]))

    seen: set = set()

    carried: List[Any] = []

    turns: List[Dict[str, Any]] = []

    total, repeated, new = 0, 0, 0

    first_total, last_total = 0, 0

        raw = _blocks_for_event(ev)

        if not isinstance(raw, list):

            raise ValueError("turn block list is not an array")

        keys = [_canon(b) for b in raw if _canon(b) is not None]

        n_total = len(keys)

        n_repeated = sum(1 for k in keys if k in seen)

        n_new = n_total - n_repeated

        own = [_canon(b) for b in raw if _canon(b) is not None]

        if context == "accumulate":

            # The request carries everything said so far, then this turn's own

            # blocks. The prefix is exactly what was carried in.

            n_repeated = len(carried)

            keys = carried + own

            n_total = len(keys)

            n_new = len(own)

            carried = keys

        else:

            keys = own

            n_total = len(keys)

            n_repeated = sum(1 for k in keys if k in seen)

            n_new = n_total - n_repeated

        seen.update(keys)

        total += n_total

        repeated += n_repeated

    return {"files": results, "corpus": corpus}

def process_paths(paths: List[Path]) -> Tuple[List[Dict[str, Any]], List[str]]:

def process_paths(paths: List[Path], context: str = "accumulate") -> Tuple[List[Dict[str, Any]], List[str]]:

    results: List[Dict[str, Any]] = []

    errors: List[str] = []

    for p in paths:

                        "turns": a["turns"],

                        "summary": a["summary"],

                    }

                    for sid, a in ((sid, _analyze_session(ev)) for sid, ev in sessions)

                    for sid, a in ((sid, _analyze_session(ev, context)) for sid, ev in sessions)

                ]

                file_docs.append({"document_index": i, "sessions": analyzed})

            results.append({"path": str(p), "documents": file_docs})

    )

    parser.add_argument("traces", nargs="+", type=Path, help="weka-trace-v1 JSON files")

    parser.add_argument("--json", action="store_true", help="emit machine-readable JSON output")

    parser.add_argument(

        "--context",

        choices=("accumulate", "explicit"),

        default="accumulate",

        help=(

            "how a turn's block list relates to the request context. "

            "accumulate (default, and what weka-trace-v1 exports): each event "

            "carries its own new content and the request re-sends everything "

            "before it. explicit: each turn's list is already the whole "

            "context, repeats included."

        ),

    )

    arguments = parser.parse_args(argv)

    results, errors = process_paths(arguments.traces)

    results, errors = process_paths(arguments.traces, arguments.context)

    all_sessions = [

        s for r in results for d in r.get("documents", []) for s in d["sessions"]

    ]

def test_sample_reuse_ratio() -> None:

    proc = _run([str(_FIXTURE)])

    # The fixture records whole request contexts, so it is an `explicit`

    # corpus. `weka-trace-v1` is the other shape and is covered below.

    proc = _run([str(_FIXTURE), "--context", "explicit"])

    if proc.returncode != 0:

        raise AssertionError(f"tool failed: {proc.stderr}")

    data = json.loads(proc.stdout)

    assert corpus["context_growth"] == 6

def test_transcript_corpus_reuse_ratio() -> None:

    """A weka-trace-v1 transcript: each event carries only its own blocks.

    Hand-computed: turn 1 sends 2 blocks and repeats none; turn 2 re-sends

    those 2 and adds 1; turn 3 re-sends 3 and adds 1. So 9 blocks travel, 5 of

    them are prefix, and the reuse is 5/9. Read under the `explicit` model

    this same document reports zero reuse, which is the bug this pins.

    """

    fixture = _FIXTURE.parent / "weka-trace-v1-transcript.json"

    proc = _run([str(fixture)])

    if proc.returncode != 0:

        raise AssertionError(f"tool failed: {proc.stderr}")

    corpus = json.loads(proc.stdout)["corpus"]

    assert corpus["turns"] == 3

    assert corpus["total_blocks"] == 9

    assert corpus["repeated_blocks"] == 5

    assert abs(corpus["prefix_reuse_ratio"] - 5 / 9) < 1e-9

    assert corpus["context_growth"] == 4

    explicit = _run([str(fixture), "--context", "explicit"])

    assert json.loads(explicit.stdout)["corpus"]["repeated_blocks"] == 0

def test_malformed_and_empty_do_not_block_valid() -> None:

    with tempfile.TemporaryDirectory() as d:

        empty = Path(d) / "empty.json"

        empty.write_text("")

        bad = Path(d) / "bad.json"

        bad.write_text("not json")

        proc = _run([str(empty), str(bad), str(_FIXTURE)])

        proc = _run([str(empty), str(bad), str(_FIXTURE), "--context", "explicit"])

        assert proc.returncode == 1, f"expected exit 1, got {proc.returncode}"

        data = json.loads(proc.stdout)

        errors = [f for f in data["files"] if "error" in f]

if __name__ == "__main__":

    failures = 0

    for test in (test_sample_reuse_ratio, test_malformed_and_empty_do_not_block_valid):

    for test in (

        test_sample_reuse_ratio,

        test_transcript_corpus_reuse_ratio,

        test_malformed_and_empty_do_not_block_valid,

    ):

        name = test.__name__

        try:

            test()