#v0.7.0 Cleanup + Perf Implementation Plan

# Canonical list of tool names the CLI accepts. Order matters for the
# argparse choices=... ordering shown in --help.
CODING_TOOLS: tuple[str, ...] = (
    "opencode", "claude-code", "codex", "openclaude", "hermes", "pi",
    "both", "manual",
)

# Set lookup for normalize_tools' validation. Derived from CODING_TOOLS so
# the two cannot drift.
VALID_TOOLS: frozenset[str] = frozenset(CODING_TOOLS)

CODING_TOOLS = ["opencode", "claude-code", "codex", "openclaude", "hermes", "pi", "both", "manual"]
INSTALLABLE_TOOLS = ["opencode", "claude-code", "codex", "openclaude", "hermes", "pi", "both"]

from .intake import CODING_TOOLS as _CODING_TOOLS_TUPLE
# argparse `choices=` expects a list; convert from the canonical tuple.
CODING_TOOLS = list(_CODING_TOOLS_TUPLE)
# Installable subset: every coding tool except the special `manual` value.
# `both` is also installable (it expands to opencode+openclaude at install time).
INSTALLABLE_TOOLS = [t for t in CODING_TOOLS if t != "manual"]

from .intake import DEFAULT_TOOLS, IntakeAnswers, collect_intake, normalize_tools

from .intake import (
    CODING_TOOLS as _CODING_TOOLS_TUPLE,
    DEFAULT_TOOLS,
    IntakeAnswers,
    collect_intake,
    normalize_tools,
)

        if chunk == "both":
            raise CliError(
                cause="`--tool both` was removed in 0.7.0",
                next_step="use `--tool opencode,openclaude` instead",
                link="https://jrs1986.github.io/CodingScaffold/wiki/Upgrading",
            )

def _load_project_intake(target: Path) -> IntakeAnswers:
    from .intake import _normalize_persisted_intake
    ...
    payload = _normalize_persisted_intake(payload)
    ...

def _load_project_intake(target: Path) -> IntakeAnswers:
    path = target / ".coding-scaffold" / "project.json"
    try:
        payload = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return collect_intake(target, IntakeAnswers(), interactive=False)
    if not isinstance(payload, dict):
        return collect_intake(target, IntakeAnswers(), interactive=False)
    raw_tools = payload.get("tools")
    if not isinstance(raw_tools, list):
        raw_tools = []
    tools = [t for t in raw_tools if isinstance(t, str) and t] or list(DEFAULT_TOOLS)
    return collect_intake(
        target,
        IntakeAnswers(
            language=_string_or_none(payload.get("language")),
            project_target=_string_or_none(payload.get("project_target")),
            existing_codebase=_bool_or_none(payload.get("existing_codebase")),
            privacy=_string_or_none(payload.get("privacy")),
            tools=tools,
            preferred_local_model=_string_or_none(payload.get("preferred_local_model")),
            mode=_string_or_none(payload.get("mode")),
        ),
        interactive=False,
    )

def test_both_raises_cli_error_for_programmatic_callers() -> None:
    """Removed in 0.7.0 — programmatic callers get a clear three-line error.

    The CLI itself rejects `--tool both` at argparse (choice validation)
    before normalize_tools runs; this test covers library callers that
    bypass argparse.
    """

    with pytest.raises(CliError) as excinfo:
        normalize_tools(["both"])
    assert "removed in 0.7.0" in excinfo.value.cause
    assert "opencode,openclaude" in excinfo.value.next_step
    assert "Upgrading" in (excinfo.value.link or "")

def test_cli_setup_run_rejects_both_at_argparse(capsys: pytest.CaptureFixture[str]) -> None:
    """Argparse rejects `--tool both` with its standard 'invalid choice' error
    now that the value is no longer in CODING_TOOLS."""

    from coding_scaffold.cli import build_parser
    with pytest.raises(SystemExit):
        build_parser().parse_args(["setup", "run", "--tool", "both", "--target", "."])
    err = capsys.readouterr().err
    assert "invalid choice" in err
    assert "'both'" in err

import json
import os
import platform
import sys
from datetime import datetime, timedelta, timezone

_CACHE_TTL = timedelta(hours=1)


def _cache_path() -> Path:
    """XDG-conformant cache location."""

    base = Path(
        os.environ.get("XDG_CACHE_HOME")
        or Path.home() / ".cache"
    )
    return base / "coding-scaffold" / "hardware.json"


def _cache_key() -> str:
    """OS + arch + Python version — invalidates when any of these change."""

    return (
        f"{platform.system().lower()}"
        f"/{platform.machine()}"
        f"/{sys.version_info.major}.{sys.version_info.minor}"
    )


def _read_cache() -> HardwareProfile | None:
    """Return cached profile if present, fresh, and key-matched. Else None."""

    path = _cache_path()
    try:
        payload = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return None
    if not isinstance(payload, dict):
        return None
    if payload.get("version") != 1 or payload.get("key") != _cache_key():
        return None
    cached_at_raw = payload.get("cached_at", "")
    try:
        cached_at = datetime.fromisoformat(cached_at_raw)
    except (TypeError, ValueError):
        return None
    if datetime.now(timezone.utc) - cached_at > _CACHE_TTL:
        return None
    profile = payload.get("profile")
    if not isinstance(profile, dict):
        return None
    try:
        return HardwareProfile(**profile)
    except TypeError:
        # Cache shape from an older release; ignore.
        return None


def _write_cache(profile: HardwareProfile) -> None:
    """Best-effort write. Failures (read-only FS, permission denied) are
    logged once to stderr and otherwise swallowed."""

    path = _cache_path()
    payload = {
        "version": 1,
        "cached_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
        "key": _cache_key(),
        "profile": profile.to_dict(),
    }
    try:
        path.parent.mkdir(parents=True, exist_ok=True)
        path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    except OSError as exc:
        print(
            f"warning: could not write hardware probe cache to {path}: {exc}",
            file=sys.stderr,
        )

def probe_hardware() -> HardwareProfile:
    ...

def probe_hardware(*, use_cache: bool = True) -> HardwareProfile:
    """Detect hardware features. Results cached for 1 hour by default.

    Pass ``use_cache=False`` to force a fresh probe (e.g. after installing
    a new local runtime like ``ollama`` and wanting `doctor` to see it
    immediately).
    """

    if use_cache:
        cached = _read_cache()
        if cached is not None:
            return cached
    profile = _probe_hardware_fresh()
    _write_cache(profile)
    return profile


def _probe_hardware_fresh() -> HardwareProfile:
    # ... existing body of probe_hardware() moves here unchanged ...

doctor.add_argument(
    "--no-probe-cache",
    action="store_true",
    help="Bypass the hardware probe cache; re-probe live. Use after installing a new local runtime.",
)

"""Coverage for probe_hardware() caching (spec §5)."""

from __future__ import annotations

import json
from datetime import datetime, timedelta, timezone
from pathlib import Path

import pytest

import coding_scaffold.hardware as hardware_module
from coding_scaffold.hardware import HardwareProfile, probe_hardware


@pytest.fixture(autouse=True)
def isolated_cache(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
    """Redirect the cache to a tmp dir so tests don't pollute each other or
    the user's real ~/.cache."""

    monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path))
    yield


def test_first_call_writes_cache(tmp_path: Path) -> None:
    profile = probe_hardware()
    cache_file = tmp_path / "coding-scaffold" / "hardware.json"
    assert cache_file.exists()
    payload = json.loads(cache_file.read_text())
    assert payload["version"] == 1
    assert payload["profile"]["os_name"] == profile.os_name


def test_warm_call_reads_cache(monkeypatch: pytest.MonkeyPatch) -> None:
    fresh_calls: list[int] = []
    real_fresh = hardware_module._probe_hardware_fresh

    def counting_fresh() -> HardwareProfile:
        fresh_calls.append(1)
        return real_fresh()

    monkeypatch.setattr(hardware_module, "_probe_hardware_fresh", counting_fresh)
    probe_hardware()        # populates cache
    probe_hardware()        # should hit cache
    probe_hardware()        # should hit cache
    assert len(fresh_calls) == 1, f"expected 1 fresh probe + 2 cache hits, got {len(fresh_calls)} fresh"


def test_expired_cache_re_probes(tmp_path: Path) -> None:
    probe_hardware()
    cache_file = tmp_path / "coding-scaffold" / "hardware.json"
    payload = json.loads(cache_file.read_text())
    # Backdate cached_at past the TTL window.
    payload["cached_at"] = (
        datetime.now(timezone.utc) - timedelta(hours=2)
    ).isoformat(timespec="seconds")
    cache_file.write_text(json.dumps(payload))
    # Counting wrapper to confirm a fresh probe happened.
    fresh_calls: list[int] = []
    import coding_scaffold.hardware as hw_mod
    real_fresh = hw_mod._probe_hardware_fresh

    def counting_fresh() -> HardwareProfile:
        fresh_calls.append(1)
        return real_fresh()

    hw_mod._probe_hardware_fresh = counting_fresh
    try:
        probe_hardware()
    finally:
        hw_mod._probe_hardware_fresh = real_fresh
    assert len(fresh_calls) == 1


def test_corrupt_cache_re_probes_silently(tmp_path: Path) -> None:
    cache_file = tmp_path / "coding-scaffold" / "hardware.json"
    cache_file.parent.mkdir(parents=True)
    cache_file.write_text("not json{{")
    # Must not raise.
    profile = probe_hardware()
    assert isinstance(profile, HardwareProfile)


def test_wrong_key_cache_re_probes(tmp_path: Path) -> None:
    """Cache from a different OS/arch/Python is ignored."""

    cache_file = tmp_path / "coding-scaffold" / "hardware.json"
    cache_file.parent.mkdir(parents=True)
    cache_file.write_text(json.dumps({
        "version": 1,
        "cached_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
        "key": "wat/wat/9.9",
        "profile": {"os_name": "fake", "arch": "fake", "cpu_count": 1,
                    "ram_gb": 1, "gpu_name": None, "vram_gb": None,
                    "is_wsl": False, "llmfit_available": False,
                    "local_runtimes": []},
    }))
    profile = probe_hardware()
    assert profile.os_name != "fake"


def test_use_cache_false_bypasses_cache(monkeypatch: pytest.MonkeyPatch) -> None:
    fresh_calls: list[int] = []
    real_fresh = hardware_module._probe_hardware_fresh

    def counting_fresh() -> HardwareProfile:
        fresh_calls.append(1)
        return real_fresh()

    monkeypatch.setattr(hardware_module, "_probe_hardware_fresh", counting_fresh)
    probe_hardware()                            # cache miss + write
    probe_hardware(use_cache=False)             # bypass
    probe_hardware(use_cache=False)             # bypass
    assert len(fresh_calls) == 3


def test_unwritable_cache_dir_proceeds_with_warning(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
) -> None:
    # Point cache at a path that can't be created (file in the way).
    blocker = tmp_path / "blocker"
    blocker.write_text("not a directory")
    monkeypatch.setenv("XDG_CACHE_HOME", str(blocker))
    profile = probe_hardware()
    assert isinstance(profile, HardwareProfile)
    err = capsys.readouterr().err
    assert "warning" in err.lower()


def test_doctor_warm_call_is_under_100ms_median() -> None:
    """Perf gate. Spec §5.6 acceptance criterion."""

    import subprocess
    import time
    import statistics
    # Warm the cache.
    subprocess.run(
        ["python", "-m", "coding_scaffold", "doctor", "--target", "/tmp"],
        capture_output=True, check=False,
    )
    runs = []
    for _ in range(5):
        t = time.perf_counter()
        subprocess.run(
            ["python", "-m", "coding_scaffold", "doctor", "--target", "/tmp"],
            capture_output=True, check=False,
        )
        runs.append((time.perf_counter() - t) * 1000)
    median = statistics.median(runs)
    assert median <= 150, (
        f"doctor warm call should be ≤150ms (target 100, allow CI variance), got median={median:.0f}ms"
    )