wicked-garden 12.27.0

package/scripts/setup/migrate_v6_projects.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+"""migrate_v6_projects.py — Detect + (optionally) migrate v6-v10 crew
+projects to v11 archetype-mode.
+
+The v6-v10 universal-pipeline machinery was deleted wholesale in
+v11.0.0. Any existing project state on disk references concepts the
+v11 phase_manager no longer understands — `process-plan.json`, the
+9-phase universal plan, gate-result.json files, conditions-manifest,
+reeval-log, etc. The v11 phase_manager loads those records but the
+plan / gate / addendum machinery is gone.
+
+This script:
+  1. Detects v6-v10 projects in the wicked-crew DomainStore.
+  2. Optionally migrates each one to v11 by mapping the v6 phase
+     plan to the closest v11 archetype + stamping
+     phase_plan_mode="archetype" on the project state.
+
+The mapping is best-effort — many v6 plans don't fit cleanly into
+a single v11 archetype. The default mapping uses the v6 phase
+list to pick the v11 archetype that best matches:
+
+  v6 plan contains 'cutover' or 'expand' / 'backfill' → migrate
+  v6 plan = ['triage', 'investigate', ...]            → incident
+  v6 plan = ['canary', 'ramp', 'full', ...]           → ship
+  v6 plan = ['scope', 'assess', 'findings', ...]      → review
+  v6 plan = ['elicit', 'structure', ...]              → specify
+  v6 plan = ['frame', 'diverge', 'converge']          → explore
+  v6 plan = ['brief', 'options', 'score', 'record']   → decide
+  default                                             → build
+
+The script defaults to dry-run. Use --apply to actually mutate state.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+_SCRIPTS = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(_SCRIPTS))
+
+
+_PHASE_HINTS_TO_ARCHETYPE: Tuple[Tuple[Tuple[str, ...], str], ...] = (
+    # First match wins. Most-specific patterns first.
+    (("expand", "backfill", "cutover", "contract"), "migrate"),
+    (("cutover",), "migrate"),
+    (("canary", "ramp", "full", "soak"), "ship"),
+    (("triage", "investigate", "mitigate"), "incident"),
+    (("scope", "assess", "findings", "remediate-or-accept"), "review"),
+    (("scope", "assess", "findings"), "review"),
+    (("elicit", "structure", "validate"), "specify"),
+    (("frame", "diverge", "converge"), "explore"),
+    (("brief", "options", "score", "record"), "decide"),
+    # Universal-pipeline plans land here:
+    (("clarify", "design", "build", "test", "review"), "build"),
+)
+
+
+def _classify_phase_plan(phase_plan: List[str]) -> str:
+    """Pick the v11 archetype that best matches a v6 phase plan."""
+    if not phase_plan:
+        return "build"
+    plan_set = set(phase_plan)
+    for phases_required, archetype in _PHASE_HINTS_TO_ARCHETYPE:
+        if all(p in plan_set for p in phases_required):
+            return archetype
+    return "build"  # safe default
+
+
+def _map_to_v11_phases(archetype: str) -> List[str]:
+    """Read .claude-plugin/archetypes.json for the canonical phase list."""
+    catalog_path = (
+        Path(__file__).resolve().parents[2]
+        / ".claude-plugin" / "archetypes.json"
+    )
+    catalog = json.loads(catalog_path.read_text(encoding="utf-8"))
+    return list(
+        catalog.get("archetypes", {}).get(archetype, {}).get("phases", [])
+    )
+
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+def detect_v6_projects() -> List[Dict]:
+    """Return a list of projects whose state looks like v6-v10 universal-
+    pipeline output (i.e. phase_plan_mode != 'archetype' AND non-empty
+    phase_plan)."""
+    try:
+        from _domain_store import DomainStore
+    except ImportError:
+        return []
+
+    sm = DomainStore("projects")
+    try:
+        all_records = sm.list("projects")
+    except Exception:
+        all_records = []
+
+    legacy = []
+    for rec in (all_records or []):
+        if not isinstance(rec, dict):
+            continue
+        extras = rec.get("extras") or {}
+        mode = extras.get("phase_plan_mode")
+        plan = rec.get("phase_plan") or []
+        if mode == "archetype":
+            continue  # already v11
+        if not plan:
+            continue  # no phase plan to migrate
+        legacy.append(rec)
+    return legacy
+
+
+# ---------------------------------------------------------------------------
+# Migration
+# ---------------------------------------------------------------------------
+
+def migrate_one(project_record: Dict, *, dry_run: bool = True) -> Dict:
+    """Translate a single v6 project to v11 archetype-mode.
+
+    Returns a dict describing the migration: {name, from_phases,
+    chosen_archetype, to_phases, applied}.
+    """
+    name = project_record.get("name") or project_record.get("id")
+    from_phases = list(project_record.get("phase_plan") or [])
+    archetype = _classify_phase_plan(from_phases)
+    to_phases = _map_to_v11_phases(archetype)
+
+    result = {
+        "name": name,
+        "from_phases": from_phases,
+        "chosen_archetype": archetype,
+        "to_phases": to_phases,
+        "applied": False,
+    }
+
+    if dry_run:
+        return result
+
+    # Apply: mutate state via the v11 phase_manager API
+    try:
+        from _domain_store import DomainStore
+    except ImportError:
+        return result
+
+    sm = DomainStore("projects")
+    record = dict(project_record)
+    record["phase_plan"] = to_phases
+    extras = dict(record.get("extras") or {})
+    extras["phase_plan_mode"] = "archetype"
+    extras["v11_archetype"] = archetype
+    extras["v11_migrated_at"] = _utc_now()
+    extras["v11_migration_source"] = {
+        "from_phases": from_phases,
+        "chosen_archetype": archetype,
+    }
+    record["extras"] = extras
+    sm.update("projects", name, record)
+    result["applied"] = True
+    return result
+
+
+def _utc_now() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def _cli() -> None:
+    parser = argparse.ArgumentParser(
+        description="Detect + migrate v6-v10 crew projects to v11 archetype-mode."
+    )
+    parser.add_argument("--apply", action="store_true",
+                        help="Actually mutate state. Without this flag, prints what would happen.")
+    parser.add_argument("--name", default=None,
+                        help="Migrate only the project with this name.")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    legacy = detect_v6_projects()
+    if args.name:
+        legacy = [p for p in legacy if p.get("name") == args.name]
+
+    if not legacy:
+        if args.json:
+            print(json.dumps({"status": "CLEAN", "migratable": []}))
+        else:
+            print("CLEAN: no v6-v10 projects detected.")
+        return
+
+    results = [
+        migrate_one(p, dry_run=not args.apply) for p in legacy
+    ]
+
+    if args.json:
+        print(json.dumps({
+            "status": "MIGRATABLE_FOUND" if not args.apply else "APPLIED",
+            "count": len(results),
+            "results": results,
+        }, indent=2, default=str))
+    else:
+        print(
+            f"{'APPLIED' if args.apply else 'DRY-RUN'}: "
+            f"{len(results)} v6-v10 project(s) "
+            f"{'migrated' if args.apply else 'detected'}"
+        )
+        for r in results:
+            arrow = "→"
+            print(
+                f"  {r['name']}: {' → '.join(r['from_phases'][:5])}"
+                f"{'...' if len(r['from_phases']) > 5 else ''} "
+                f"{arrow} archetype={r['chosen_archetype']} "
+                f"({' → '.join(r['to_phases'])})"
+            )
+        if not args.apply:
+            print(
+                "\nRe-run with --apply to perform the migration. "
+                "The legacy phase_plan is recorded in extras.v11_migration_source."
+            )
+
+
+if __name__ == "__main__":
+    _cli()

package/scripts/setup/onboarding.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""onboarding.py — onboarding-gate state mutations for /wicked-garden:setup.
+
+Section 6 of the setup command flips a handful of SessionState fields
+once onboarding finishes (or is skipped). The mutation was inlined in
+markdown; this module wraps it so the command body stays slim and the
+fields stay in one place.
+
+Stdlib-only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+_SCRIPTS_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(_SCRIPTS_ROOT))
+
+
+_VALID_MODES = ("full", "quick", "skip")
+
+
+def clear_gate(mode: str, complete: bool) -> dict:
+    """Update SessionState onboarding fields and return the post-update dict.
+
+    ``mode`` is one of ``full``, ``quick``, ``skip``. ``complete`` is True
+    for full / quick paths and False for skip.
+    """
+    if mode not in _VALID_MODES:
+        raise ValueError(f"mode must be one of {_VALID_MODES}, got {mode!r}")
+    from _session import SessionState  # type: ignore
+
+    state = SessionState.load()
+    state.update(
+        needs_onboarding=False,
+        setup_in_progress=False,
+        setup_confirmed=True,
+        onboarding_mode=mode,
+        onboarding_complete=bool(complete),
+    )
+    return {
+        "needs_onboarding": False,
+        "setup_in_progress": False,
+        "setup_confirmed": True,
+        "onboarding_mode": mode,
+        "onboarding_complete": bool(complete),
+    }
+
+
+def mark_setup_complete() -> dict:
+    """Section 4 helper: write setup_complete + setup_confirmed to SessionState."""
+    from _session import SessionState  # type: ignore
+
+    state = SessionState.load()
+    state.update(setup_complete=True, setup_confirmed=True)
+    return {"setup_complete": True, "setup_confirmed": True}
+
+
+def write_local_config() -> dict:
+    """Write the default local-mode config.json. Idempotent — overwrites."""
+    config_dir = Path.home() / ".something-wicked" / "wicked-garden"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    payload = {"mode": "local", "setup_complete": True}
+    (config_dir / "config.json").write_text(
+        json.dumps(payload, indent=2) + "\n", encoding="utf-8"
+    )
+    return {"path": str(config_dir / "config.json"), "config": payload}
+
+
+def save_domain_pref(selection: str) -> dict:
+    """Persist the chosen issue tracker to config.json domain_prefs.delivery."""
+    config_path = Path.home() / ".something-wicked" / "wicked-garden" / "config.json"
+    config: dict = {}
+    if config_path.exists():
+        try:
+            config = json.loads(config_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            config = {}
+    config.setdefault("domain_prefs", {})["delivery"] = selection
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    return {"path": str(config_path), "selection": selection}
+
+
+def _cli() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+    gate = sub.add_parser("clear-gate", help="Clear onboarding gate after onboarding")
+    gate.add_argument("--mode", required=True, choices=_VALID_MODES)
+    gate.add_argument("--complete", action="store_true")
+    sub.add_parser("mark-setup-complete", help="Set setup_complete + setup_confirmed in SessionState")
+    sub.add_parser("write-local-config", help="Write the default local-mode config.json")
+    pref = sub.add_parser("save-domain-pref", help="Persist chosen issue tracker")
+    pref.add_argument("selection", help="github | linear | jira | ado | rally | local")
+    args = parser.parse_args()
+    if args.cmd == "clear-gate":
+        result = clear_gate(args.mode, args.complete)
+    elif args.cmd == "mark-setup-complete":
+        result = mark_setup_complete()
+    elif args.cmd == "write-local-config":
+        result = write_local_config()
+    elif args.cmd == "save-domain-pref":
+        result = save_domain_pref(args.selection)
+    json.dump(result, sys.stdout, indent=2)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_cli())

package/scripts/smaht/_bus_consumers.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+smaht/_bus_consumers.py — Bus event consumers for the smaht domain.
+
+Reacts to wicked-brain events to keep smaht caches fresh.
+Poll-on-invoke pattern: called at prompt_submit hook startup.
+"""
+
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import List
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+logger = logging.getLogger("wicked-smaht.bus-consumers")
+
+
+def process_brain_events() -> List[str]:
+    """Poll for brain events and invalidate caches as needed.
+
+    Returns list of actions taken. Empty if bus unavailable.
+    """
+    actions = []
+    try:
+        from _bus import poll_pending, ack_events, is_processed, mark_processed
+
+        events = poll_pending(event_type_prefix="wicked.brain.")
+        if not events:
+            return actions
+
+        max_event_id = 0
+        for event in events:
+            event_id = event.get("event_id", 0)
+            event_type = event.get("event_type", "")
+            metadata = event.get("metadata", {})
+            chain_id = metadata.get("chain_id", event_type)
+
+            if event_id > max_event_id:
+                max_event_id = event_id
+
+            if is_processed(event_type, chain_id):
+                continue
+
+            if event_type == "wicked.brain.consolidated":
+                _invalidate_brain_adapter_cache()
+                mark_processed(event_type, chain_id)
+                actions.append("Invalidated smaht brain adapter cache (brain consolidated)")
+
+            elif event_type == "wicked.config.updated":
+                _clear_brain_port_cache()
+                mark_processed(event_type, chain_id)
+                actions.append("Cleared brain port cache (config updated)")
+
+            elif event_type == "wicked.brain.initialized":
+                _auto_configure_brain_adapter()
+                mark_processed(event_type, chain_id)
+                actions.append("Auto-configured smaht brain adapter (brain initialized)")
+
+        if max_event_id > 0:
+            ack_events(max_event_id)
+
+    except Exception as e:
+        logger.debug(f"Brain event consumer error (non-blocking): {e}")
+
+    return actions
+
+
+def _invalidate_brain_adapter_cache():
+    """Clear any cached brain query results so next prompt gets fresh data."""
+    try:
+        cache_dir = Path(os.path.expanduser("~")) / ".something-wicked" / "wicked-garden" / "local" / "wicked-smaht" / "cache"
+        if cache_dir.exists():
+            for f in cache_dir.glob("brain_*.json"):
+                f.unlink(missing_ok=True)
+    except Exception:
+        pass  # fail open
+
+
+def _clear_brain_port_cache():
+    """Clear the WICKED_BRAIN_PORT resolution cache."""
+    try:
+        from _brain_port import _port_cache
+        _port_cache.clear()
+    except Exception:
+        pass  # fail open — _brain_port may not have a cache dict
+
+
+def _auto_configure_brain_adapter():
+    """Auto-detect brain and configure smaht adapter without manual setup."""
+    try:
+        from _brain_port import resolve_brain_port
+        port = resolve_brain_port()
+        if port:
+            logger.info(f"Brain auto-detected on port {port}")
+    except Exception:
+        pass  # fail open

package/scripts/smaht/adapters/__init__.py

@@ -0,0 +1,83 @@
+"""
+Source adapters for wicked-smaht.
+
+Each adapter queries a wicked-garden plugin and returns ContextItems.
+
+IMPORTANT: All adapters must be truly async to enable parallel execution.
+Use run_subprocess() for subprocess calls and run_in_thread() for blocking I/O.
+
+All scripts are co-located under plugins/wicked-garden/scripts/{domain}/.
+Use _SCRIPTS_ROOT to build direct paths instead of discover_script().
+"""
+
+import asyncio
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# All domain scripts live under plugins/wicked-garden/scripts/
+# adapters/ is at scripts/smaht/adapters/, so parents[2] = scripts/
+_SCRIPTS_ROOT = Path(__file__).resolve().parents[2]
+
+
+async def run_subprocess(
+    cmd: List[str],
+    timeout: float = 5.0,
+    cwd: Optional[str] = None
+) -> tuple[int, str, str]:
+    """Run subprocess asynchronously without blocking the event loop.
+
+    Returns: (returncode, stdout, stderr)
+    """
+    def _run():
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=cwd
+            )
+            return (result.returncode, result.stdout, result.stderr)
+        except subprocess.TimeoutExpired:
+            return (-1, "", "timeout")
+        except Exception as e:
+            return (-1, "", str(e))
+
+    return await asyncio.to_thread(_run)
+
+
+async def run_in_thread(func, *args, **kwargs):
+    """Run a blocking function in a thread pool."""
+    import functools
+    return await asyncio.to_thread(functools.partial(func, *args, **kwargs))
+
+
+@dataclass
+class ContextItem:
+    """A single item of context from a source."""
+    id: str
+    source: str           # mem, jam, search, crew, context7
+    title: str
+    summary: str
+    excerpt: str = ""
+    relevance: float = 0.0
+    age_days: float = 0.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def token_estimate(self) -> int:
+        """Estimate token count for this item."""
+        text = f"{self.title} {self.summary} {self.excerpt}"
+        return len(text) // 4  # Rough estimate
+
+
+from . import domain_adapter
+from . import context7_adapter
+
+__all__ = [
+    'ContextItem',
+    'domain_adapter',
+    'context7_adapter',
+]