Backup/feature engine 2026 03 11 rollback

.gitignore

@@ -0,0 +1,18 @@
+# Never publish private skill variants
+skills/*-private/
+skills/**/private-*/
+skills/**/internal-*/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+
+# SQLite
+*.db
+*.db-wal
+*.db-shm

PUBLISH-CYBERWOODS-PUBLIC.md

@@ -0,0 +1,24 @@
+# Publish Cyberwoods Public Only
+
+## Stage only public skill files
+
+```bash
+git add .gitignore
+git add skills/cyberwoods-public/SKILL.md
+git add skills/cyberwoods-public/agents/openai.yaml
+git add skills/cyberwoods-public/references/threat-model.md
+git add skills/cyberwoods-public/references/adoption-checklist.md
+```
+
+## Commit message template
+
+```txt
+feat(skill): add cyberwoods-public sanitized security review workflow
+```
+
+## Optional verify command
+
+```bash
+git diff --cached --name-only
+```
+

pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "ai-hot-sauce"
+version = "0.1.0"
+description = "Scoring-based multi-model router with circuit breakers, quality gates, and session persistence"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = []
+
+[project.optional-dependencies]
+openai = ["openai>=1.0"]
+anthropic = ["anthropic>=0.40"]
+google = ["google-genai>=1.0"]
+all = ["openai>=1.0", "anthropic>=0.40", "google-genai>=1.0"]
+dev = ["pytest", "pyyaml"]
+
+[project.scripts]
+sauce = "sauce:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

sauce.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""sauce.py — CLI entry point for the Hot Sauce engine.
+
+Usage:
+  python sauce.py "explain this error"           # auto-route to best model
+  python sauce.py "@gemini describe this image"   # explicit model override
+  python sauce.py --stats                         # show model health + breaker states
+  python sauce.py --rank "fix this bug"           # show how models would be ranked
+  python sauce.py --session abc123 "continue..."  # resume a session
+  python sauce.py --reset-breaker gemini-2.5-flash  # manually reset a tripped breaker
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from src.engine import HotSauceEngine
+from src.routing.scorer import classify_task
+
+
+def _build_engine(db_path: str | None = None) -> HotSauceEngine:
+    """Build engine with available providers based on env vars."""
+    engine = HotSauceEngine(db_path=db_path)
+
+    # Only add providers we have keys for
+    if os.environ.get("OPENAI_API_KEY"):
+        from src.providers.openai_provider import OpenAIProvider
+        engine.add_provider(OpenAIProvider())
+
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        from src.providers.anthropic_provider import AnthropicProvider
+        engine.add_provider(AnthropicProvider())
+
+    if os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY"):
+        from src.providers.google_provider import GoogleProvider
+        key = os.environ.get("GOOGLE_API_KEY") or os.environ.get("GEMINI_API_KEY")
+        engine.add_provider(GoogleProvider(api_key=key))
+
+    # Always try Ollama (local, no key needed)
+    try:
+        from src.providers.ollama_provider import OllamaProvider
+        p = OllamaProvider()
+        if p._is_available():
+            engine.add_provider(p)
+    except Exception:
+        pass
+
+    return engine
+
+
+def cmd_chat(args):
+    engine = _build_engine(args.db)
+    sid = engine.session(args.session)
+    result = engine.chat(args.message, session_id=sid, system=args.system)
+    print(result.content)
+    print(f"\n--- [{result.model}] {result.tokens_in}→{result.tokens_out} tokens, "
+          f"{result.latency_ms:.0f}ms, ${result.cost_usd:.6f} ---", file=sys.stderr)
+
+
+def cmd_stats(args):
+    engine = _build_engine(args.db)
+    stats = engine.stats()
+    print(json.dumps(stats, indent=2, default=str))
+
+
+def cmd_rank(args):
+    engine = _build_engine(args.db)
+    task = classify_task(args.message)
+    ranked = engine.router.rank(task)
+    print(f"Task: {task.task_type} | vision={task.needs_vision} | tools={task.needs_tools}")
+    print(f"{'Model':<35} {'Score':>8}")
+    print("-" * 45)
+    for name, score in ranked:
+        breaker_state = engine.breaker.state(name)
+        flag = f" [{breaker_state.upper()}]" if breaker_state != "closed" else ""
+        print(f"{name:<35} {score:>8.4f}{flag}")
+
+
+def cmd_reset_breaker(args):
+    engine = _build_engine(args.db)
+    engine.breaker.reset(args.model)
+    print(f"Breaker reset for {args.model}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Hot Sauce — AI model router + engine")
+    parser.add_argument("--db", help="SQLite database path", default=None)
+    sub = parser.add_subparsers(dest="command")
+
+    # Default: chat
+    chat_p = sub.add_parser("chat", help="Send a message (default)")
+    chat_p.add_argument("message", help="Your message")
+    chat_p.add_argument("--session", "-s", help="Session ID to resume")
+    chat_p.add_argument("--system", help="System prompt")
+    chat_p.set_defaults(func=cmd_chat)
+
+    # Stats
+    stats_p = sub.add_parser("stats", help="Show model health and breaker states")
+    stats_p.set_defaults(func=cmd_stats)
+
+    # Rank
+    rank_p = sub.add_parser("rank", help="Show model ranking for a message")
+    rank_p.add_argument("message", help="Message to classify and rank")
+    rank_p.set_defaults(func=cmd_rank)
+
+    # Reset breaker
+    reset_p = sub.add_parser("reset-breaker", help="Reset a circuit breaker")
+    reset_p.add_argument("model", help="Model name to reset")
+    reset_p.set_defaults(func=cmd_reset_breaker)
+
+    args = parser.parse_args()
+
+    # Default to chat if bare message given
+    if args.command is None:
+        if len(sys.argv) > 1 and not sys.argv[1].startswith("-"):
+            args.message = " ".join(sys.argv[1:])
+            args.session = None
+            args.system = None
+            cmd_chat(args)
+        else:
+            parser.print_help()
+    else:
+        args.func(args)
+
+
+if __name__ == "__main__":
+    main()

src/__init__.py

@@ -0,0 +1,2 @@
+# ai-hot-sauce engine
+__version__ = "0.1.0"

src/engine.py

@@ -0,0 +1,162 @@
+"""Hot Sauce Engine — the main orchestrator.
+
+Wires together: providers → router → breaker → quality gate → persistence.
+This is what replaces "just a README".
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from .providers.base import CompletionResult, Provider
+from .quality.gate import QualityGate, QualityVerdict
+from .routing.breaker import CircuitBreaker
+from .routing.scorer import ScoringRouter, TaskProfile, classify_task
+from .store.db import HotSauceDB
+
+log = logging.getLogger("hotsauce")
+
+MAX_RETRIES = 2  # retry once with same model, then fallback
+
+
+class HotSauceEngine:
+    """Main entry point. Create one, call .chat()."""
+
+    def __init__(
+        self,
+        db_path: Path | str | None = None,
+        providers: list[Provider] | None = None,
+    ):
+        self.db = HotSauceDB(db_path)
+        self.gate = QualityGate()
+
+        # Default to empty — user adds providers they have keys for
+        self._providers: list[Provider] = providers or []
+        self.breaker = CircuitBreaker(self.db)
+        self.router = ScoringRouter(self.db, self._providers, self.breaker)
+        self._session_id: str | None = None
+
+    def add_provider(self, provider: Provider):
+        """Add a provider at runtime."""
+        self._providers.append(provider)
+        self.router = ScoringRouter(self.db, self._providers, self.breaker)
+
+    def session(self, session_id: str | None = None) -> str:
+        """Start or resume a session."""
+        if session_id:
+            existing = self.db.get_session(session_id)
+            if existing:
+                self._session_id = session_id
+                return session_id
+        self._session_id = self.db.create_session()
+        return self._session_id
+
+    def chat(
+        self,
+        message: str,
+        session_id: str | None = None,
+        system: str | None = None,
+        expect_json: bool = False,
+        **kwargs,
+    ) -> CompletionResult:
+        """Send a message, get a quality-checked response.
+
+        Handles: routing → call → quality gate → retry/fallback → persistence.
+        """
+        sid = session_id or self._session_id or self.session()
+
+        # Log user turn
+        self.db.log_turn(sid, "user", message)
+
+        # Build messages from session history
+        turns = self.db.get_turns(sid, limit=50)
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        for t in turns:
+            messages.append({"role": t["role"], "content": t["content"]})
+
+        # Route
+        model_name, provider_name, task = self.router.select(message)
+        ranked = self.router.rank(task)
+        tried_models: set[str] = set()
+
+        for attempt in range(MAX_RETRIES + len(ranked)):
+            if model_name in tried_models:
+                # Move to next model in ranking
+                for name, score in ranked:
+                    if name not in tried_models:
+                        model_name = name
+                        _, provider_name = self.router._model_registry[name]
+                        break
+                else:
+                    break  # exhausted all models
+
+            tried_models.add(model_name)
+            provider = self.router.providers.get(provider_name)
+            if not provider:
+                log.warning(f"Provider {provider_name} not registered, skipping {model_name}")
+                continue
+
+            try:
+                result = provider.timed_complete(model_name, messages, **kwargs)
+
+                # Record health
+                self.db.log_health(model_name, provider_name, True, result.latency_ms)
+                self.breaker.record_success(model_name)
+
+                # Quality gate
+                gate_result = self.gate.check(
+                    result.content,
+                    task_type=task.task_type,
+                    expect_json=expect_json,
+                )
+
+                if gate_result.passed:
+                    # Persist and return
+                    self.db.log_turn(
+                        sid, "assistant", result.content,
+                        model=model_name, provider=provider_name,
+                        latency_ms=result.latency_ms,
+                        tokens_in=result.tokens_in, tokens_out=result.tokens_out,
+                        cost_usd=result.cost_usd, quality_status="pass",
+                    )
+                    return result
+
+                # Quality failed — log and try next model
+                log.warning(f"Quality gate failed for {model_name}: {gate_result.detail}")
+                self.db.log_turn(
+                    sid, "assistant", result.content,
+                    model=model_name, provider=provider_name,
+                    latency_ms=result.latency_ms,
+                    tokens_in=result.tokens_in, tokens_out=result.tokens_out,
+                    cost_usd=result.cost_usd,
+                    quality_status=gate_result.verdict.value,
+                )
+                continue
+
+            except Exception as e:
+                log.error(f"Model {model_name} failed: {e}")
+                self.db.log_health(
+                    model_name, provider_name, False,
+                    error_type=type(e).__name__, error_message=str(e)[:500],
+                )
+                self.breaker.record_failure(model_name)
+                continue
+
+        raise RuntimeError(
+            f"All models exhausted after {len(tried_models)} attempts. "
+            f"Tried: {tried_models}"
+        )
+
+    def stats(self) -> dict[str, Any]:
+        """Get current engine stats — model health, breaker states, session count."""
+        result = {"models": {}, "breakers": {}}
+        for name in self.router._model_registry:
+            result["models"][name] = self.db.get_model_stats(name)
+            breaker = self.db.get_breaker(name)
+            if breaker:
+                result["breakers"][name] = dict(breaker)
+        return result