wicked-garden 12.27.0

package/scripts/_agents.py

@@ -0,0 +1,357 @@
+#!/usr/bin/env python3
+"""
+_agents.py — Dynamic agent loader.
+
+Loads agent definitions from disk:
+    - Disk agents: agents/{domain}/*.md files shipped with the plugin.
+      Always available.
+
+Usage:
+    from _agents import AgentLoader
+
+    loader = AgentLoader(agents_dir=Path("agents/"))
+    loader.load_disk_agents(agents_dir)
+    profile = loader.get("senior-engineer")
+"""
+
+import json
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# AgentProfile dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class AgentProfile:
+    """Normalized agent definition — common format for disk and CP sources.
+
+    Fields:
+        name:          Unique agent identifier (kebab-case).
+        domain:        Domain namespace (e.g. "engineering", "platform").
+        system_prompt: Full system prompt text.
+        capabilities:  List of capability strings (e.g. ["code-review"]).
+        traits:        List of trait strings (e.g. ["pragmatic", "concise"]).
+        metadata:      Arbitrary key/value pairs; includes "source" and others.
+    """
+
+    name: str
+    domain: str = ""
+    system_prompt: str = ""
+    capabilities: list[str] = field(default_factory=list)
+    traits: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "domain": self.domain,
+            "system_prompt": self.system_prompt,
+            "capabilities": self.capabilities,
+            "traits": self.traits,
+            "metadata": self.metadata,
+        }
+
+
+# ---------------------------------------------------------------------------
+# AgentLoader
+# ---------------------------------------------------------------------------
+
+
+class AgentLoader:
+    """Load and retrieve agent profiles from disk.
+
+    Lifecycle (called once in bootstrap.py):
+        loader = AgentLoader()
+        loader.load_disk_agents(agents_dir)
+        profile = loader.get("senior-engineer")
+    """
+
+    def __init__(self) -> None:
+        self._agents: dict[str, AgentProfile] = {}
+
+    # ------------------------------------------------------------------
+    # Loading
+    # ------------------------------------------------------------------
+
+    def load_disk_agents(self, agents_dir: Path) -> dict[str, AgentProfile]:
+        """Scan agents_dir recursively for *.md agent files and load them.
+
+        Each markdown file must have YAML frontmatter with at least a `name`
+        field. Additional recognized frontmatter keys: domain, description,
+        capabilities (list), traits (list), model, color.
+
+        The body of the markdown file (after frontmatter) becomes system_prompt.
+
+        Args:
+            agents_dir: Path to the agents/ directory (may contain subdirs).
+
+        Returns:
+            Dict mapping agent name -> AgentProfile. Also stored internally.
+        """
+        if not agents_dir.exists():
+            return {}
+
+        for md_file in sorted(agents_dir.rglob("*.md")):
+            profile = _parse_agent_md(md_file)
+            if profile is None:
+                continue
+            self._agents[profile.name] = profile
+
+        return dict(self._agents)
+
+    # ------------------------------------------------------------------
+    # Retrieval
+    # ------------------------------------------------------------------
+
+    def get(self, name: str) -> AgentProfile | None:
+        """Look up an agent by name.
+
+        Args:
+            name: Agent name (kebab-case, e.g. "senior-engineer").
+
+        Returns:
+            AgentProfile, or None if no agent with that name is loaded.
+        """
+        return self._agents.get(name)
+
+    def all(self) -> dict[str, AgentProfile]:
+        """Return a shallow copy of all loaded agents."""
+        return dict(self._agents)
+
+    def count(self) -> int:
+        return len(self._agents)
+
+    def serialize(self) -> list[dict]:
+        """Serialize all agents to a JSON-safe list (for session state file)."""
+        return [p.to_dict() for p in self._agents.values()]
+
+    @classmethod
+    def deserialize(cls, data: list[dict]) -> "AgentLoader":
+        """Reconstruct an AgentLoader from a previously serialized list."""
+        loader = cls()
+        for rec in data:
+            name = rec.get("name")
+            if not name:
+                continue
+            loader._agents[name] = AgentProfile(
+                name=name,
+                domain=rec.get("domain", ""),
+                system_prompt=rec.get("system_prompt", ""),
+                capabilities=rec.get("capabilities") or [],
+                traits=rec.get("traits") or [],
+                metadata=rec.get("metadata") or {},
+            )
+        return loader
+
+
+# ---------------------------------------------------------------------------
+# Markdown frontmatter parser (stdlib-only, no PyYAML)
+# ---------------------------------------------------------------------------
+
+_FRONTMATTER_START = "---"
+_FRONTMATTER_END = "---"
+
+
+def _parse_agent_md(path: Path) -> AgentProfile | None:
+    """Parse a Claude Code agent markdown file into an AgentProfile.
+
+    Format:
+        ---
+        name: agent-name
+        description: |
+          Optional description
+        domain: engineering          # optional
+        capabilities:                # optional list
+          - code-review
+        traits:                      # optional list
+          - pragmatic
+        model: sonnet                # stored in metadata
+        color: blue                  # stored in metadata
+        ---
+
+        # Agent Title
+
+        System prompt body...
+
+    Returns:
+        AgentProfile, or None if the file lacks a valid name field.
+    """
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+
+    frontmatter, body = _split_frontmatter(raw)
+    if frontmatter is None:
+        # No frontmatter — use filename as name, whole file as system_prompt
+        name = path.stem
+        domain = _infer_domain(path)
+        return AgentProfile(
+            name=name,
+            domain=domain,
+            system_prompt=raw.strip(),
+            metadata={"source": "disk", "file": str(path)},
+        )
+
+    parsed = _parse_simple_yaml(frontmatter)
+    name = parsed.get("name") or path.stem
+    if not name:
+        return None
+
+    domain = parsed.get("domain") or _infer_domain(path)
+
+    # Build metadata from remaining frontmatter keys
+    metadata_keys = {"model", "color", "version", "author", "allowed-tools"}
+    extra_meta = {k: v for k, v in parsed.items() if k in metadata_keys}
+    extra_meta["source"] = "disk"
+    extra_meta["file"] = str(path)
+
+    # Extract tool-capabilities for capability-based dynamic tool routing
+    tool_caps = _to_list(parsed.get("tool-capabilities"))
+    if tool_caps:
+        extra_meta["tool_capabilities"] = tool_caps
+
+    # Parse allowed-tools into a list for the resolver
+    allowed_tools_list = _to_list(parsed.get("allowed-tools"))
+    if allowed_tools_list:
+        extra_meta["allowed_tools_list"] = allowed_tools_list
+
+    return AgentProfile(
+        name=name,
+        domain=domain,
+        system_prompt=body.strip(),
+        capabilities=_to_list(parsed.get("capabilities")),
+        traits=_to_list(parsed.get("traits")),
+        metadata=extra_meta,
+    )
+
+
+def _split_frontmatter(raw: str) -> tuple[str | None, str]:
+    """Split raw markdown into (frontmatter, body).
+
+    Returns (None, raw) if no YAML frontmatter block is found.
+    """
+    lines = raw.split("\n")
+    if not lines or lines[0].strip() != _FRONTMATTER_START:
+        return None, raw
+
+    end_idx = None
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == _FRONTMATTER_END:
+            end_idx = i
+            break
+
+    if end_idx is None:
+        return None, raw
+
+    frontmatter = "\n".join(lines[1:end_idx])
+    body = "\n".join(lines[end_idx + 1 :])
+    return frontmatter, body
+
+
+def _parse_simple_yaml(text: str) -> dict[str, Any]:
+    """Minimal YAML parser for Claude Code agent frontmatter.
+
+    Handles the subset of YAML used in agent files:
+        - key: scalar_value
+        - key: |
+            multi-line block (dedented)
+        - key:
+            - list_item_1
+            - list_item_2
+
+    Does NOT handle nested dicts, anchors, or other YAML features.
+    """
+    result: dict[str, Any] = {}
+    lines = text.split("\n")
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+
+        # Skip blank lines and comments
+        if not line.strip() or line.strip().startswith("#"):
+            i += 1
+            continue
+
+        # Key: value or Key:
+        if ":" not in line:
+            i += 1
+            continue
+
+        key_part, _, value_part = line.partition(":")
+        key = key_part.strip()
+        value = value_part.strip()
+
+        if not key:
+            i += 1
+            continue
+
+        # Block scalar (|)
+        if value == "|":
+            block_lines: list[str] = []
+            i += 1
+            while i < len(lines):
+                bl = lines[i]
+                # Block ends when we hit a line at root indentation (no leading space)
+                if bl and not bl.startswith(" ") and not bl.startswith("\t"):
+                    break
+                block_lines.append(bl)
+                i += 1
+            result[key] = "\n".join(line.rstrip() for line in block_lines).strip()
+            continue
+
+        # Inline list (next lines starting with "  -")
+        if value == "":
+            list_items: list[str] = []
+            j = i + 1
+            while j < len(lines):
+                candidate = lines[j].strip()
+                if candidate.startswith("- "):
+                    list_items.append(candidate[2:].strip())
+                    j += 1
+                elif candidate == "-":
+                    list_items.append("")
+                    j += 1
+                else:
+                    break
+            if list_items:
+                result[key] = list_items
+                i = j
+                continue
+
+        # Plain scalar — strip surrounding quotes
+        if value.startswith(('"', "'")):
+            value = value[1:-1] if len(value) > 1 and value[-1] == value[0] else value
+        result[key] = value
+        i += 1
+
+    return result
+
+
+def _infer_domain(path: Path) -> str:
+    """Infer domain from path: agents/{domain}/agent.md -> domain."""
+    parts = path.parts
+    # Look for the 'agents' segment and take the next part as domain
+    for idx, part in enumerate(parts):
+        if part == "agents" and idx + 2 < len(parts):
+            return parts[idx + 1]
+    return ""
+
+
+def _to_list(value: Any) -> list[str]:
+    """Normalize a YAML value to a list of strings."""
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(v) for v in value]
+    if isinstance(value, str):
+        # Comma-separated or single value
+        if "," in value:
+            return [v.strip() for v in value.split(",") if v.strip()]
+        return [value.strip()] if value.strip() else []
+    return []

package/scripts/_brain_ingest/__init__.py

@@ -0,0 +1,2 @@
+# _brain_ingest — internal infrastructure for brain ingestion.
+# Feeds session facts and other internal events into wicked-brain.

package/scripts/_brain_ingest/session_fact_extractor.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""
+Session-fact extractor over native Claude tasks.
+
+Replaces the smaht/v2 FactExtractor + HistoryCondenser turn-log pipeline
+that was deleted in Gate 4 Phase 2 of the v6 rebuild (#428). Reads native
+tasks written by TaskCreate/TaskUpdate to
+${CLAUDE_CONFIG_DIR:-~/.claude}/tasks/{session_id}/*.json and extracts
+session-level facts using the same heuristic patterns as the old
+FactExtractor.
+
+Source of truth shift:
+- v5: wicked-smaht session directory turn log (user/assistant messages)
+- v6: native task records (subject + description, filtered to completed)
+
+The emission shape on wicked-bus stays the same — `wicked.fact.extracted`
+events with {type, content, entities, source, session_id} — so the brain
+auto-memorize subscriber is unaffected.
+
+Fact types (mirrors brain auto-memorize policy):
+- decision    — "decided on X", "chose Y", "let's use Z"
+- discovery   — "found that X", "turns out Y"
+- artifact    — "created X", "wrote Y"
+- problem_solved — "fixed X", "resolved Y"
+- context     — "the system uses X", "currently running Y"
+
+Only `decision` and `discovery` are emittable (brain re-filters).
+
+stdlib-only. Fails open — returns [] on any I/O or parse error.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+import uuid
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, Optional
+
+
+FACT_TYPES = ("decision", "discovery", "artifact", "problem_solved", "context")
+EMITTABLE_FACT_TYPES = frozenset({"decision", "discovery"})
+
+
+@dataclass
+class SessionFact:
+    """A structured fact extracted from a native task record."""
+
+    id: str
+    type: str
+    content: str
+    entities: list = field(default_factory=list)
+    source: str = "task"  # always "task" in v6 — native task origin
+    timestamp: str = ""
+    task_id: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.id:
+            self.id = str(uuid.uuid4())[:8]
+        if not self.timestamp:
+            self.timestamp = datetime.now(timezone.utc).isoformat()
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# --- Extraction patterns (ported verbatim from smaht/v2/fact_extractor.py) ---
+
+_DECISION_PATTERNS = [
+    (r"let's (?:go with|use|do) ([^.!?\n]{10,100})", "decision"),
+    (r"decided (?:on|to) ([^.!?\n]{10,100})", "decision"),
+    (r"chose ([^.!?\n]{10,100})", "decision"),
+    (r"we(?:'ll| will) use ([^.!?\n]{10,100})", "decision"),
+    (r"going (?:to|with) ([^.!?\n]{10,100})", "decision"),
+    (r"switched to ([^.!?\n]{10,100})", "decision"),
+]
+
+_DISCOVERY_PATTERNS = [
+    (r"(?:found|discovered) (?:that |out )([^.!?\n]{10,100})", "discovery"),
+    (r"turns out ([^.!?\n]{10,100})", "discovery"),
+    (r"(?:realized|noticed) (?:that )?([^.!?\n]{10,100})", "discovery"),
+    (r"the (?:issue|problem|root cause) (?:is|was) ([^.!?\n]{10,100})", "discovery"),
+]
+
+_ARTIFACT_PATTERNS = [
+    (r"(?:created|wrote|generated|built) ([^.!?\n]{5,80})", "artifact"),
+    (r"(?:added|implemented) ([^.!?\n]{5,80})", "artifact"),
+]
+
+_PROBLEM_SOLVED_PATTERNS = [
+    (r"(?:fixed|resolved|solved) ([^.!?\n]{10,100})", "problem_solved"),
+    (r"(?:the fix|solution) (?:is|was) ([^.!?\n]{10,100})", "problem_solved"),
+]
+
+_CONTEXT_PATTERNS = [
+    (r"the system (?:uses|has|runs) ([^.!?\n]{10,80})", "context"),
+    (r"currently (?:using|running|on) ([^.!?\n]{10,80})", "context"),
+    (r"our (?:stack|setup|architecture) (?:is|includes) ([^.!?\n]{10,80})", "context"),
+]
+
+_ALL_PATTERNS = (
+    _DECISION_PATTERNS
+    + _DISCOVERY_PATTERNS
+    + _ARTIFACT_PATTERNS
+    + _PROBLEM_SOLVED_PATTERNS
+    + _CONTEXT_PATTERNS
+)
+
+
+_TECH_NAMES = (
+    "Redis", "Postgres", "PostgreSQL", "MySQL", "MongoDB", "SQLite",
+    "Docker", "Kubernetes", "AWS", "GCP", "Azure",
+    "React", "Vue", "Angular", "FastAPI", "Django", "Flask", "Express",
+    "JWT", "OAuth", "GraphQL", "REST", "gRPC",
+    "Stripe", "Kafka", "RabbitMQ", "Elasticsearch",
+)
+
+_FILE_PATH_RE = re.compile(
+    r"([a-zA-Z_][a-zA-Z0-9_/.-]*\."
+    r"(?:py|ts|js|tsx|jsx|json|yaml|yml|md|sql|java|go|rs|sh))\b"
+)
+
+
+def _extract_entities(text: str) -> list:
+    """Extract entity references (files, technologies, services) from text."""
+    entities: list = []
+
+    files = _FILE_PATH_RE.findall(text)
+    entities.extend(files[:5])
+
+    for tech in _TECH_NAMES:
+        if re.search(rf"\b{re.escape(tech)}\b", text, re.IGNORECASE) and tech not in entities:
+            entities.append(tech)
+
+    return entities[:8]
+
+
+def _tasks_dir(session_id: str) -> Path:
+    """Resolve the native tasks directory for a session.
+
+    Honors CLAUDE_CONFIG_DIR; defaults to ~/.claude.
+    """
+    base = os.environ.get("CLAUDE_CONFIG_DIR")
+    if base:
+        root = Path(base).expanduser()
+    else:
+        root = Path.home() / ".claude"
+    # Sanitize session_id the same way hooks/scripts/stop.py does.
+    safe = session_id.replace("/", "_").replace("\\", "_").replace("..", "_")
+    return root / "tasks" / safe
+
+
+def _iter_task_records_direct(session_id: str) -> Iterable[dict]:
+    """Yield completed task records via direct file read (pre-PR-2 behaviour)."""
+    tdir = _tasks_dir(session_id)
+    if not tdir.exists() or not tdir.is_dir():
+        return
+
+    # Native task filenames are the numeric task id + .json. Sort numerically
+    # so earlier tasks produce earlier facts (stable order for dedup).
+    def _sort_key(p: Path) -> tuple:
+        stem = p.stem
+        try:
+            return (0, int(stem))
+        except ValueError:
+            return (1, stem)
+
+    for path in sorted(tdir.glob("*.json"), key=_sort_key):
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError, json.JSONDecodeError):
+            continue
+        if not isinstance(data, dict):
+            continue
+        if data.get("status") != "completed":
+            continue
+        yield data
+
+
+def _iter_task_records(session_id: str) -> Iterable[dict]:
+    """Yield native task JSON records for the session, oldest-first by numeric id.
+
+    Only yields tasks whose status == 'completed'.
+
+    Routing: WG_DAEMON_ENABLED=false → direct file read (unchanged);
+             WG_DAEMON_ENABLED=true  → daemon HTTP with fallback (#596 v8-PR-2).
+    """
+    try:
+        # _SCRIPTS_ROOT is the parent of this file's directory.
+        _scripts = str(Path(__file__).resolve().parents[1])
+        if _scripts not in sys.path:
+            sys.path.insert(0, _scripts)
+        from crew._task_reader import read_session_tasks  # type: ignore[import]
+        tasks = read_session_tasks(session_id, limit=500)
+        for t in tasks:
+            if isinstance(t, dict) and t.get("status") == "completed":
+                yield t
+        return
+    except Exception:
+        pass  # fail open — _task_reader unavailable; fall through to direct file read
+    # Fallback to direct file read if import fails.
+    yield from _iter_task_records_direct(session_id)
+
+
+def _extract_from_text(text: str, task_id: str) -> list:
+    """Extract facts from a text block (task subject + description)."""
+    if not text:
+        return []
+
+    facts: list = []
+    text_lower = text.lower()
+    entities = _extract_entities(text)
+
+    for pattern, fact_type in _ALL_PATTERNS:
+        matches = re.findall(pattern, text_lower)
+        for match in matches[:2]:
+            if isinstance(match, tuple):
+                match = " ".join(match)
+            match = match.strip()
+            if not match or len(match) < 5:
+                continue
+            facts.append(
+                SessionFact(
+                    id=str(uuid.uuid4())[:8],
+                    type=fact_type,
+                    content=match,
+                    entities=entities,
+                    source="task",
+                    task_id=task_id,
+                )
+            )
+    # Match the old FactExtractor cap of 5 per text block.
+    return facts[:5]
+
+
+def extract_session_facts(session_id: str, limit: int = 10) -> list:
+    """Extract session-level facts from native task records.
+
+    Returns a list of SessionFact objects (up to `limit`), deduplicated by
+    lowercased content. Fails open — returns [] on any error.
+
+    The returned shape matches what hooks/scripts/stop.py::_run_memory_promotion
+    consumes: objects with `.type`, `.content`, `.entities`, `.source`.
+    """
+    if not session_id or limit <= 0:
+        return []
+
+    facts: list = []
+    seen: set = set()
+
+    try:
+        for record in _iter_task_records(session_id):
+            task_id = str(record.get("id", ""))
+            subject = str(record.get("subject", "") or "")
+            description = str(record.get("description", "") or "")
+            # Concatenate so patterns can match across subject+description;
+            # keeps entity extraction coherent within a single task.
+            text = f"{subject}. {description}".strip()
+
+            for fact in _extract_from_text(text, task_id):
+                key = fact.content.lower()
+                if key in seen:
+                    continue
+                seen.add(key)
+                facts.append(fact)
+                if len(facts) >= limit:
+                    return facts
+    except Exception as exc:  # pragma: no cover - defensive fail-open
+        print(f"[wicked-mem] session fact extraction error: {exc}", file=sys.stderr)
+        return facts
+
+    return facts
+
+
+def _self_test() -> int:
+    """Inline self-test with a synthetic task directory."""
+    import tempfile
+
+    tmp = Path(tempfile.mkdtemp(prefix="wg-sfe-"))
+    try:
+        session_id = "selftest"
+        sdir = tmp / "tasks" / session_id
+        sdir.mkdir(parents=True)
+
+        # Task 1: contains a decision + an artifact
+        (sdir / "1.json").write_text(json.dumps({
+            "id": "1",
+            "subject": "Wire facilitator",
+            "description": "We decided to use the rubric approach and created facilitator.md",
+            "status": "completed",
+        }))
+        # Task 2: pending — should be ignored
+        (sdir / "2.json").write_text(json.dumps({
+            "id": "2",
+            "subject": "Write docs",
+            "description": "Not done yet",
+            "status": "pending",
+        }))
+        # Task 3: a discovery
+        (sdir / "3.json").write_text(json.dumps({
+            "id": "3",
+            "subject": "Root cause",
+            "description": "The issue was a race condition in the event loop",
+            "status": "completed",
+        }))
+
+        os.environ["CLAUDE_CONFIG_DIR"] = str(tmp)
+        facts = extract_session_facts(session_id, limit=10)
+
+        types = [f.type for f in facts]
+        contents = [f.content for f in facts]
+
+        assert facts, f"expected at least one fact, got {facts}"
+        assert "decision" in types, f"expected a decision fact, got types={types}"
+        assert "discovery" in types, f"expected a discovery fact, got types={types}"
+        # pending task must not leak into facts
+        assert not any("not done" in c for c in contents), (
+            f"pending task leaked into facts: {contents}"
+        )
+        # Every fact must have a task_id linking it to its source
+        assert all(f.task_id for f in facts), (
+            f"facts missing task_id: {[f.to_dict() for f in facts]}"
+        )
+
+        emittable = [f for f in facts if f.type in EMITTABLE_FACT_TYPES]
+        assert emittable, "expected at least one emittable (decision/discovery) fact"
+
+        print(f"session_fact_extractor self-test: PASS ({len(facts)} facts, {len(emittable)} emittable)")
+        return 0
+    finally:
+        import shutil
+        shutil.rmtree(tmp, ignore_errors=True)
+        os.environ.pop("CLAUDE_CONFIG_DIR", None)
+
+
+if __name__ == "__main__":
+    sys.exit(_self_test())