pantheon-opencode 1.2.0 → 1.2.2

package/src/routing.yml

@@ -1,4 +1,152 @@
 version: 1.0
+presets:
+  go-deepseek:
+    description: "DeepSeek tiering via OpenCode Zen: V4 Pro for planners/reviewers (free on Zen), V4 Flash for implementers, V4 Flash Free for scouts. Vision turns route to MiniMax M3 (opencode-go; Qwen3.7 Plus image input fails on the Go gateway — opencode#29956). Prices verified 2026-08."
+    vision:
+      model: opencode-go/minimax-m3
+      reasoning_effort: medium
+    providers:
+      opencode:
+        baseURL: https://opencode.ai/zen/v1
+        apiKeyEnv: PANTHEON_OPENCODE_API_KEY
+      opencode-go:
+        baseURL: https://opencode.ai/zen/go/v1
+        apiKeyEnv: PANTHEON_OPENCODE_API_KEY
+    agents:
+      athena:     { model: opencode/deepseek-v4-pro,       reasoning_effort: high,   fallback_models: [opencode/mimo-v2.5] }
+      themis:     { model: opencode/deepseek-v4-pro,       reasoning_effort: high,   fallback_models: [opencode/mimo-v2.5] }
+      zeus:       { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      hermes:     { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      aphrodite:  { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      demeter:    { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      prometheus: { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      hephaestus: { model: opencode/deepseek-v4-flash,     reasoning_effort: medium, fallback_models: [opencode/mimo-v2.5] }
+      apollo:     { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+      nyx:        { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+      gaia:       { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+      iris:       { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+      mnemosyne:  { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+      talos:      { model: opencode/deepseek-v4-flash-free, reasoning_effort: low,   fallback_models: [opencode/mimo-v2.5] }
+  go-fast:
+    description: "All 14 agents on DeepSeek V4 Flash via OpenCode Go with reasoning_effort low everywhere. Fastest tier. Vision turns route to MiniMax M2.5 (mimo-v2.5). Prices verified 2026-08."
+    vision:
+      model: opencode-go/mimo-v2.5
+      reasoning_effort: low
+    providers:
+      opencode-go:
+        baseURL: https://opencode.ai/zen/go/v1
+        apiKeyEnv: PANTHEON_OPENCODE_API_KEY
+    agents:
+      athena:     { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      themis:     { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      zeus:       { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      hermes:     { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      aphrodite:  { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      demeter:    { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      prometheus: { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      hephaestus: { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      apollo:     { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      nyx:        { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      gaia:       { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      iris:       { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      mnemosyne:  { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      talos:      { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+  go-claude:
+    description: "Anthropic Claude tiering: Opus 4.8 for planners/reviewers, Sonnet 5 for implementers, Haiku 4.5 for scouts. Vision turns route to Sonnet 5 (native image support). Prices verified 2026-07."
+    vision:
+      model: anthropic/claude-sonnet-5
+      reasoning_effort: medium
+    providers:
+      anthropic:
+        baseURL: https://api.anthropic.com
+        apiKeyEnv: PANTHEON_ANTHROPIC_API_KEY
+    agents:
+      athena:     { model: anthropic/claude-opus-4-8, reasoning_effort: high }
+      themis:     { model: anthropic/claude-opus-4-8, reasoning_effort: high }
+      zeus:       { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      hermes:     { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      aphrodite:  { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      demeter:    { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      prometheus: { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      hephaestus: { model: anthropic/claude-sonnet-5, reasoning_effort: medium }
+      apollo:     { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+      nyx:        { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+      gaia:       { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+      iris:       { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+      mnemosyne:  { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+      talos:      { model: anthropic/claude-haiku-4-5, reasoning_effort: low }
+  go-openai:
+    description: "OpenAI GPT-5.6 family tiering: Sol for planners/reviewers, Terra for implementers, Luna Fast for scouts. Vision turns route to GPT-5.6 Sol. Prices verified 2026-07."
+    vision:
+      model: openai/gpt-5.6-sol
+      reasoning_effort: high
+    providers:
+      openai:
+        baseURL: https://api.openai.com/v1
+        apiKeyEnv: PANTHEON_OPENAI_API_KEY
+    agents:
+      athena:     { model: openai/gpt-5.6-sol, reasoning_effort: high }
+      themis:     { model: openai/gpt-5.6-sol, reasoning_effort: high }
+      zeus:       { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      hermes:     { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      aphrodite:  { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      demeter:    { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      prometheus: { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      hephaestus: { model: openai/gpt-5.6-terra, reasoning_effort: medium }
+      apollo:     { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+      nyx:        { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+      gaia:       { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+      iris:       { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+      mnemosyne:  { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+      talos:      { model: openai/gpt-5.6-luna-fast, reasoning_effort: low }
+  go-premium:
+    description: "Pantheon premium lineup on OpenCode Go (subscription): GLM-5.1 orchestrator, DeepSeek V4 Pro planner, Qwen3.7 Max reviewer, Kimi K2.6 designer, MiniMax M2.7 implementers, DeepSeek V4 Flash scouts. Vision turns route to MiniMax M3 (multimodal; Qwen3.7 Plus image input fails on the Go gateway — opencode#29956). Ported from Oh-My-OpenAgent 'opencode-go' preset. Requires OpenCode Go subscription. Prices verified 2026-08."
+    vision:
+      model: opencode-go/minimax-m3
+      reasoning_effort: medium
+    providers:
+      opencode-go:
+        baseURL: https://opencode.ai/zen/go/v1
+        apiKeyEnv: PANTHEON_OPENCODE_API_KEY
+    agents:
+      zeus:       { model: opencode-go/glm-5.1,           reasoning_effort: medium }
+      athena:     { model: opencode-go/deepseek-v4-pro,   reasoning_effort: high }
+      themis:     { model: opencode-go/qwen3.7-max,       reasoning_effort: high }
+      hermes:     { model: opencode-go/minimax-m2.7,      reasoning_effort: medium }
+      aphrodite:  { model: opencode-go/kimi-k2.6,         reasoning_effort: medium }
+      demeter:    { model: opencode-go/qwen3.7-plus,      reasoning_effort: medium }
+      prometheus: { model: opencode-go/glm-5.2,           reasoning_effort: medium }
+      hephaestus: { model: opencode-go/minimax-m2.7,      reasoning_effort: medium }
+      apollo:     { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      nyx:        { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      gaia:       { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      iris:       { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      mnemosyne:  { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+      talos:      { model: opencode-go/deepseek-v4-flash, reasoning_effort: low }
+  go-free:
+    description: "Pantheon free lineup on OpenCode Zen free tier, $0: Big Pickle orchestrator, Nemotron 3 Ultra Free planner, North Mini Code scouts. Vision turns route to MiniMax M2.5 Free (mimo-v2.5-free, multimodal on Zen free). Ported from Oh-My-OpenAgent 'zen-free' preset. CAUTION: nemotron-3-ultra-free has known intermittent failures (opencode#38028) — switch to go-fast if flaky. Prices verified 2026-08."
+    vision:
+      model: opencode/mimo-v2.5-free
+      reasoning_effort: low
+    providers:
+      opencode:
+        baseURL: https://opencode.ai/zen/v1
+        apiKeyEnv: PANTHEON_OPENCODE_API_KEY
+    agents:
+      zeus:       { model: opencode/big-pickle,             reasoning_effort: medium }
+      athena:     { model: opencode/nemotron-3-ultra-free,  reasoning_effort: high }
+      themis:     { model: opencode/deepseek-v4-flash-free, reasoning_effort: high }
+      hermes:     { model: opencode/deepseek-v4-flash-free, reasoning_effort: medium }
+      aphrodite:  { model: opencode/deepseek-v4-flash-free, reasoning_effort: medium }
+      demeter:    { model: opencode/deepseek-v4-flash-free, reasoning_effort: medium }
+      prometheus: { model: opencode/deepseek-v4-flash-free, reasoning_effort: medium }
+      hephaestus: { model: opencode/deepseek-v4-flash-free, reasoning_effort: medium }
+      apollo:     { model: opencode/north-mini-code-free,   reasoning_effort: low }
+      nyx:        { model: opencode/north-mini-code-free,   reasoning_effort: low }
+      gaia:       { model: opencode/north-mini-code-free,   reasoning_effort: low }
+      iris:       { model: opencode/north-mini-code-free,   reasoning_effort: low }
+      mnemosyne:  { model: opencode/north-mini-code-free,   reasoning_effort: low }
+      talos:      { model: opencode/north-mini-code-free,   reasoning_effort: low }
 agents:
   zeus:
     role: Central orchestrator

package/src/skills/context-compression/SKILL.md

@@ -165,7 +165,7 @@ Score = 0.9×0.30 + 1.0×0.25 + 0.5×0.20 + 0.0×0.15 + 0.9×0.10
 
 ## 4. Semantic Summarization
 
-Zeus generates contextual summaries for CRITICAL and HIGH entries using the semantic-summarize prompt template. 
+Zeus generates contextual summaries for CRITICAL and HIGH entries using the semantic-summarize prompt template.
 Each summary costs ~50 input tokens per entry (uses the same model as Zeus). MEDIUM/LOW entries get mechanical 1-line compression without summarization.
 
 ### Template: CRITICAL (3 lines)

package/src/skills/loop-engineering/SKILL.md

@@ -21,7 +21,7 @@ Controlled iterative refinement for complex problems. Each loop tightens the sol
 Loop 1: Baseline → Implement simplest working version
    ↓ review
 Loop 2: Improve → Optimize for <metric>
-   ↓ review  
+   ↓ review
 Loop 3: Polish → Edge cases, error handling, DX
    ↓ review
 Done

package/src/skills/orchestration-workflow/SKILL.md

@@ -14,9 +14,9 @@ Practical walkthrough for using the multi-agent system end-to-end. This is your
 
 ## Your First Feature (Real Example)
 
-**Scenario:** You want to add JWT authentication to your app.  
-**Time:** ~6-8 hours total (spread across 1-2 days)  
-**Team:** All agents working together  
+**Scenario:** You want to add JWT authentication to your app.
+**Time:** ~6-8 hours total (spread across 1-2 days)
+**Team:** All agents working together
 **Result:** Complete feature with 95% coverage, security audit passed, ready to deploy
 
 ---
@@ -287,14 +287,14 @@ Result:      10x faster queries (~2 hours)
 
 ## Pro Tips
 
-🎯 **Plan First** — Saves 2-3x rework time  
-🎯 **Use Pause Points** — You control when to proceed  
-🎯 **Trust Themis** — Code review catches issues early  
-🎯 **Commit Atomically** — One phase = one commit  
-🎯 **Test First** — RED tests before code  
-🎯 **Coverage Matters** — <80% = blocked, no exceptions  
-🎯 **Security First** — Themis enforces OWASP compliance  
-🎯 **Background Dispatch** — Use OpenCode v1.16.2+ background agents to run independent phases in parallel without polling  
+🎯 **Plan First** — Saves 2-3x rework time
+🎯 **Use Pause Points** — You control when to proceed
+🎯 **Trust Themis** — Code review catches issues early
+🎯 **Commit Atomically** — One phase = one commit
+🎯 **Test First** — RED tests before code
+🎯 **Coverage Matters** — <80% = blocked, no exceptions
+🎯 **Security First** — Themis enforces OWASP compliance
+🎯 **Background Dispatch** — Use OpenCode v1.16.2+ background agents to run independent phases in parallel without polling
 
 ---
 

package/scripts/scrub_secrets.py

@@ -1,281 +0,0 @@
-#!/usr/bin/env python3
-"""
-scrub-secrets.py — Credential scrubber for Memory Bank promotions.
-
-Scrubs credentials, tokens, and secrets from text before promoting it
-to permanent memory bank files. Uses Python 3.9+ stdlib only.
-
-Usage:
-    python3 scripts/scrub-secrets.py --file path/to/file
-        # scrub in-place (with .bak backup)
-    python3 scripts/scrub-secrets.py --stdin
-        # read stdin, write scrubbed to stdout
-    python3 scripts/scrub-secrets.py --audit path/to/file
-        # only report, don't modify
-"""
-
-from __future__ import annotations
-
-import argparse
-import os
-import re
-import sys
-from re import Match
-
-# ---------------------------------------------------------------------------
-# Pattern definitions — order matters (private keys first to catch multi-line)
-# ---------------------------------------------------------------------------
-
-
-def _make_redactor(pattern: str, replacement: str) -> tuple[re.Pattern, str]:
-    """Compile a pattern with DOTALL for multi-line."""
-    return (re.compile(pattern, re.DOTALL), replacement)
-
-
-REDACTORS: list[tuple[re.Pattern, str]] = [
-    # SSH private keys (multi-line, before generic private key)
-    _make_redactor(
-        r"-----BEGIN\s+OPENSSH\s+PRIVATE\s+KEY-----"
-        r".*?-----END\s+OPENSSH\s+PRIVATE\s+KEY-----",
-        "[SSH PRIVATE KEY REDACTED]",
-    ),
-    # Private keys (multi-line, must run before Bearer/JWT)
-    _make_redactor(
-        r"-----BEGIN\s+.*?PRIVATE\s+KEY-----"
-        r".*?-----END\s+.*?PRIVATE\s+KEY-----",
-        "[PRIVATE KEY REDACTED]",
-    ),
-    # Certificates (multi-line)
-    _make_redactor(
-        r"-----BEGIN\s+CERTIFICATE-----"
-        r".*?-----END\s+CERTIFICATE-----",
-        "[CERTIFICATE REDACTED]",
-    ),
-    # Bearer tokens
-    _make_redactor(
-        r"Bearer\s+[A-Za-z0-9\-._~+/]+=*",
-        "Bearer [REDACTED]",
-    ),
-    # JWTs
-    _make_redactor(
-        r"eyJ[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+",
-        "[JWT REDACTED]",
-    ),
-    # GitHub PATs
-    _make_redactor(
-        r"ghp_[A-Za-z0-9]{36}",
-        "[GITHUB TOKEN REDACTED]",
-    ),
-    # OpenAI keys
-    _make_redactor(
-        r"sk-[A-Za-z0-9\-_]{10,}",
-        "[OPENAI KEY REDACTED]",
-    ),
-    # API keys (api_key, api-key, apikey)
-    _make_redactor(
-        r"(api[_-]?key|apikey)\s*[=:]\s*['\"]?[A-Za-z0-9\-_]{8,}",
-        r"\1=[REDACTED]",
-    ),
-    # Passwords / tokens / secrets
-    _make_redactor(
-        r"(token|secret|password)\s*[=:]\s*['\"]?[A-Za-z0-9\-_]{8,}",
-        r"\1=[REDACTED]",
-    ),
-    # AWS Access Keys
-    _make_redactor(
-        r"AKIA[0-9A-Z]{16}",
-        "[AWS KEY REDACTED]",
-    ),
-    # Google API Keys
-    _make_redactor(
-        r"AIza[0-9A-Za-z\-_]{35}",
-        "[GOOGLE API KEY REDACTED]",
-    ),
-    # Slack tokens
-    _make_redactor(
-        r"xox[baprs]-[0-9a-zA-Z-]{20,}",
-        "[SLACK TOKEN REDACTED]",
-    ),
-    # Heroku API Keys (UUID format)
-    _make_redactor(
-        r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
-        "[HEROKU API KEY REDACTED]",
-    ),
-    # Database connection strings (non-greedy to prevent over-matching)
-    _make_redactor(
-        r"postgresql\+?:\/\/.*?:.*?@",
-        "[POSTGRESQL CONNECTION REDACTED]",
-    ),
-    _make_redactor(
-        r"mysql\+?:\/\/.*?:.*?@",
-        "[MYSQL CONNECTION REDACTED]",
-    ),
-    _make_redactor(
-        r"redis\+?:\/\/.*?:.*?@",
-        "[REDIS CONNECTION REDACTED]",
-    ),
-    # .env export statements
-    _make_redactor(
-        r"export\s+\w+=['\"]?\S+",
-        "[ENV EXPORT REDACTED]",
-    ),
-]
-
-# Classification dispatch: prefix → label
-_CLASSIFIERS: list[tuple[str, str]] = [
-    ("-----BEGIN OPENSSH", "ssh_private_key"),
-    ("-----BEGIN CERTIFICATE", "certificate"),
-    ("-----BEGIN", "private_key"),
-    ("Bearer ", "bearer_token"),
-    ("eyJ", "jwt"),
-    ("ghp_", "github_pat"),
-    ("sk-", "openai_key"),
-    ("xox", "slack_token"),
-    ("AKIA", "aws_key"),
-    ("AIza", "google_api_key"),
-    ("postgresql://", "postgresql_conn"),
-    ("mysql://", "mysql_conn"),
-    ("redis://", "redis_conn"),
-    ("export ", "env_export"),
-]
-
-
-def _classify_match(matched: str) -> str:
-    """Return a human-readable label for a matched secret."""
-    for prefix, label in _CLASSIFIERS:
-        if matched.startswith(prefix):
-            return label
-    if re.match(r"api[_-]?key|apikey", matched, re.IGNORECASE):
-        return "api_key"
-    if re.match(r"(token|secret|password)\s*=", matched, re.IGNORECASE):
-        return "credential"
-    if re.match(
-        r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}",
-        matched,
-    ):
-        return "heroku_uuid"
-    return "unknown_secret"
-
-
-def scrub(content: str) -> tuple[str, list[dict]]:
-    """Scrub secrets from *content*.
-
-    Returns (scrubbed_content, redactions) where each redaction dict has:
-        type        — human-readable label for the matched secret
-        position    — (start, end) tuple of character offsets in original
-        replacement — what the secret was replaced with
-
-    Each redactor runs independently so every match in the input is
-    captured exactly once.  Overlapping matches across *different* patterns
-    are possible but extremely unlikely given the pattern design.
-    """
-    redactions: list[dict] = []
-    scrubbed = content
-
-    for pattern, replacement in REDACTORS:
-        # Walk matches in reverse offset order so replacements don't shift
-        # positions of yet-unreplaced matches.
-        matches: list[Match] = list(pattern.finditer(scrubbed))
-        for m in reversed(matches):
-            start, end = m.start(), m.end()
-            matched_text = m.group(0)
-            resolved = m.expand(replacement) if "\\" in replacement else replacement
-
-            redactions.append(
-                {
-                    "type": _classify_match(matched_text),
-                    "position": (start, end),
-                    "replacement": resolved,
-                }
-            )
-            scrubbed = scrubbed[:start] + resolved + scrubbed[end:]
-
-    # Restore original order (positional, ascending)
-    redactions.reverse()
-    return scrubbed, redactions
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-
-def _audit(path: str) -> None:
-    """Print what would be redacted without modifying the file."""
-    with open(path, encoding="utf-8") as fh:
-        content = fh.read()
-    _, redactions = scrub(content)
-    if not redactions:
-        print(f"[OK] {path}: no secrets found")
-        return
-    print(f"[SCAN] {path}: {len(redactions)} potential secret(s) found:")
-    for r in redactions:
-        print(f"   [{r['type']}] at {r['position']} -> {r['replacement']}")
-
-
-def _scrub_file(path: str) -> None:
-    """Scrub file in-place, creating a .bak backup."""
-    with open(path, encoding="utf-8") as fh:
-        content = fh.read()
-    scrubbed, redactions = scrub(content)
-    if not redactions:
-        print(f"[OK] {path}: no secrets found, file unchanged")
-        return
-    # Write backup
-    bak = path + ".bak"
-    if not os.path.exists(bak):
-        os.rename(path, bak)
-    else:
-        print(f"[WARN] {bak} already exists, skipping backup")
-    with open(path, "w", encoding="utf-8") as fh:
-        fh.write(scrubbed)
-    print(
-        f"[SECURE] {path}: {len(redactions)} secret(s) redacted "
-        f"({' + '.join(r['type'] for r in redactions)})"
-    )
-    print(f"   Backup: {bak}")
-
-
-def _scrub_stdin() -> None:
-    """Read stdin, write scrubbed output to stdout."""
-    content = sys.stdin.read()
-    scrubbed, redactions = scrub(content)
-    for r in redactions:
-        print(f"  [REDACTED {r['type']}]", file=sys.stderr)
-    sys.stdout.write(scrubbed)
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Scrub secrets from text before promoting to "
-        "permanent memory bank files.",
-    )
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument(
-        "--file",
-        type=str,
-        help="Scrub file in-place (with .bak backup)",
-    )
-    group.add_argument(
-        "--stdin",
-        action="store_true",
-        help="Read stdin, write scrubbed to stdout",
-    )
-    group.add_argument(
-        "--audit",
-        type=str,
-        help="Only report what would be redacted",
-    )
-
-    args = parser.parse_args()
-
-    if args.file:
-        _scrub_file(args.file)
-    elif args.stdin:
-        _scrub_stdin()
-    elif args.audit:
-        _audit(args.audit)
-
-
-if __name__ == "__main__":
-    main()

package/src/mcp/requirements-mcp-core.txt

@@ -1,5 +0,0 @@
-mcp>=1.28.0
-fastmcp>=3.4.0
-pyyaml>=6.0
-sqlite-vec>=0.1.7
-fastembed>=0.5.0