src/ctx_init.py

"""ctx_init.py -- One-shot ``ctx-init`` command to bootstrap ~/.claude/ for ctx.

Replaces the legacy ``install.sh`` flow for users who installed via
``pip install claude-ctx``. The goal is a single command that, run
once after installation, produces a working environment:

    $ pip install claude-ctx
    $ ctx-init

What it does:

  1. Ensures ``~/.claude`` + standard subdirectories exist
     (``skills/``, ``agents/``, ``skill-wiki/``, ``skill-quality/``,
     ``backups/``).
  2. Copies the shipped starter config if ``skill-system-config.json``
     is missing (otherwise leaves the user's config alone).
  3. Seeds the starter toolboxes via ``ctx-toolbox init`` if the
     global toolboxes file is empty.
  4. In a terminal, guides first-time users through hooks, graph build,
     model profile, and harness recommendation setup. Automation can
     keep the non-interactive path by passing explicit flags such as
     ``--model-mode skip``; ``--wizard`` forces the prompts.
  5. Optionally: injects PostToolUse + Stop hooks via
     ``ctx-install-hooks``. Skipped unless the wizard or ``--hooks`` asks
     for it, so the user has to opt in to modifying
     ``~/.claude/settings.json``.
  6. Optionally: runs the initial graph/wiki build if missing.
     Skipped unless the wizard or ``--graph`` asks for it — building
     graph from 2k+ skills is a multi-minute operation and not everyone
     wants it.

Idempotent: re-running only writes what's missing. Never overwrites
a user's config or hook settings without an explicit ``--force`` flag.
"""

from __future__ import annotations

import argparse
import json
import os
import re
import subprocess
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any


# ─── Directory layout ───────────────────────────────────────────────────────


_STANDARD_SUBDIRS = (
    "skills",
    "agents",
    "skill-wiki",
    "skill-wiki/entities",
    "skill-wiki/entities/skills",
    "skill-wiki/entities/agents",
    "skill-wiki/entities/mcp-servers",
    "skill-wiki/entities/harnesses",
    "skill-wiki/concepts",
    "skill-wiki/converted",
    "skill-wiki/graphify-out",
    "skill-quality",
    "backups",
)


def _claude_dir() -> Path:
    return Path(os.path.expanduser("~/.claude"))


def ensure_directories(root: Path | None = None) -> list[Path]:
    """Create standard subdirectories. Returns the list of paths created."""
    claude = root if root is not None else _claude_dir()
    claude.mkdir(parents=True, exist_ok=True)
    created: list[Path] = []
    for sub in _STANDARD_SUBDIRS:
        p = claude / sub
        if not p.exists():
            p.mkdir(parents=True, exist_ok=True)
            created.append(p)
    return created


# ─── Config seeding ─────────────────────────────────────────────────────────


_STARTER_USER_CONFIG = """{
  "_comment": "User-level overrides for ctx (claude-ctx) defaults. Edit me.",
  "_config_path": "~/.claude/skill-system-config.json"
}
"""


def seed_user_config(claude: Path, *, force: bool = False) -> Path | None:
    """Write a stub ``skill-system-config.json`` if missing. Returns path if written."""
    target = claude / "skill-system-config.json"
    if target.exists() and not force:
        return None
    target.write_text(_STARTER_USER_CONFIG, encoding="utf-8")
    return target


# ─── Toolbox seeding ────────────────────────────────────────────────────────


@dataclass(frozen=True)
class ToolboxSeedResult:
    returncode: int
    already_present: bool = False


def _toolbox_init_already_present(stderr: str) -> bool:
    return (
        "Global config already has" in stderr
        and "toolbox" in stderr
        and "Use --force to overwrite" in stderr
    )


def seed_toolboxes(*, force: bool = False) -> ToolboxSeedResult:
    """Invoke ``toolbox init`` to drop the 5 starter templates.

    Returns 0 on success, non-zero on failure. Safe to call when the
    global config already has toolboxes — ``toolbox init`` refuses to
    overwrite without ``--force``.
    """
    cmd = [sys.executable, "-m", "toolbox", "init"]
    if force:
        cmd.append("--force")
    result = subprocess.run(cmd, capture_output=True, text=True, check=False)
    if (
        not force
        and result.returncode != 0
        and _toolbox_init_already_present(result.stderr)
    ):
        return ToolboxSeedResult(returncode=0, already_present=True)
    if result.stdout.strip():
        print(result.stdout.rstrip())
    if result.stderr.strip():
        print(result.stderr.rstrip(), file=sys.stderr)
    return ToolboxSeedResult(returncode=result.returncode)


# ─── Hook injection (opt-in) ────────────────────────────────────────────────


def install_hooks(*, ctx_src_dir: Path, settings_path: Path | None = None) -> int:
    """Run ``inject_hooks.main()`` to wire PostToolUse + Stop hooks."""
    target_settings = settings_path or (_claude_dir() / "settings.json")
    cmd = [
        sys.executable, "-m", "ctx.adapters.claude_code.inject_hooks",
        "--settings", str(target_settings),
        "--ctx-dir", str(ctx_src_dir),
    ]
    result = subprocess.run(cmd, capture_output=True, text=True, check=False)
    if result.stdout.strip():
        print(result.stdout.rstrip())
    if result.stderr.strip():
        print(result.stderr.rstrip(), file=sys.stderr)
    return result.returncode


def _resolve_ctx_src_dir() -> Path:
    """Best-guess the directory containing the runtime modules.

    When installed via pip, the modules land in ``<sitepackages>/``. The
    inject_hooks template writes absolute python3 ... paths into the hook
    commands, so we pass in the site-packages directory that *this* file
    lives in.
    """
    return Path(__file__).resolve().parent


# ─── Graph build (opt-in, slow) ─────────────────────────────────────────────


def build_graph() -> int:
    """Run ``wiki_graphify`` to rebuild the knowledge graph."""
    result = subprocess.run(
        [sys.executable, "-m", "ctx.core.wiki.wiki_graphify"],
        capture_output=True, text=True, check=False,
    )
    if result.stdout.strip():
        print(result.stdout.rstrip())
    if result.stderr.strip():
        print(result.stderr.rstrip(), file=sys.stderr)
    return result.returncode


# ─── Model onboarding ───────────────────────────────────────────────────────


_MODEL_PROFILE_NAME = "ctx-model-profile.json"

_HARNESS_TOKEN_RE = re.compile(r"[a-z0-9]+")

_HARNESS_GOAL_NOISE = frozenset({
    "build",
    "create",
    "into",
    "make",
    "turn",
    "write",
    "need",
    "want",
    "using",
    "custom",
    "harness",
    "harnesses",
    "model",
    "models",
    "llm",
    "llms",
    "api",
    "apis",
    "work",
    "workflow",
    "workflows",
    "project",
    "repo",
    "development",
    "dev",
})

_HARNESS_SIGNAL_ALIASES: dict[str, set[str]] = {
    "ai": {"ai", "llm", "model"},
    "agent": {"agent", "agents", "agentic"},
    "agents": {"agent", "agents", "agentic"},
    "browser": {"browser", "web"},
    "cad": {"cad", "3d", "modeling", "modelling"},
    "checkpoint": {"checkpoint", "checkpoints", "checkpointing"},
    "checkpointing": {"checkpoint", "checkpoints", "checkpointing"},
    "cli": {"cli", "command", "commands"},
    "local": {"local", "ollama", "vllm"},
    "mcp": {"mcp", "server", "servers"},
    "openai": {"openai", "gpt"},
    "private": {"private", "local", "offline", "self", "hosted"},
    "python": {"python", "py"},
    "tool": {"tool", "tools"},
    "tools": {"tool", "tools"},
}

_DEFAULT_HARNESS_RELIABILITY_WEIGHTS = {
    "context": 0.34,
    "constraints": 0.33,
    "convergence": 0.33,
}

_HARNESS_RELIABILITY_TERMS = {
    "context": frozenset({
        "context",
        "contexts",
        "document",
        "documents",
        "durable",
        "knowledge",
        "memory",
        "persistent",
        "replay",
        "retrieval",
        "state",
        "wiki",
    }),
    "constraints": frozenset({
        "access",
        "approval",
        "approvals",
        "boundaries",
        "boundary",
        "governance",
        "limits",
        "permission",
        "permissions",
        "policy",
        "policies",
        "rules",
        "sandbox",
        "security",
    }),
    "convergence": frozenset({
        "automated",
        "check",
        "checks",
        "eval",
        "evals",
        "evaluation",
        "gates",
        "idempotence",
        "monitoring",
        "pytest",
        "retries",
        "retry",
        "tests",
        "tracing",
        "validation",
        "verify",
    }),
}

_MODEL_VERSION_PREFIXES = (
    "claude",
    "codellama",
    "deepseek",
    "gemini",
    "glm",
    "gpt",
    "llama",
    "mistral",
    "mixtral",
    "phi",
    "qwen",
)

_PROVIDER_KEY_ENV: dict[str, str] = {
    "openrouter": "OPENROUTER_API_KEY",
    "anthropic": "ANTHROPIC_API_KEY",
    "openai": "OPENAI_API_KEY",
    "gemini": "GEMINI_API_KEY",
    "mistral": "MISTRAL_API_KEY",
    "deepseek": "DEEPSEEK_API_KEY",
    "together": "TOGETHER_API_KEY",
    "groq": "GROQ_API_KEY",
    "ollama": "",
}


def _model_provider_prefix(model: str) -> str:
    return model.split("/", 1)[0] if "/" in model else model


def _resolve_api_key_env(
    explicit: str | None,
    model: str | None,
    provider: str | None,
) -> str | None:
    if explicit is not None:
        return explicit or None
    prefix = provider or (_model_provider_prefix(model) if model else "")
    env_name = _PROVIDER_KEY_ENV.get(prefix, "")
    return env_name or None


def write_model_profile(
    claude: Path,
    profile: dict[str, Any],
    *,
    force: bool = False,
) -> Path | None:
    """Write the user's ctx model/onboarding profile if allowed."""
    target = claude / _MODEL_PROFILE_NAME
    if target.exists() and not force:
        return None
    target.write_text(json.dumps(profile, indent=2) + "\n", encoding="utf-8")
    return target


def recommend_harnesses(
    goal: str,
    *,
    top_k: int = 5,
    model_provider: str | None = None,
    model: str | None = None,
) -> list[dict[str, Any]]:
    """Return high-confidence harness catalog recommendations."""
    if not goal.strip():
        return []
    try:
        from ctx.core.resolve.recommendations import (  # noqa: PLC0415
            query_to_tags,
            recommend_by_tags,
        )
        from ctx_config import cfg  # noqa: PLC0415

        graph = _load_recommendation_graph()
        if graph.number_of_nodes() == 0:
            return []
        limit = max(1, min(int(top_k), cfg.recommendation_top_k))
        candidate_limit = max(limit * 4, 25)
        signals = query_to_tags(goal)
        results = recommend_by_tags(
            graph,
            signals,
            top_n=candidate_limit,
            query=goal,
            entity_types=("harness",),
            min_normalized_score=0.0,
            # Harness fit is recomputed from provider/runtime/capability terms below.
            # Avoid loading local embedding models on the latency-sensitive CLI path.
            use_semantic_query=False,
        )
        results = _add_unranked_harness_candidates(graph, results)
        results = [
            row for row in results
            if _harness_supports_provider(
                graph,
                str(row.get("name") or ""),
                model_provider,
                model=model,
            )
        ]
        installed = _installed_harness_slugs(cfg.claude_dir / "harness-installs")
        if installed:
            results = [
                row for row in results
                if str(row.get("name") or "") not in installed
            ]
        threshold = cfg.harness_recommendation_min_fit_score
        for row in results:
            row.update(_annotate_harness_fit(graph, row, signals))
        if results:
            results = [
                row for row in results
                if float(row.get("fit_score") or 0.0) >= threshold
            ]
            results.sort(
                key=lambda row: (
                    -float(row.get("fit_score") or 0.0),
                    -float(row.get("reliability_score") or 0.0),
                    -float(row.get("normalized_score") or 0.0),
                    str(row.get("name") or ""),
                )
            )
    except Exception as exc:  # noqa: BLE001
        print(
            f"  [warn] harness recommendation failed: {type(exc).__name__}: {exc}",
            file=sys.stderr,
        )
        return []
    return results[:limit]


def _add_unranked_harness_candidates(
    graph: Any,
    results: list[dict[str, Any]],
) -> list[dict[str, Any]]:
    """Add catalog harnesses that tag ranking missed, then let fit scoring decide."""
    expanded = list(results)
    seen = {str(row.get("name") or "") for row in expanded}
    try:
        nodes = graph.nodes(data=True)
    except Exception:
        return expanded
    for node_id, data in nodes:
        if str(data.get("type")) != "harness":
            continue
        slug = str(data.get("label") or str(node_id).rsplit(":", 1)[-1]).strip()
        if not slug or slug in seen:
            continue
        expanded.append({
            "name": slug,
            "type": "harness",
            "score": 75.0,
            "normalized_score": 0.0,
            "matching_tags": [],
            "source": data.get("source") or "catalog",
        })
        seen.add(slug)
    return expanded


def _annotate_harness_fit(
    graph: Any,
    row: dict[str, Any],
    signals: list[str],
) -> dict[str, Any]:
    """Return absolute fit metadata for a harness recommendation row."""
    relevant_signals = _relevant_harness_signals(signals)
    terms = _harness_candidate_terms(graph, row)
    scored_signals: list[str] = []
    matched: list[str] = []
    for signal in relevant_signals:
        signal_matches = _harness_signal_matches(signal, terms)
        if not signal_matches and _looks_like_model_version_signal(signal):
            continue
        scored_signals.append(signal)
        if signal_matches:
            matched.append(signal)
    matched_set = set(matched)
    missing = [
        signal for signal in scored_signals
        if signal not in matched_set
    ]

    coverage = (
        len(matched) / len(scored_signals)
        if scored_signals else 0.0
    )
    breadth = min(len(matched_set) / 3.0, 1.0)
    raw_strength = _clamp_harness_score(float(row.get("score") or 0.0) / 75.0)
    fit_score = round(
        _clamp_harness_score((0.8 * coverage * breadth) + (0.2 * raw_strength)),
        4,
    )
    return {
        "fit_score": fit_score,
        "fit_signals": sorted(matched_set),
        "missing_signals": missing[:8],
        "fit_reason": _harness_fit_reason(matched, scored_signals),
        **_harness_reliability_metadata(terms),
    }


def _harness_fit_reason(matched: list[str], relevant_signals: list[str]) -> str:
    if not relevant_signals:
        return "no concrete goal signals were provided"
    if not matched:
        return "no concrete goal signals matched this harness"
    matched_set = set(matched)
    if len(matched_set) < min(3, len(set(relevant_signals))):
        return "matched too few concrete goal signals: " + ", ".join(sorted(matched_set))
    return "matched concrete goal signals: " + ", ".join(sorted(matched_set))


def _relevant_harness_signals(signals: list[str]) -> list[str]:
    seen: dict[str, None] = {}
    for signal in signals:
        token = signal.strip().lower()
        if len(token) < 3 or token in _HARNESS_GOAL_NOISE:
            continue
        seen.setdefault(token, None)
    return list(seen.keys())


def _looks_like_model_version_signal(signal: str) -> bool:
    token = signal.strip().lower()
    return any(char.isdigit() for char in token) and token.startswith(
        _MODEL_VERSION_PREFIXES
    )


def _harness_candidate_terms(graph: Any, row: dict[str, Any]) -> set[str]:
    terms: set[str] = set()
    slug = str(row.get("name") or "")
    terms.update(_harness_tokens(slug))
    terms.update(_harness_tokens(str(row.get("type") or "")))
    terms.update(_harness_tokens(str(row.get("source") or "")))
    for key in ("matching_tags", "shared_tags", "tags"):
        raw = row.get(key)
        if isinstance(raw, (list, tuple, set, frozenset)):
            for item in raw:
                terms.update(_harness_tokens(str(item)))
    node_data = _harness_node_data(graph, slug)
    for key in ("label", "description", "summary", "source"):
        terms.update(_harness_tokens(str(node_data.get(key) or "")))
    for key in (
        "tags",
        "capabilities",
        "model_providers",
        "runtimes",
        "setup_commands",
        "verify_commands",
        "attach_modes",
        "sources",
    ):
        _add_harness_terms(terms, node_data.get(key))
    wiki_fm = _harness_frontmatter_from_wiki(slug)
    for key in ("title", "description", "summary", "repo_url", "docs_url"):
        terms.update(_harness_tokens(str(wiki_fm.get(key) or "")))
    for key in (
        "tags",
        "capabilities",
        "model_providers",
        "runtimes",
        "setup_commands",
        "verify_commands",
        "attach_modes",
        "sources",
    ):
        _add_harness_terms(terms, wiki_fm.get(key))
    return terms


def _harness_reliability_metadata(terms: set[str]) -> dict[str, Any]:
    """Score the harness-engineering 3C contract: context/constraints/convergence."""
    weights = _harness_reliability_weights()
    dimensions: dict[str, dict[str, Any]] = {}
    weighted_total = 0.0
    total_weight = 0.0
    covered: list[str] = []

    for dimension, required_terms in _HARNESS_RELIABILITY_TERMS.items():
        matched = sorted(required_terms & terms)
        score = _clamp_harness_score(len(matched) / 2.0)
        weight = weights.get(dimension, 0.0)
        weighted_total += weight * score
        total_weight += weight
        if matched:
            covered.append(dimension)
        dimensions[dimension] = {
            "score": round(score, 4),
            "matched_terms": matched[:8],
        }

    reliability_score = round(
        _clamp_harness_score(weighted_total / total_weight)
        if total_weight > 0 else 0.0,
        4,
    )
    return {
        "reliability_score": reliability_score,
        "reliability_dimensions": dimensions,
        "reliability_reason": _harness_reliability_reason(covered),
    }


def _harness_reliability_weights() -> dict[str, float]:
    try:
        from ctx_config import cfg  # noqa: PLC0415

        raw = getattr(cfg, "harness_reliability_weights", None)
    except Exception:
        raw = None
    if not isinstance(raw, dict):
        return dict(_DEFAULT_HARNESS_RELIABILITY_WEIGHTS)
    weights: dict[str, float] = {}
    for dimension, default in _DEFAULT_HARNESS_RELIABILITY_WEIGHTS.items():
        try:
            value = float(raw.get(dimension, default))
        except (TypeError, ValueError):
            value = default
        weights[dimension] = max(0.0, value)
    total = sum(weights.values())
    if total <= 0:
        return dict(_DEFAULT_HARNESS_RELIABILITY_WEIGHTS)
    return {dimension: value / total for dimension, value in weights.items()}


def _harness_reliability_reason(covered: list[str]) -> str:
    if not covered:
        return "no harness reliability signals for context, constraints, or convergence"
    missing = [
        dimension for dimension in _DEFAULT_HARNESS_RELIABILITY_WEIGHTS
        if dimension not in covered
    ]
    if not missing:
        return "covers context, constraints, and convergence"
    return (
        "covers " + ", ".join(covered)
        + "; missing " + ", ".join(missing)
    )


def _add_harness_terms(terms: set[str], raw: object) -> None:
    if isinstance(raw, str):
        terms.update(_harness_tokens(raw))
    elif isinstance(raw, (list, tuple, set, frozenset)):
        for item in raw:
            terms.update(_harness_tokens(str(item)))


def _harness_node_data(graph: Any, slug: str) -> dict[str, Any]:
    try:
        nodes = graph.nodes(data=True)
    except Exception:
        return {}
    for node_id, data in nodes:
        if str(data.get("type")) != "harness":
            continue
        label = str(data.get("label") or "")
        if label == slug or str(node_id).rsplit(":", 1)[-1] == slug:
            return dict(data)
    return {}


def _harness_signal_matches(signal: str, terms: set[str]) -> bool:
    candidates = set(_HARNESS_SIGNAL_ALIASES.get(signal, {signal}))
    candidates.update(_harness_tokens(signal))
    if signal.endswith("ies"):
        candidates.add(signal[:-3] + "y")
    elif signal.endswith("s") and len(signal) > 3:
        candidates.add(signal[:-1])
    else:
        candidates.add(signal + "s")
    return bool(candidates & terms)


def _harness_tokens(value: str) -> set[str]:
    tokens = {
        token for token in _HARNESS_TOKEN_RE.findall(value.lower())
        if len(token) >= 2
    }
    expanded = set(tokens)
    for token in tokens:
        expanded.update(_HARNESS_SIGNAL_ALIASES.get(token, ()))
    return expanded


def _clamp_harness_score(value: float) -> float:
    return max(0.0, min(1.0, value))


def _installed_harness_slugs(manifest_dir: Path) -> set[str]:
    """Return harness slugs with an active install manifest."""
    if not manifest_dir.exists():
        return set()
    slugs: set[str] = set()
    for path in manifest_dir.glob("*.json"):
        try:
            data = json.loads(path.read_text(encoding="utf-8"))
        except Exception:  # noqa: BLE001 - corrupt manifests should not break onboarding.
            continue
        if str(data.get("status") or "installed") != "installed":
            continue
        slug = str(data.get("slug") or path.stem).strip()
        if slug:
            slugs.add(slug)
    return slugs


def _harness_supports_provider(
    graph: Any,
    slug: str,
    model_provider: str | None,
    *,
    model: str | None = None,
) -> bool:
    """Return true when a harness is compatible with the requested provider."""
    requested = _provider_match_candidates(model_provider, model)
    if not requested:
        return True
    providers = _harness_model_providers_from_graph(graph, slug)
    if not providers:
        providers = _harness_model_providers_from_wiki(slug)
    if not providers:
        return True
    if providers.intersection({"model-agnostic", "any", "all", "litellm"}):
        return True
    return bool(requested & providers)


def _provider_match_candidates(
    model_provider: str | None,
    model: str | None,
) -> set[str]:
    providers = {
        candidate for candidate in (
            _normalise_model_provider(model_provider),
            _normalise_model_provider(_model_provider_prefix(model or "")),
        ) if candidate
    }
    parts = [part for part in (model or "").split("/") if part]
    if parts and _normalise_model_provider(parts[0]) in {"openrouter", "litellm"}:
        providers.update(
            _normalise_model_provider(part)
            for part in parts[1:2]
            if _normalise_model_provider(part)
        )
    return providers


def _normalise_model_provider(value: str | None) -> str:
    provider = (value or "").strip().lower()
    if not provider:
        return ""
    aliases = {
        "azure": "azure-openai",
        "azure_openai": "azure-openai",
        "googleai": "google",
        "gemini": "google",
        "local": "ollama",
        "model_agnostic": "model-agnostic",
        "model agnostic": "model-agnostic",
    }
    return aliases.get(provider, provider)


def _normalise_model_providers(raw: object) -> set[str]:
    if raw is None:
        return set()
    if isinstance(raw, str):
        values = [raw]
    elif isinstance(raw, (list, tuple, set, frozenset)):
        values = [str(item) for item in raw]
    else:
        return set()
    return {
        provider for value in values
        if (provider := _normalise_model_provider(value))
    }


def _harness_model_providers_from_graph(graph: Any, slug: str) -> set[str]:
    for _node_id, data in graph.nodes(data=True):
        if str(data.get("type")) != "harness":
            continue
        if str(data.get("label") or "") != slug:
            continue
        return _normalise_model_providers(data.get("model_providers"))
    return set()


def _harness_model_providers_from_wiki(slug: str) -> set[str]:
    return _normalise_model_providers(
        _harness_frontmatter_from_wiki(slug).get("model_providers")
    )


def _harness_frontmatter_from_wiki(slug: str) -> dict[str, Any]:
    try:
        from ctx.core.entity_types import entity_page_path  # noqa: PLC0415
        from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body  # noqa: PLC0415
        from ctx_config import cfg  # noqa: PLC0415

        path = entity_page_path(cfg.wiki_dir, "harness", slug)
        if path is None or not path.is_file():
            return {}
        fm, _body = parse_frontmatter_and_body(
            path.read_text(encoding="utf-8", errors="replace"),
        )
        return fm
    except Exception:
        return {}


def _load_recommendation_graph() -> Any:
    """Load the ctx knowledge graph for harness onboarding."""
    from ctx.core.graph.resolve_graph import load_graph  # noqa: PLC0415
    from ctx_config import cfg  # noqa: PLC0415

    return load_graph(cfg.wiki_dir / "graphify-out" / "graph.json")


def validate_model_connection(
    *,
    model: str,
    api_key_env: str | None,
    base_url: str | None,
) -> int:
    """Make one tiny provider call when the user explicitly asks."""
    try:
        from ctx.adapters.generic.providers import Message, get_provider  # noqa: PLC0415

        client = get_provider(
            default_model=model,
            base_url=base_url,
            api_key_env=api_key_env,
            timeout=30.0,
        )
        client.complete(
            [Message(role="user", content="Reply exactly: ctx-ok")],
            model=model,
            temperature=0.0,
            max_tokens=8,
        )
    except Exception as exc:  # noqa: BLE001
        print(
            f"  [warn] model validation failed: {type(exc).__name__}: {exc}",
            file=sys.stderr,
        )
        return 1
    return 0


def _prompt_yes_no(prompt: str, *, default: bool = False) -> bool:
    suffix = "Y/n" if default else "y/N"
    while True:
        answer = input(f"{prompt} [{suffix}] ").strip().lower()
        if not answer:
            return default
        if answer in {"y", "yes"}:
            return True
        if answer in {"n", "no"}:
            return False
        print("  Please answer yes or no.")


def _prompt_text(prompt: str, *, default: str | None = None) -> str:
    suffix = f" [{default}]" if default else ""
    answer = input(f"{prompt}{suffix}: ").strip()
    return answer or (default or "")


def _prompt_model_mode(default: str = "claude-code") -> str:
    while True:
        answer = input(
            "Use Claude Code or a custom model with ctx? "
            f"[{default}; choices: claude-code/custom/skip] "
        ).strip().lower()
        mode = answer or default
        if mode in {"claude-code", "custom", "skip"}:
            return mode
        print("  Please choose claude-code, custom, or skip.")


def _stdio_is_interactive() -> bool:
    return bool(
        getattr(sys.stdin, "isatty", lambda: False)()
        and getattr(sys.stdout, "isatty", lambda: False)()
    )


def _should_run_wizard(
    args: argparse.Namespace,
    raw_argv: list[str],
) -> bool:
    return bool(args.wizard or (not raw_argv and _stdio_is_interactive()))


def run_wizard(args: argparse.Namespace) -> None:
    """Prompt for first-run choices and mutate parsed args in place."""
    print("ctx-init wizard:")
    args.hooks = _prompt_yes_no(
        "Install Claude Code observation hooks now?",
        default=args.hooks,
    )
    args.graph = _prompt_yes_no(
        "Build the knowledge graph now? This can take a while.",
        default=args.graph,
    )

    args.model_mode = _prompt_model_mode(args.model_mode or "claude-code")
    if args.model_mode == "skip":
        return

    if args.model_mode == "custom":
        args.model = _prompt_text(
            "Model slug, e.g. openai/gpt-5.5 or ollama/llama3.1",
            default=args.model,
        )
        provider_default = args.model_provider or (
            _model_provider_prefix(args.model) if args.model else None
        )
        args.model_provider = _prompt_text(
            "Provider prefix",
            default=provider_default,
        ) or None
        api_key_default = _resolve_api_key_env(
            args.api_key_env,
            args.model,
            args.model_provider,
        )
        args.api_key_env = _prompt_text(
            "API key environment variable (blank for local/no key)",
            default=api_key_default,
        )
        args.base_url = _prompt_text(
            "Provider base URL (blank for default)",
            default=args.base_url,
        ) or None

    args.goal = _prompt_text(
        "What do you want ctx to help you build or maintain?",
        default=args.goal,
    )
    if args.model_mode == "custom":
        args.validate_model = _prompt_yes_no(
            "Validate the model with one tiny provider call now?",
            default=args.validate_model,
        )


def run_model_onboarding(args: argparse.Namespace, claude: Path) -> int:
    """Record model choice and print harness recommendations."""
    mode = args.model_mode
    if mode is None or mode == "skip":
        print("  [skip] model onboarding (run ctx-init --wizard to configure)")
        return 0
    if mode not in {"claude-code", "custom"}:
        print(f"  [warn] unknown model mode: {mode}", file=sys.stderr)
        return 1

    goal = args.goal or ""
    if mode == "custom" and not args.model:
        print("  [warn] --model-mode custom requires --model", file=sys.stderr)
        return 1

    provider = args.model_provider or (
        _model_provider_prefix(args.model) if args.model else None
    )
    api_key_env = _resolve_api_key_env(args.api_key_env, args.model, provider)
    profile: dict[str, Any] = {
        "mode": mode,
        "provider": provider,
        "model": args.model,
        "api_key_env": api_key_env,
        "base_url": args.base_url,
        "goal": goal,
    }
    written = write_model_profile(claude, profile, force=args.force)
    if written:
        print(f"  [ok] wrote {written.name}")
    else:
        print(f"  [skip] {_MODEL_PROFILE_NAME} already present (use --force)")

    rc = 0
    if mode == "custom" and api_key_env and not os.environ.get(api_key_env):
        print(f"  [warn] set {api_key_env} before running ctx with this model")
    if mode == "custom" and args.validate_model:
        rc = validate_model_connection(
            model=args.model,
            api_key_env=api_key_env,
            base_url=args.base_url,
        )
        if rc == 0:
            print("  [ok] model connection validated")

    if mode != "custom":
        return rc

    recommendation_query = " ".join(
        part for part in [goal, provider or "", args.model or "", "harness"]
        if part
    )
    harnesses = recommend_harnesses(
        recommendation_query,
        model_provider=provider,
        model=args.model,
    )
    if harnesses:
        print("  [ok] recommended harnesses:")
        for row in harnesses:
            fit = float(row.get("fit_score") or row.get("normalized_score") or 0.0)
            name = row.get("name")
            print(f"       - {name} (fit {fit:.2f})")
            print(f"         install: ctx-harness-install {name} --dry-run")
    elif goal or mode == "custom":
        print("  [info] no harness recommendations matched yet")
        print(
            "       build plan: ctx-harness-install --recommend "
            f"--goal {json.dumps(goal or args.model or 'custom model work')} "
            f"--model {json.dumps(args.model or '')} --plan-on-no-fit"
        )
    return rc


# ─── CLI ────────────────────────────────────────────────────────────────────


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(
        prog="ctx-init",
        description="Bootstrap ~/.claude/ for ctx (claude-ctx).",
    )
    parser.add_argument(
        "--hooks", action="store_true",
        help="Inject PostToolUse + Stop hooks into ~/.claude/settings.json",
    )
    parser.add_argument(
        "--graph", action="store_true",
        help="Rebuild the knowledge graph after setup (slow: >1 minute)",
    )
    parser.add_argument(
        "--force", action="store_true",
        help="Overwrite existing config files if present",
    )
    parser.add_argument(
        "--wizard",
        action="store_true",
        help=(
            "Prompt for hooks, graph build, model profile, and harness "
            "recommendation setup. Plain ctx-init does this automatically "
            "when run in an interactive terminal."
        ),
    )
    parser.add_argument(
        "--model-mode",
        choices=("claude-code", "custom", "skip"),
        help="Record whether this install uses Claude Code or a custom model",
    )
    parser.add_argument("--model-provider", help="Custom model provider prefix")
    parser.add_argument("--model", help="Custom model slug, e.g. openai/gpt-5.5")
    parser.add_argument(
        "--api-key-env",
        help="Environment variable that stores the custom provider API key",
    )
    parser.add_argument("--base-url", help="Custom provider base URL")
    parser.add_argument(
        "--goal",
        help="What the user wants to build; used for harness recommendations",
    )
    parser.add_argument(
        "--validate-model",
        action="store_true",
        help="Make one tiny provider call to validate the custom model connection",
    )
    raw_argv = sys.argv[1:] if argv is None else list(argv)
    args = parser.parse_args(raw_argv)
    if _should_run_wizard(args, raw_argv):
        run_wizard(args)

    claude = _claude_dir()
    print(f"ctx-init: setting up {claude}")

    created = ensure_directories(claude)
    if created:
        print(f"  [ok] created {len(created)} subdirectories")
    else:
        print("  [ok] all standard subdirectories exist")

    seeded_config = seed_user_config(claude, force=args.force)
    if seeded_config:
        print(f"  [ok] wrote {seeded_config.name}")
    else:
        print("  [skip] skill-system-config.json already present (use --force to overwrite)")

    toolbox_seed = seed_toolboxes(force=args.force)
    if isinstance(toolbox_seed, ToolboxSeedResult):
        toolbox_rc = toolbox_seed.returncode
        toolbox_already_present = toolbox_seed.already_present
    else:
        toolbox_rc = int(toolbox_seed)
        toolbox_already_present = False
    final_rc = 0
    if toolbox_already_present:
        print("  [skip] starter toolboxes already present (use --force to overwrite)")
    elif toolbox_rc == 0:
        print("  [ok] toolboxes seeded")
    else:
        print(f"  [warn] toolbox init returned {toolbox_rc} — inspect above", file=sys.stderr)

    if args.hooks:
        rc = install_hooks(ctx_src_dir=_resolve_ctx_src_dir())
        if rc == 0:
            print("  [ok] PostToolUse + Stop hooks injected")
        else:
            print(f"  [warn] hook injection returned {rc}", file=sys.stderr)
            final_rc = rc
    else:
        print("  [skip] hook injection (pass --hooks to enable)")

    if args.graph:
        rc = build_graph()
        if rc == 0:
            print("  [ok] knowledge graph rebuilt")
        else:
            print(f"  [warn] graph build returned {rc}", file=sys.stderr)
            if final_rc == 0:
                final_rc = rc
    else:
        print("  [skip] graph build (pass --graph to rebuild)")

    rc = run_model_onboarding(args, claude)
    if rc != 0 and final_rc == 0:
        final_rc = rc

    print("\nctx-init: done. Next steps:")
    print("  - ctx-toolbox list                 # see starter toolboxes")
    print("  - ctx-skill-health dashboard       # baseline health scan")
    print("  - ctx-monitor serve                # local dashboard at :8765")
    if not args.hooks:
        print("  - ctx-init --hooks                 # wire live observation")
    if not args.graph:
        print("  - ctx-init --graph                 # build knowledge graph")
    return final_rc


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