split-stack 0.2.0__py3-none-any.whl

split_stack/__init__.py

@@ -0,0 +1,106 @@
+from split_stack.advice import stack_recommendation
+from split_stack.benchmark import format_markdown_table, run_benchmark
+from split_stack.complexity import resolve_tier, score_prompt
+from split_stack.hints import list_hints, normalize_step_kind
+from split_stack.discovery import discover_models
+from split_stack.local_models import assign_tiers_from_local, list_local_models
+from split_stack.model_registry import (
+    DeploymentProfileSpec,
+    ModelEntry,
+    ModelRegistry,
+    list_deployment_profiles,
+    load_registry,
+    model_weight,
+    normalize_deployment_profile,
+)
+from split_stack.models import ComplexityTier, RouteDecision, StackAdvice, StepKind, TierMap
+from split_stack.presets import (
+    assign_recommended_tiers,
+    list_recommended_stacks,
+    recommended_models,
+)
+from split_stack.requirements import (
+    Prerequisite,
+    ProfileRequirements,
+    UsageProfile,
+    list_usage_profiles,
+    usage_requirements,
+)
+from split_stack.quantization import (
+    QUANT_MODES,
+    adjust_vram_for_quant,
+    expand_models_for_quant,
+    normalize_quant_mode,
+    pull_guidance_lines,
+    quant_from_env,
+)
+from split_stack.routing import explain_route, route_prompt
+from split_stack.session import (
+    Session,
+    configure,
+    default_profile_from_env,
+    describe_session,
+    explain,
+    get_session,
+    profile_for_vram_gb,
+    route,
+    session_warnings,
+)
+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"
+
+__all__ = [
+    "ComplexityTier",
+    "DeploymentProfileSpec",
+    "ModelRegistry",
+    "Prerequisite",
+    "ProfileRequirements",
+    "QUANT_MODES",
+    "StackAdvice",
+    "StepKind",
+    "RouteDecision",
+    "Session",
+    "TierMap",
+    "UsageProfile",
+    "assign_recommended_tiers",
+    "assign_tiers",
+    "assign_tiers_from_local",
+    "adjust_vram_for_quant",
+    "configure",
+    "default_profile_from_env",
+    "describe_session",
+    "describe_tiers",
+    "discover_models",
+    "explain",
+    "explain_route",
+    "format_markdown_table",
+    "get_session",
+    "list_local_models",
+    "list_deployment_profiles",
+    "list_recommended_stacks",
+    "load_registry",
+    "normalize_quant_mode",
+    "normalize_step_kind",
+    "normalize_deployment_profile",
+    "list_usage_profiles",
+    "model_recommendation_report",
+    "model_weight",
+    "profile_for_vram_gb",
+    "pull_guidance_lines",
+    "quant_from_env",
+    "recommended_models",
+    "route",
+    "route_prompt",
+    "resolve_tier",
+    "score_prompt",
+    "session_warnings",
+    "stack_recommendation",
+    "usage_requirements",
+    "validate_tier_map",
+    "__version__",
+]
+
+# Embedded library use: no import-time stderr. Use ``stack tips`` or ``SPLIT_STACK_IMPORT_TIPS=on``.

split_stack/__main__.py

@@ -0,0 +1,4 @@
+from split_stack.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

split_stack/advice.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from split_stack.models import StackAdvice
+
+
+def stack_recommendation(cursor_override_enabled: bool = False) -> StackAdvice:
+    return StackAdvice(
+        cursor_model="Auto",
+        prose_path="Use Claude/ChatGPT native apps for prose-heavy work",
+        local_path="Use local Ollama for private quick questions and scripts",
+        warn_cursor_override=cursor_override_enabled,
+    )

split_stack/benchmark.py

@@ -0,0 +1,97 @@
+"""Fixed prompt suite for routing benchmarks (no inference required)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from split_stack.poc_models import DEFAULT_POC_STACK
+from split_stack.routing import route_prompt
+from split_stack.tiering import assign_tiers
+
+
+@dataclass(frozen=True)
+class BenchmarkPrompt:
+    id: str
+    prompt: str
+    note: str
+
+
+DEFAULT_MODELS = list(DEFAULT_POC_STACK) + ["qwen3:30b-a3b"]
+
+BENCHMARK_PROMPTS: tuple[BenchmarkPrompt, ...] = (
+    BenchmarkPrompt("b01", "what is caching?", "definition"),
+    BenchmarkPrompt("b02", "what is an API?", "definition"),
+    BenchmarkPrompt("b03", "define idempotency in one paragraph", "short explain"),
+    BenchmarkPrompt("b04", "explain eventual consistency for a junior dev", "medium explain"),
+    BenchmarkPrompt("b05", "compare Redis vs Memcached for session storage", "compare"),
+    BenchmarkPrompt("b06", "outline a plan for adding logging to a Flask app", "plan"),
+    BenchmarkPrompt("b07", "debug why webhook retries duplicate orders", "debug keyword"),
+    BenchmarkPrompt("b08", "design a distributed retry strategy for webhooks", "architecture"),
+    BenchmarkPrompt("b09", "refactor this auth module for testability", "refactor keyword"),
+    BenchmarkPrompt("b10", "prove this retry policy step by step with edge cases", "reasoning"),
+)
+
+
+@dataclass(frozen=True)
+class BenchmarkRow:
+    id: str
+    prompt: str
+    tier: str
+    model: str
+    note: str
+
+
+@dataclass(frozen=True)
+class BenchmarkReport:
+    models: tuple[str, ...]
+    rows: tuple[BenchmarkRow, ...]
+
+    @property
+    def tier_counts(self) -> dict[str, int]:
+        counts: dict[str, int] = {}
+        for row in self.rows:
+            counts[row.tier] = counts.get(row.tier, 0) + 1
+        return counts
+
+
+def run_benchmark(
+    model_names: list[str] | None = None,
+) -> BenchmarkReport:
+    models = model_names or list(DEFAULT_MODELS)
+    tiers = assign_tiers(models)
+    rows: list[BenchmarkRow] = []
+    for item in BENCHMARK_PROMPTS:
+        tier, model = route_prompt(item.prompt, tiers)
+        rows.append(
+            BenchmarkRow(
+                id=item.id,
+                prompt=item.prompt,
+                tier=tier.value,
+                model=model,
+                note=item.note,
+            )
+        )
+    return BenchmarkReport(models=tuple(models), rows=tuple(rows))
+
+
+def format_markdown_table(report: BenchmarkReport) -> str:
+    lines = [
+        "| id | tier | model | note |",
+        "| --- | --- | --- | --- |",
+    ]
+    for row in report.rows:
+        lines.append(f"| {row.id} | {row.tier} | {row.model} | {row.note} |")
+    return "\n".join(lines)
+
+
+def naive_single_model(report: BenchmarkReport) -> str:
+    """Largest model in tier map (simulates always-use-biggest policy)."""
+    tiers = assign_tiers(list(report.models))
+    return tiers.complex
+
+
+def routed_model_mix(report: BenchmarkReport) -> dict[str, int]:
+    counts: dict[str, int] = {}
+    for row in report.rows:
+        counts[row.model] = counts.get(row.model, 0) + 1
+    return counts