split-stack 0.2.0__tar.gz → 0.3.0__tar.gz

{split_stack-0.2.0/src/split_stack.egg-info → split_stack-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: split-stack
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python routing library for local LLM agent loops: score prompts, map tiers to model names, embed in your runner.
 Author: Eddie Baumel
 License: MIT

{split_stack-0.2.0 → split_stack-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "split-stack"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python routing library for local LLM agent loops: score prompts, map tiers to model names, embed in your runner."
 readme = "README.md"
 requires-python = ">=3.10"

{split_stack-0.2.0 → split_stack-0.3.0}/src/split_stack/__init__.py

@@ -46,11 +46,12 @@ from split_stack.session import (
     route,
     session_warnings,
 )
+from split_stack.stack_health import check_stack_health, format_stack_health
 from split_stack.startup_tips import emit_import_tips, model_recommendation_report
 from split_stack.tiering import assign_tiers, describe_tiers
 from split_stack.validation import validate_tier_map
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "ComplexityTier",
@@ -98,6 +99,8 @@ __all__ = [
     "score_prompt",
     "session_warnings",
     "stack_recommendation",
+    "check_stack_health",
+    "format_stack_health",
     "usage_requirements",
     "validate_tier_map",
     "__version__",

{split_stack-0.2.0 → split_stack-0.3.0}/src/split_stack/cli.py

@@ -20,6 +20,7 @@ from split_stack.ollama_generate import ask_prompt_json, route_prompt_json
 from split_stack.requirements import UsageProfile, list_usage_profiles, usage_requirements
 from split_stack.presets import assign_recommended_tiers, list_recommended_stacks, recommended_models
 from split_stack.setup_wizard import format_setup_summary, plan_setup, run_setup
+from split_stack.stack_health import check_stack_health, format_stack_health
 from split_stack.tiering import assign_tiers, describe_tiers
 
 
@@ -159,7 +160,47 @@ def _cmd_profiles(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_doctor_check_stack(args: argparse.Namespace) -> int:
+    models = None
+    if args.models:
+        models = [part.strip() for part in args.models.split(",") if part.strip()]
+    report = check_stack_health(
+        profile=args.profile,
+        vram_gb=args.vram_gb,
+        quant=args.quant,
+        base_url=args.base_url,
+        models=models,
+    )
+    if args.json:
+        payload = {
+            "ready": report.ready,
+            "profile": report.profile,
+            "vram_gb": report.vram_gb,
+            "quant": report.quant,
+            "recommended": list(report.recommended),
+            "resolved": list(report.resolved),
+            "missing": list(report.missing),
+            "pool_size": report.pool_size,
+            "inventory_note": report.inventory_note,
+            "findings": [
+                {
+                    "level": item.level,
+                    "code": item.code,
+                    "message": item.message,
+                    "models": list(item.models),
+                }
+                for item in report.findings
+            ],
+        }
+        return _emit_json(payload)
+    print(format_stack_health(report))
+    return 0 if report.ready else 1
+
+
 def _cmd_doctor(args: argparse.Namespace) -> int:
+    if args.check_stack:
+        return _cmd_doctor_check_stack(args)
+
     advice = stack_recommendation(cursor_override_enabled=False)
     print(f"Cursor model: {advice.cursor_model}")
     print(f"Prose path: {advice.prose_path}")
@@ -505,6 +546,27 @@ def main(argv: list[str] | None = None) -> int:
         help="Path to split-stack.models.json (or set SPLIT_STACK_MODELS_CONFIG)",
     )
     _add_quant_arg(doctor_parser)
+    doctor_parser.add_argument(
+        "--check-stack",
+        action="store_true",
+        help="Offline stack health: missing models, duplicates, routing spread (exit 1 if not ready)",
+    )
+    doctor_parser.add_argument(
+        "--vram-gb",
+        type=int,
+        choices=[8, 12, 16, 24, 32],
+        help="GPU VRAM for recommended stack (alternative to --profile)",
+    )
+    doctor_parser.add_argument(
+        "--base-url",
+        default="http://127.0.0.1:11434",
+        help="Ollama base URL for inventory scan",
+    )
+    doctor_parser.add_argument(
+        "--models",
+        help="Comma-separated stack override when using --check-stack",
+    )
+    doctor_parser.add_argument("--json", action="store_true", help="JSON output (with --check-stack)")
     doctor_parser.set_defaults(handler=_cmd_doctor)
 
     requirements_parser = subparsers.add_parser(

{split_stack-0.2.0 → split_stack-0.3.0}/src/split_stack/discovery.py

@@ -240,7 +240,7 @@ def audit_model_folders(
         primary = home if home.is_dir() else None
     return {
         "primary_root": str(primary) if primary else None,
-        "scan_roots": list(manifest_search_paths()),
+        "scan_roots": [str(path) for path in manifest_search_paths()],
         "tag_count": len(locations),
         "locations": {tag: list(paths) for tag, paths in locations.items()},
         "duplicates": duplicates,

split_stack-0.3.0/src/split_stack/poc_models.py

@@ -0,0 +1,201 @@
+"""Workstation stack helpers for demos and compare POC."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from split_stack.discovery import list_model_inventory
+from split_stack.presets import RECOMMENDED_STACKS, recommended_models
+from split_stack.quantization import QAT_STACK_ADDITIONS, normalize_quant_mode
+from split_stack.session import profile_for_vram_gb
+
+DEFAULT_POC_STACK = ["gemma4:e4b", "qwen3:8b", "qwen3:14b"]
+
+VRAM_OPTIONS: tuple[tuple[int, str], ...] = (
+    (8, "8 GB"),
+    (12, "12 GB"),
+    (16, "16 GB"),
+    (24, "24 GB"),
+    (32, "32 GB"),
+)
+
+QUANT_OPTIONS: tuple[tuple[str, str], ...] = (
+    ("default", "Default (PTQ)"),
+    ("qat", "Gemma QAT (int4)"),
+    ("qat_mobile", "Gemma mobile QAT"),
+    ("bf16", "BF16 (full size)"),
+)
+
+_PRESET_VRAM_ALIASES: dict[str, int] = {
+    "mixed_12gb": 12,
+    "mixed_16gb": 16,
+    "qwen_only": 12,
+    "recommended_12gb": 12,
+    "from_inventory": 0,
+}
+
+
+@dataclass(frozen=True)
+class WorkstationStack:
+    vram_gb: int
+    profile: str
+    quant: str
+    models: tuple[str, ...]
+    description: str
+    notes: tuple[str, ...]
+
+
+def list_vram_options() -> tuple[tuple[int, str], ...]:
+    return VRAM_OPTIONS
+
+
+def list_quant_options() -> tuple[tuple[str, str], ...]:
+    return QUANT_OPTIONS
+
+
+def recommended_stack_for_vram(
+    vram_gb: int,
+    *,
+    quant: str | None = None,
+) -> WorkstationStack:
+    profile = profile_for_vram_gb(vram_gb)
+    stack = RECOMMENDED_STACKS[profile]
+    quant_mode = normalize_quant_mode(quant)
+    models = recommended_models(profile, quant=quant_mode)
+    notes: list[str] = []
+    if quant_mode == "qat":
+        extras = QAT_STACK_ADDITIONS.get(profile, ())
+        if extras:
+            notes.append(
+                f"QAT adds {', '.join(extras)} on {vram_gb} GB — Gemma-only int4 runtime sizes."
+            )
+    elif quant_mode == "bf16":
+        notes.append("BF16 uses full Gemma pull sizes — prefer 24 GB+ or datacenter.")
+    return WorkstationStack(
+        vram_gb=vram_gb,
+        profile=profile,
+        quant=quant_mode,
+        models=tuple(models),
+        description=stack.description,
+        notes=tuple(notes),
+    )
+
+
+def models_for_preset(
+    preset_id: str,
+    *,
+    base_url: str = "http://127.0.0.1:11434",
+    profile: str | None = None,
+    quant: str | None = None,
+) -> list[str]:
+    if preset_id == "from_inventory":
+        inventory = list_model_inventory(base_url=base_url)
+        if inventory.suggested_stack:
+            return list(inventory.suggested_stack)
+        return list(DEFAULT_POC_STACK)
+    if preset_id == "qwen_only":
+        return ["qwen3:4b", "qwen3:8b", "qwen3:14b"]
+    if preset_id == "community_agentic":
+        from split_stack.community_picks import focus_stack, vram_tier_for_profile
+
+        tier = vram_tier_for_profile(profile or "workstation_12gb")
+        focus = focus_stack("agentic", vram_tier=tier)
+        if focus and focus.models:
+            return list(focus.models)
+        return list(DEFAULT_POC_STACK)
+    vram = _PRESET_VRAM_ALIASES.get(preset_id)
+    if vram:
+        return list(recommended_stack_for_vram(vram, quant=quant).models)
+    raise ValueError(f"Unknown stack preset '{preset_id}'.")
+
+
+def available_model_pool(
+    *,
+    base_url: str = "http://127.0.0.1:11434",
+    source: str = "both",
+) -> tuple[list[str], str | None]:
+    inventory = list_model_inventory(base_url=base_url)
+    if source == "api":
+        pool = list(inventory.api_models)
+    elif source == "disk":
+        pool = list(inventory.disk_models)
+    else:
+        pool = sorted(set(inventory.api_models) | set(inventory.disk_models))
+    return pool, inventory.note
+
+
+def resolve_stack_against_pool(
+    desired: list[str],
+    installed: list[str],
+) -> tuple[list[str], list[str], str | None]:
+    installed_set = set(installed)
+    matched = [name for name in desired if name in installed_set]
+    missing = [name for name in desired if name not in installed_set]
+    if len(matched) >= 2:
+        return matched, missing, None
+
+    if installed:
+        from split_stack.model_registry import load_registry, model_weight
+
+        registry = load_registry()
+        ranked = sorted(installed, key=lambda name: model_weight(name, registry))
+        if len(ranked) >= 2:
+            warning = (
+                f"Recommended stack not fully installed ({', '.join(desired)}). "
+                f"Using: {', '.join(ranked)}"
+            )
+            return ranked, missing, warning
+        warning = (
+            f"Recommended stack not fully installed. "
+            f"Using only {ranked[0]} — need 2+ models for routing spread."
+        )
+        return ranked, missing, warning
+
+    return desired, missing, f"Using recommended list (not verified against disk): {', '.join(desired)}"
+
+
+def resolve_installed_stack(
+    installed: list[str],
+    *,
+    preset_id: str = "mixed_12gb",
+    base_url: str = "http://127.0.0.1:11434",
+    vram_gb: int | None = None,
+    quant: str | None = None,
+    models: list[str] | None = None,
+) -> tuple[list[str], str | None]:
+    if models:
+        desired = models
+    elif vram_gb is not None:
+        desired = list(recommended_stack_for_vram(vram_gb, quant=quant).models)
+    else:
+        desired = models_for_preset(preset_id, base_url=base_url, quant=quant)
+    resolved, _missing, warning = resolve_stack_against_pool(desired, installed)
+    return resolved, warning
+
+
+def stack_payload(
+    *,
+    vram_gb: int = 16,
+    quant: str | None = "qat",
+    base_url: str = "http://127.0.0.1:11434",
+    source: str = "both",
+    models_override: list[str] | None = None,
+) -> dict[str, object]:
+    stack = recommended_stack_for_vram(vram_gb, quant=quant)
+    desired = list(models_override) if models_override else list(stack.models)
+    pool, inventory_note = available_model_pool(base_url=base_url, source=source)
+    resolved, missing, warning = resolve_stack_against_pool(desired, pool)
+    return {
+        "ready": True,
+        "vram_gb": vram_gb,
+        "profile": stack.profile,
+        "quant": stack.quant,
+        "description": stack.description,
+        "notes": list(stack.notes),
+        "models": desired,
+        "resolved_models": resolved,
+        "missing_models": missing,
+        "warning": warning,
+        "inventory_note": inventory_note,
+        "pool_size": len(pool),
+    }

split_stack-0.3.0/src/split_stack/stack_health.py

@@ -0,0 +1,360 @@
+"""Offline stack health checks — missing models, duplicates, routing spread, quant honesty."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from split_stack.discovery import audit_model_folders, list_model_inventory
+from split_stack.poc_models import resolve_stack_against_pool, stack_payload
+from split_stack.presets import recommended_models
+from split_stack.quantization import adjust_vram_for_quant, normalize_quant_mode, pull_guidance_lines
+from split_stack.session import default_profile_from_env, profile_for_vram_gb
+
+
+@dataclass(frozen=True)
+class ModelTagInfo:
+    name: str
+    size_bytes: int
+    quantization_level: str | None
+
+
+@dataclass(frozen=True)
+class StackHealthFinding:
+    level: str  # ok, warn, error
+    code: str
+    message: str
+    models: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class StackHealthReport:
+    ready: bool
+    profile: str
+    vram_gb: int | None
+    quant: str
+    recommended: tuple[str, ...]
+    resolved: tuple[str, ...]
+    missing: tuple[str, ...]
+    pool_size: int
+    findings: tuple[StackHealthFinding, ...]
+    inventory_note: str | None = None
+
+
+def check_stack_health(
+    *,
+    profile: str | None = None,
+    vram_gb: int | None = None,
+    quant: str | None = None,
+    base_url: str = "http://127.0.0.1:11434",
+    models: list[str] | None = None,
+    source: str = "both",
+) -> StackHealthReport:
+    """Check recommended stack against local inventory (offline; no upstream registry)."""
+    quant_mode = normalize_quant_mode(quant)
+    if vram_gb is not None:
+        resolved_profile = profile_for_vram_gb(vram_gb)
+    else:
+        resolved_profile = profile or default_profile_from_env()
+        vram_gb = _vram_for_profile(resolved_profile)
+
+    if models:
+        recommended = tuple(models)
+        payload = stack_payload(
+            vram_gb=vram_gb or 12,
+            quant=quant_mode,
+            base_url=base_url,
+            source=source,
+            models_override=list(models),
+        )
+        resolved = tuple(payload.get("resolved_models") or ())
+        missing = tuple(payload.get("missing_models") or ())
+        inventory_note = payload.get("inventory_note")
+        if isinstance(inventory_note, str):
+            pass
+        else:
+            inventory_note = None
+        pool_size = int(payload.get("pool_size") or 0)
+    else:
+        recommended = tuple(recommended_models(resolved_profile, quant=quant_mode))
+        inventory = list_model_inventory(base_url=base_url)
+        if source == "api":
+            pool = list(inventory.api_models)
+        elif source == "disk":
+            pool = list(inventory.disk_models)
+        else:
+            pool = sorted(set(inventory.api_models) | set(inventory.disk_models))
+        resolved_list, missing_list, _warning = resolve_stack_against_pool(
+            list(recommended),
+            pool,
+        )
+        resolved = tuple(resolved_list)
+        missing = tuple(missing_list)
+        inventory_note = inventory.note
+        pool_size = len(pool)
+
+    findings: list[StackHealthFinding] = []
+
+    for name in recommended:
+        if name in missing:
+            findings.append(
+                StackHealthFinding(
+                    level="error",
+                    code="missing",
+                    message=f"{name} is recommended but not found in local inventory.",
+                    models=(name,),
+                )
+            )
+        elif name in resolved:
+            findings.append(
+                StackHealthFinding(
+                    level="ok",
+                    code="present",
+                    message=f"{name} is installed.",
+                    models=(name,),
+                )
+            )
+
+    if len(resolved) < 2:
+        findings.append(
+            StackHealthFinding(
+                level="error",
+                code="routing_spread",
+                message=(
+                    f"Only {len(resolved)} model(s) available for routing "
+                    f"({', '.join(resolved) or 'none'}). Need at least 2 for tier spread."
+                ),
+                models=resolved,
+            )
+        )
+    elif missing:
+        findings.append(
+            StackHealthFinding(
+                level="warn",
+                code="partial_stack",
+                message=(
+                    f"Using {len(resolved)} installed model(s); "
+                    f"{len(missing)} recommended tag(s) missing."
+                ),
+                models=resolved,
+            )
+        )
+    else:
+        findings.append(
+            StackHealthFinding(
+                level="ok",
+                code="stack_complete",
+                message=f"All {len(recommended)} recommended model(s) are installed.",
+                models=resolved,
+            )
+        )
+
+    audit = audit_model_folders()
+    duplicate_tags = audit.get("duplicate_tags") or []
+    if duplicate_tags:
+        dup_list = tuple(str(tag) for tag in duplicate_tags)
+        findings.append(
+            StackHealthFinding(
+                level="warn",
+                code="duplicate_tags",
+                message=(
+                    f"Duplicate tags across Ollama folders: {', '.join(dup_list)}. "
+                    "Keep one models directory or run audit cleanup."
+                ),
+                models=dup_list,
+            )
+        )
+
+    findings.extend(
+        _quant_mismatch_findings(
+            quant_mode=quant_mode,
+            model_names=tuple(name for name in resolved if name not in missing),
+            base_url=base_url,
+        )
+    )
+
+    ready = len(resolved) >= 2
+    return StackHealthReport(
+        ready=ready,
+        profile=resolved_profile,
+        vram_gb=vram_gb,
+        quant=quant_mode,
+        recommended=recommended,
+        resolved=resolved,
+        missing=missing,
+        pool_size=pool_size,
+        findings=tuple(findings),
+        inventory_note=inventory_note,
+    )
+
+
+def format_stack_health(report: StackHealthReport) -> str:
+    lines: list[str] = []
+    vram_label = f"{report.vram_gb} GB" if report.vram_gb is not None else report.profile
+    lines.append(f"Stack health ({vram_label}, quant={report.quant})")
+    lines.append(f"  Recommended: {', '.join(report.recommended) or '-'}")
+    lines.append(f"  Resolved:    {', '.join(report.resolved) or '-'}")
+    if report.missing:
+        lines.append(f"  Missing:     {', '.join(report.missing)}")
+    lines.append(f"  Inventory:   {report.pool_size} tag(s) seen (API + disk)")
+    if report.inventory_note:
+        lines.append(f"  Note:        {report.inventory_note}")
+    lines.append("")
+    for item in report.findings:
+        prefix = {"ok": "OK", "warn": "WARN", "error": "ERROR"}.get(item.level, item.level.upper())
+        lines.append(f"  [{prefix}] {item.message}")
+    lines.append("")
+    if report.ready:
+        lines.append("Routing: ready (2+ models)")
+    else:
+        lines.append("Routing: not ready — install more models or adjust profile/VRAM.")
+    return "\n".join(lines)
+
+
+def _vram_for_profile(profile: str) -> int | None:
+    from split_stack.model_registry import DEPLOYMENT_PROFILES
+
+    spec = DEPLOYMENT_PROFILES.get(profile)
+    if spec is None:
+        return None
+    return spec.assumed_vram_gb
+
+
+def _fetch_ollama_tag_info(
+    *,
+    base_url: str = "http://127.0.0.1:11434",
+) -> dict[str, ModelTagInfo]:
+    try:
+        import requests
+    except ImportError:
+        return {}
+
+    url = f"{base_url.rstrip('/')}/api/tags"
+    try:
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()
+    except Exception:
+        return {}
+
+    out: dict[str, ModelTagInfo] = {}
+    payload = response.json() or {}
+    for item in payload.get("models") or []:
+        name = (item.get("name") or "").strip()
+        if not name:
+            continue
+        details = item.get("details") or {}
+        quant = details.get("quantization_level")
+        out[name] = ModelTagInfo(
+            name=name,
+            size_bytes=int(item.get("size") or 0),
+            quantization_level=str(quant) if quant else None,
+        )
+    return out
+
+
+def _is_gemma_tag(name: str) -> bool:
+    family = name.split(":")[0].lower()
+    return family.startswith("gemma")
+
+
+def _tag_suggests_qat(name: str) -> bool:
+    lowered = name.lower()
+    markers = ("qat", "ud-q4", "ud_q4", "unsloth", "gemma-4-qat")
+    return any(marker in lowered for marker in markers)
+
+
+def _tag_suggests_bf16(name: str) -> bool:
+    lowered = name.lower()
+    return "bf16" in lowered or "-it-bf16" in lowered
+
+
+def _quant_mismatch_findings(
+    *,
+    quant_mode: str,
+    model_names: tuple[str, ...],
+    base_url: str,
+) -> list[StackHealthFinding]:
+    if quant_mode == "default":
+        return []
+
+    tag_info = _fetch_ollama_tag_info(base_url=base_url)
+    if not tag_info:
+        return [
+            StackHealthFinding(
+                level="warn",
+                code="quant_check_skipped",
+                message=(
+                    "Quant check skipped — Ollama /api/tags unreachable or "
+                    "install split-stack[ollama] for requests."
+                ),
+            )
+        ]
+
+    findings: list[StackHealthFinding] = []
+    gemma_tags = [name for name in model_names if _is_gemma_tag(name)]
+    if not gemma_tags:
+        return findings
+
+    for name in gemma_tags:
+        info = tag_info.get(name)
+        if info is None:
+            continue
+
+        expected_gb = adjust_vram_for_quant(name, base_vram_gb=999, quant_mode=quant_mode)
+        size_gb = info.size_bytes / (1024**3) if info.size_bytes else 0.0
+        quant_label = info.quantization_level or "unknown"
+
+        if quant_mode == "bf16":
+            if not _tag_suggests_bf16(name) and quant_label not in {"F16", "BF16", "FP16"}:
+                findings.append(
+                    StackHealthFinding(
+                        level="warn",
+                        code="quant_mismatch",
+                        message=(
+                            f"{name}: quant=bf16 but installed as {quant_label} "
+                            f"({size_gb:.1f} GB on disk). VRAM sizing may be wrong."
+                        ),
+                        models=(name,),
+                    )
+                )
+            continue
+
+        # qat / qat_mobile — expect smaller runtime than library Q4_K_M pulls
+        if _tag_suggests_qat(name):
+            findings.append(
+                StackHealthFinding(
+                    level="ok",
+                    code="quant_ok",
+                    message=f"{name}: tag looks QAT-aligned ({quant_label}, {size_gb:.1f} GB).",
+                    models=(name,),
+                )
+            )
+            continue
+
+        oversized = expected_gb is not None and size_gb > expected_gb * 1.35
+        library_ptq = quant_label in {"Q4_K_M", "Q4_0", "Q5_K_M", "Q5_0"}
+        if oversized or library_ptq:
+            expected_text = f"~{expected_gb} GB runtime" if expected_gb else "smaller QAT runtime"
+            findings.append(
+                StackHealthFinding(
+                    level="warn",
+                    code="quant_mismatch",
+                    message=(
+                        f"{name}: quant={quant_mode} expects {expected_text} but installed "
+                        f"{quant_label} at {size_gb:.1f} GB — likely library PTQ, not QAT."
+                    ),
+                    models=(name,),
+                )
+            )
+
+    if any(item.code == "quant_mismatch" for item in findings):
+        hint = pull_guidance_lines(quant_mode)
+        if hint:
+            findings.append(
+                StackHealthFinding(
+                    level="warn",
+                    code="quant_hint",
+                    message=hint[0],
+                )
+            )
+
+    return findings

{split_stack-0.2.0 → split_stack-0.3.0/src/split_stack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: split-stack
-Version: 0.2.0
+Version: 0.3.0
 Summary: Python routing library for local LLM agent loops: score prompts, map tiers to model names, embed in your runner.
 Author: Eddie Baumel
 License: MIT

{split_stack-0.2.0 → split_stack-0.3.0}/src/split_stack.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ src/split_stack/requirements.py
 src/split_stack/routing.py
 src/split_stack/session.py
 src/split_stack/setup_wizard.py
+src/split_stack/stack_health.py
 src/split_stack/startup_tips.py
 src/split_stack/tiering.py
 src/split_stack/validation.py
@@ -53,5 +54,6 @@ tests/test_routing.py
 tests/test_session.py
 tests/test_setup.py
 tests/test_setup_cli.py
+tests/test_stack_health.py
 tests/test_startup_tips.py
 tests/test_tiering.py

{split_stack-0.2.0 → split_stack-0.3.0}/tests/test_hints.py

@@ -1,7 +1,7 @@
 from split_stack.discovery import discover_models_from_disk, list_model_inventory, manifest_search_paths
 from split_stack.hints import canonical_hint_id, list_hints, normalize_step_kind
 from split_stack.models import StepKind
-from split_stack.poc_models import models_for_preset, resolve_installed_stack
+from split_stack.poc_models import models_for_preset, recommended_stack_for_vram, resolve_installed_stack, stack_payload
 
 
 def test_hint_catalog_has_five_entries():
@@ -29,6 +29,19 @@ def test_resolve_installed_stack_falls_back():
     assert warning is not None
 
 
+def test_recommended_stack_for_vram_16gb_qat_adds_gemma26():
+    stack = recommended_stack_for_vram(16, quant="qat")
+    assert stack.profile == "workstation_16gb"
+    assert "gemma4:26b-a4b" in stack.models
+
+
+def test_stack_payload_vram_quant_keys():
+    payload = stack_payload(vram_gb=16, quant="qat")
+    assert payload["vram_gb"] == 16
+    assert payload["quant"] == "qat"
+    assert "gemma4:26b-a4b" in payload["models"]
+
+
 def test_discover_models_from_disk_finds_user_layout():
     roots = manifest_search_paths()
     disk = discover_models_from_disk()

{split_stack-0.2.0 → split_stack-0.3.0}/tests/test_setup_cli.py

@@ -28,3 +28,26 @@ def test_stack_setup_json(mock_run_setup, capsys):
     assert payload["ready"] is True
     assert payload["profile"] == "workstation_12gb"
     assert "qwen3:14b" in payload["pulled"]
+
+
+def test_stack_doctor_check_stack_json(capsys):
+    from split_stack.discovery import ModelInventory
+
+    inventory = ModelInventory(
+        api_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b", "deepseek-r1:8b", "gemma4:26b-a4b"),
+        disk_models=(),
+        manifest_roots=(),
+        suggested_stack=("gemma4:e4b", "qwen3:8b", "qwen3:14b"),
+        note=None,
+    )
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": []},
+        ):
+            exit_code = main(["doctor", "--check-stack", "--vram-gb", "16", "--quant", "qat", "--json"])
+    payload = json.loads(capsys.readouterr().out.strip())
+    assert exit_code == 0
+    assert payload["ready"] is True
+    assert payload["profile"] == "workstation_16gb"
+    assert payload["quant"] == "qat"

split_stack-0.3.0/tests/test_stack_health.py

@@ -0,0 +1,112 @@
+from unittest.mock import patch
+
+from split_stack.discovery import ModelInventory
+from split_stack.stack_health import ModelTagInfo, check_stack_health, format_stack_health
+
+
+def test_check_stack_health_all_present():
+    inventory = ModelInventory(
+        api_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b", "deepseek-r1:8b"),
+        disk_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b", "deepseek-r1:8b"),
+        manifest_roots=("/models",),
+        suggested_stack=("gemma4:e4b", "qwen3:8b", "qwen3:14b"),
+        note=None,
+    )
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": []},
+        ):
+            report = check_stack_health(profile="workstation_12gb", quant="default")
+    assert report.ready is True
+    assert report.missing == ()
+    assert "gemma4:e4b" in report.resolved
+    codes = {item.code for item in report.findings}
+    assert "stack_complete" in codes
+    assert "routing_spread" not in codes
+
+
+def test_check_stack_health_missing_and_routing_blocked():
+    inventory = ModelInventory(
+        api_models=("qwen3:8b",),
+        disk_models=("qwen3:8b",),
+        manifest_roots=("/models",),
+        suggested_stack=("qwen3:8b",),
+        note=None,
+    )
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": []},
+        ):
+            report = check_stack_health(profile="workstation_12gb", quant="default")
+    assert report.ready is False
+    assert "gemma4:e4b" in report.missing
+    codes = {item.code for item in report.findings}
+    assert "missing" in codes
+    assert "routing_spread" in codes
+
+
+def test_check_stack_health_duplicate_tags_warn():
+    inventory = ModelInventory(
+        api_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b"),
+        disk_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b"),
+        manifest_roots=("/a", "/b"),
+        suggested_stack=("gemma4:e4b", "qwen3:8b", "qwen3:14b"),
+        note=None,
+    )
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": ["qwen3:8b"]},
+        ):
+            report = check_stack_health(vram_gb=16, quant="qat")
+    assert any(item.code == "duplicate_tags" for item in report.findings)
+    assert report.profile == "workstation_16gb"
+
+
+def test_format_stack_health_includes_routing_line():
+    inventory = ModelInventory(
+        api_models=("qwen3:8b",),
+        disk_models=(),
+        manifest_roots=(),
+        suggested_stack=("qwen3:8b",),
+        note="Ollama API unreachable.",
+    )
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": []},
+        ):
+            report = check_stack_health(profile="workstation_12gb")
+    text = format_stack_health(report)
+    assert "Stack health" in text
+    assert "Routing: not ready" in text
+    assert "Ollama API unreachable" in text
+
+
+def test_quant_mismatch_warns_library_gemma_with_qat_mode():
+    inventory = ModelInventory(
+        api_models=("gemma4:e4b", "qwen3:8b", "qwen3:14b", "deepseek-r1:8b"),
+        disk_models=(),
+        manifest_roots=(),
+        suggested_stack=(),
+        note=None,
+    )
+    tag_info = {
+        "gemma4:e4b": ModelTagInfo(
+            name="gemma4:e4b",
+            size_bytes=9_608_350_718,
+            quantization_level="Q4_K_M",
+        ),
+    }
+    with patch("split_stack.stack_health.list_model_inventory", return_value=inventory):
+        with patch(
+            "split_stack.stack_health.audit_model_folders",
+            return_value={"duplicate_tags": []},
+        ):
+            with patch("split_stack.stack_health._fetch_ollama_tag_info", return_value=tag_info):
+                report = check_stack_health(profile="workstation_12gb", quant="qat")
+    codes = {item.code for item in report.findings}
+    assert "quant_mismatch" in codes
+    assert any("gemma4:e4b" in item.message for item in report.findings)

split_stack-0.2.0/src/split_stack/poc_models.py

@@ -1,131 +0,0 @@
-"""Default model stacks for POC demos and compare benchmarks."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from split_stack.community_picks import focus_stack, vram_tier_for_profile
-from split_stack.discovery import list_model_inventory
-from split_stack.presets import recommended_models
-
-DEFAULT_POC_STACK = ["gemma4:e4b", "qwen3:8b", "qwen3:14b"]
-QWEN_ONLY_STACK = ["qwen3:4b", "qwen3:8b", "qwen3:14b"]
-
-
-@dataclass(frozen=True)
-class StackPreset:
-    id: str
-    label: str
-    models: tuple[str, ...]
-    description: str
-
-
-STACK_PRESETS: tuple[StackPreset, ...] = (
-    StackPreset(
-        id="mixed_12gb",
-        label="Mixed 12 GB (Gemma + Qwen)",
-        models=tuple(DEFAULT_POC_STACK),
-        description="Gemma lookup, Qwen 8B medium, Qwen 14B complex",
-    ),
-    StackPreset(
-        id="qwen_only",
-        label="Qwen only (4B / 8B / 14B)",
-        models=tuple(QWEN_ONLY_STACK),
-        description="Single-family ladder",
-    ),
-    StackPreset(
-        id="recommended_12gb",
-        label="Full 12 GB specialist",
-        models=tuple(recommended_models("workstation_12gb")),
-        description="Gemma + Qwen + DeepSeek R1 for reasoning",
-    ),
-    StackPreset(
-        id="community_agentic",
-        label="Reddit agentic (M tier)",
-        models=tuple(),
-        description="r/LocalLLaMA Apr 2026 — Gemma lookup + Qwen spine for agent loops",
-    ),
-    StackPreset(
-        id="from_inventory",
-        label="From your Ollama (auto ladder)",
-        models=tuple(),
-        description="Picks small/mid/large tags from API + disk manifests",
-    ),
-)
-
-
-def list_stack_presets() -> tuple[StackPreset, ...]:
-    return STACK_PRESETS
-
-
-def models_for_preset(
-    preset_id: str,
-    *,
-    base_url: str = "http://127.0.0.1:11434",
-    profile: str = "workstation_12gb",
-) -> list[str]:
-    if preset_id == "from_inventory":
-        inventory = list_model_inventory(base_url=base_url)
-        if inventory.suggested_stack:
-            return list(inventory.suggested_stack)
-        return list(DEFAULT_POC_STACK)
-    if preset_id == "community_agentic":
-        tier = vram_tier_for_profile(profile)
-        stack = focus_stack("agentic", vram_tier=tier)
-        if stack and stack.models:
-            return list(stack.models)
-        return list(DEFAULT_POC_STACK)
-    for item in STACK_PRESETS:
-        if item.id == preset_id:
-            return list(item.models)
-    valid = ", ".join(item.id for item in STACK_PRESETS)
-    raise ValueError(f"Unknown stack preset '{preset_id}'. Valid: {valid}")
-
-
-def available_model_pool(
-    *,
-    base_url: str = "http://127.0.0.1:11434",
-    source: str = "both",
-) -> tuple[list[str], str | None]:
-    """Return model names from Ollama API, disk manifests, or both."""
-    inventory = list_model_inventory(base_url=base_url)
-    if source == "api":
-        pool = list(inventory.api_models)
-    elif source == "disk":
-        pool = list(inventory.disk_models)
-    else:
-        pool = sorted(set(inventory.api_models) | set(inventory.disk_models))
-    return pool, inventory.note
-
-
-def resolve_installed_stack(
-    installed: list[str],
-    *,
-    preset_id: str = "mixed_12gb",
-    base_url: str = "http://127.0.0.1:11434",
-) -> tuple[list[str], str | None]:
-    """Pick preset models that exist in the installed pool; warn when falling back."""
-    desired = models_for_preset(preset_id, base_url=base_url)
-    installed_set = set(installed)
-    matched = [name for name in desired if name in installed_set]
-    if len(matched) >= 2:
-        return matched, None
-
-    if installed:
-        from split_stack.model_registry import load_registry, model_weight
-
-        registry = load_registry()
-        ranked = sorted(installed, key=lambda name: model_weight(name, registry))
-        if len(ranked) >= 2:
-            warning = (
-                f"Preset '{preset_id}' not fully available ({', '.join(desired)}). "
-                f"Using: {', '.join(ranked)}"
-            )
-            return ranked, warning
-        warning = (
-            f"Preset '{preset_id}' not fully available. "
-            f"Using only {ranked[0]} — need 2+ models for compare spread."
-        )
-        return ranked, warning
-
-    return desired, f"Using preset list (not verified): {', '.join(desired)}"