loki-mode 6.77.2 → 6.80.0

package/magic/core/memory_bridge.py

@@ -0,0 +1,220 @@
+"""Memory bridge for Magic Modules.
+
+Feeds component-generation outcomes into Loki's memory system so agents
+benefit from prior work across iterations and projects:
+
+- Episodic memory: component generation events with debate results
+- Semantic memory: stable tag clusters from repeated successful generations
+- Retrieval: pull similar past generations during REASON phase
+
+The memory system may or may not be available; every function here degrades
+gracefully if memory imports fail.
+"""
+
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+
+def _try_import_memory():
+    """Attempt to import the memory subsystem. Returns (engine_cls, trace_cls, pattern_cls, err)."""
+    try:
+        from memory.engine import MemoryEngine
+        from memory.schemas import EpisodeTrace, SemanticPattern
+        return MemoryEngine, EpisodeTrace, SemanticPattern, None
+    except Exception as exc:
+        return None, None, None, str(exc)
+
+
+def _load_registry(project_dir: str) -> Optional[dict]:
+    reg = Path(project_dir) / ".loki" / "magic" / "registry.json"
+    if not reg.exists():
+        return None
+    try:
+        return json.loads(reg.read_text())
+    except Exception:
+        return None
+
+
+def _engine_for(project_dir: str, MemoryEngine):
+    """Instantiate MemoryEngine rooted at project_dir/.loki/memory."""
+    base = str(Path(project_dir) / ".loki" / "memory")
+    return MemoryEngine(base_path=base)
+
+
+def capture_component_generation(
+    project_dir: str,
+    component_name: str,
+    spec_path: str,
+    targets: list,
+    debate_result: Optional[dict] = None,
+    iteration: int = 0,
+    duration_seconds: float = 0,
+) -> dict:
+    """Record an episode for a single component generation event.
+
+    Returns summary dict {stored: bool, reason: str, episode_id: str?}.
+    """
+    ME, EpisodeTrace, _SemPat, err = _try_import_memory()
+    if ME is None:
+        return {"stored": False, "reason": f"memory unavailable: {err}"}
+
+    try:
+        engine = _engine_for(project_dir, ME)
+    except Exception as exc:
+        return {"stored": False, "reason": f"engine init failed: {exc}"}
+
+    # Build episode content
+    debate_summary = ""
+    if debate_result:
+        c_count = len(debate_result.get("critiques", []))
+        consensus = debate_result.get("consensus", False)
+        blocks = len(debate_result.get("blocks", []))
+        debate_summary = (
+            f" Debate: {c_count} personas, consensus={consensus}, "
+            f"blocks={blocks}"
+        )
+    goal = (
+        f"Generate magic component '{component_name}' "
+        f"(targets={','.join(targets) if targets else 'unknown'})."
+        f"{debate_summary}"
+    )
+    outcome = "success"
+    if debate_result and debate_result.get("blocks"):
+        outcome = "failure"
+
+    try:
+        ep_id = f"magic-{component_name.lower()}-{uuid.uuid4().hex[:8]}"
+        trace = EpisodeTrace(
+            id=ep_id,
+            task_id=f"magic-gen-{component_name}",
+            timestamp=datetime.now(timezone.utc),
+            duration_seconds=int(max(0, duration_seconds)),
+            agent="magic",
+            phase="ACT",
+            goal=goal,
+            outcome=outcome,
+            artifacts_produced=[spec_path] if spec_path else [],
+            files_modified=[spec_path] if spec_path else [],
+            importance=0.6 if outcome == "success" else 0.8,
+        )
+        stored_id = engine.store_episode(trace)
+        return {"stored": True, "reason": "episode saved", "episode_id": stored_id}
+    except Exception as exc:
+        return {"stored": False, "reason": f"store failed: {exc}"}
+
+
+def capture_iteration_compound(project_dir: str, iteration: int = 0) -> dict:
+    """Called in COMPOUND phase: aggregate component stats and record semantic pattern.
+
+    Reads registry, computes per-tag pass rates, and stores as semantic memory
+    for tag clusters that hit the stability threshold.
+    """
+    data = _load_registry(project_dir)
+    if not data:
+        return {"recorded": False, "reason": "no registry"}
+
+    components = data.get("components", [])
+    if isinstance(components, dict):
+        components = [{"name": k, **(v or {})} for k, v in components.items()]
+
+    if not components:
+        return {"recorded": False, "reason": "no components"}
+
+    # Build per-tag pass rate
+    tag_stats = {}
+    for c in components:
+        tags = c.get("tags", []) or []
+        debate_passed = bool(c.get("debate_passed"))
+        for tag in tags:
+            bucket = tag_stats.setdefault(tag, {"total": 0, "passed": 0})
+            bucket["total"] += 1
+            if debate_passed:
+                bucket["passed"] += 1
+
+    # Derive patterns: tags with >=3 components and >=80% pass rate are "stable"
+    stable_tags = [
+        t for t, s in tag_stats.items()
+        if s["total"] >= 3 and s["passed"] / s["total"] >= 0.8
+    ]
+
+    ME, _Ep, SemanticPattern, err = _try_import_memory()
+    if ME is None:
+        return {
+            "recorded": False,
+            "reason": f"memory unavailable: {err}",
+            "stable_tags": stable_tags,
+            "tag_stats": tag_stats,
+        }
+
+    try:
+        engine = _engine_for(project_dir, ME)
+    except Exception as exc:
+        return {"recorded": False, "reason": f"engine init failed: {exc}"}
+
+    try:
+        stored = []
+        for tag in stable_tags:
+            s = tag_stats[tag]
+            pct = s["passed"] / s["total"]
+            pattern = SemanticPattern(
+                id=f"sem-magic-{tag}-{uuid.uuid4().hex[:6]}",
+                pattern=(
+                    f"Magic components tagged '{tag}' pass debate reliably "
+                    f"({s['passed']}/{s['total']}, {pct:.0%})."
+                ),
+                category="magic-components",
+                conditions=[f"component has tag '{tag}'"],
+                correct_approach=(
+                    f"Follow prior successful '{tag}' specs; accessibility "
+                    f"and design-token usage have been consistently present."
+                ),
+                confidence=min(0.95, 0.5 + pct * 0.5),
+            )
+            stored.append(engine.store_pattern(pattern))
+        return {
+            "recorded": True,
+            "stable_tags": stable_tags,
+            "component_count": len(components),
+            "patterns_stored": stored,
+        }
+    except Exception as exc:
+        return {"recorded": False, "reason": f"store failed: {exc}"}
+
+
+def recall_similar_components(project_dir: str, tags: list = None, query: str = "") -> list:
+    """Query memory for similar prior components. Used at REASON phase.
+
+    Returns list of remembered components (possibly empty).
+    """
+    ME, _Ep, _SemPat, _err = _try_import_memory()
+    if ME is None:
+        return []
+    try:
+        engine = _engine_for(project_dir, ME)
+        context = {
+            "goal": query or "magic component generation",
+            "tags": tags or ["magic"],
+            "phase": "REASON",
+        }
+        results = engine.retrieve_relevant(context=context, top_k=5) or []
+        return [r if isinstance(r, dict) else {"content": str(r)} for r in results]
+    except Exception:
+        return []
+
+
+def _format_tag_stats(stats: dict, limit: int = 8) -> str:
+    items = sorted(stats.items(), key=lambda x: x[1]["total"], reverse=True)[:limit]
+    parts = []
+    for tag, s in items:
+        pct = (s["passed"] / s["total"] * 100.0) if s["total"] else 0.0
+        parts.append(f"{tag}={s['passed']}/{s['total']} ({pct:.0f}%)")
+    return ", ".join(parts) if parts else "none"
+
+
+if __name__ == "__main__":
+    import sys
+    project = sys.argv[1] if len(sys.argv) > 1 else "."
+    print(json.dumps(capture_iteration_compound(project), indent=2))

package/magic/core/prd_scanner.py

@@ -0,0 +1,265 @@
+"""PRD scanner for Magic Modules.
+
+Runs during the REASON phase of a build. Reads the PRD, detects
+UI component mentions (Button, Modal, Form, Table, Card, Nav, etc.),
+and creates bare-minimum markdown specs at .loki/magic/specs/<Name>.md.
+
+The generated specs are stubs -- placeholder for agents to refine
+during the ACT phase. The goal is to make component needs explicit
+and trackable from iteration 1, not discovered mid-build.
+"""
+
+import re
+from pathlib import Path
+from typing import Optional
+
+# Component keywords to detect in PRDs. Map lowercase keyword -> default PascalCase name.
+UI_COMPONENT_VOCAB = {
+    "button": "Button",
+    "modal": "Modal",
+    "dialog": "Dialog",
+    "form": "Form",
+    "input": "Input",
+    "textarea": "Textarea",
+    "select": "Select",
+    "dropdown": "Dropdown",
+    "checkbox": "Checkbox",
+    "radio": "Radio",
+    "toggle": "Toggle",
+    "switch": "Switch",
+    "slider": "Slider",
+    "table": "Table",
+    "list": "List",
+    "card": "Card",
+    "tile": "Tile",
+    "navigation": "Navigation",
+    "navbar": "Navbar",
+    "sidebar": "Sidebar",
+    "header": "Header",
+    "footer": "Footer",
+    "tabs": "Tabs",
+    "accordion": "Accordion",
+    "badge": "Badge",
+    "avatar": "Avatar",
+    "toast": "Toast",
+    "notification": "Notification",
+    "tooltip": "Tooltip",
+    "popover": "Popover",
+    "menu": "Menu",
+    "breadcrumb": "Breadcrumb",
+    "pagination": "Pagination",
+    "progress bar": "ProgressBar",
+    "spinner": "Spinner",
+    "loader": "Loader",
+    "chart": "Chart",
+    "graph": "Graph",
+    "search bar": "SearchBar",
+    "filter": "FilterPanel",
+    "login": "LoginForm",
+    "signup": "SignupForm",
+    "profile": "ProfileCard",
+    "dashboard": "Dashboard",
+}
+
+# Patterns that strongly suggest component intent (vs incidental mentions)
+INTENT_MARKERS = [
+    r"\badd\s+(?:a|an|the)\s+",
+    r"\bbuild\s+(?:a|an|the)\s+",
+    r"\bcreate\s+(?:a|an|the)\s+",
+    r"\bneed\s+(?:a|an|the)\s+",
+    r"\bwith\s+(?:a|an|the)\s+",
+    r"\binclude\s+(?:a|an|the)\s+",
+    r"\bshould\s+have\s+(?:a|an|the)\s+",
+]
+
+INTENT_RE = re.compile("|".join(INTENT_MARKERS), re.IGNORECASE)
+
+STUB_TEMPLATE = """# {name}
+
+## Description
+Auto-seeded by the PRD scanner from phrase: "{evidence}".
+Agents: refine this spec during the REASON/ACT phases. Fill in props,
+behavior, visual details, and accessibility requirements based on the
+PRD context. The spec is the source of truth; implementation regenerates
+from it.
+
+## Props
+- (to be determined by agent based on PRD context)
+
+## Behavior
+(to be determined)
+
+## Visual / Styling
+(to be determined -- use design tokens from .loki/magic/tokens.json)
+
+## Accessibility
+- Keyboard navigation: (to be determined)
+- Screen reader: (to be determined)
+- Focus management: (to be determined)
+
+## Examples
+```tsx
+<{name} />
+```
+"""
+
+
+def scan_prd(prd_text: str, limit: int = 20) -> list:
+    """Scan a PRD and return a list of detected component intents.
+
+    Returns list of dicts: {name, keyword, evidence, confidence}
+    Confidence is 'high' when intent marker + keyword co-occur in same sentence,
+    'medium' for keyword alone, 'low' for case-sensitive matches only.
+    """
+    if not prd_text:
+        return []
+    detected = []
+    seen_names = set()
+
+    # Split into sentences (approximate)
+    sentences = re.split(r"[.!?\n]+", prd_text)
+    for sent in sentences:
+        sent_clean = sent.strip()
+        if not sent_clean:
+            continue
+        sent_lower = sent_clean.lower()
+        has_intent = bool(INTENT_RE.search(sent_clean))
+
+        for keyword, default_name in UI_COMPONENT_VOCAB.items():
+            if keyword not in sent_lower:
+                continue
+            # Try to extract a more specific name from context, e.g.
+            # "add a Submit button" -> "SubmitButton"
+            name = _extract_compound_name(sent_clean, keyword, default_name)
+            if name in seen_names:
+                continue
+            seen_names.add(name)
+            confidence = "high" if has_intent else "medium"
+            detected.append({
+                "name": name,
+                "keyword": keyword,
+                "evidence": sent_clean[:200],
+                "confidence": confidence,
+            })
+            if len(detected) >= limit:
+                return detected
+    return detected
+
+
+def _extract_compound_name(sentence: str, keyword: str, default: str) -> str:
+    """Try to derive a PascalCase compound name from context.
+
+    Examples:
+      "add a submit button" + "button" -> "SubmitButton"
+      "create a user profile card" + "card" -> "UserProfileCard"
+      "the search bar" + "search bar" -> "SearchBar"
+    Falls back to the default PascalCase form of the keyword.
+    """
+    # Find the keyword position
+    low = sentence.lower()
+    idx = low.find(keyword)
+    if idx < 0:
+        return default
+    # Look at 1-3 words before the keyword
+    before = sentence[:idx].strip()
+    tokens = re.findall(r"[A-Za-z]+", before)
+    # Filter out stop words. Verb forms of intent markers ("includes",
+    # "contains", "built", etc.) are stops -- otherwise phrases like
+    # "dashboard includes navigation" produce "DashboardIncludesNavigation".
+    stop = {
+        "a", "an", "the", "with", "and", "or", "of", "for", "to", "in",
+        "on", "at", "by", "from", "into", "as",
+        "add", "adds", "added", "adding",
+        "build", "builds", "built", "building",
+        "create", "creates", "created", "creating",
+        "need", "needs", "needed", "needing",
+        "include", "includes", "included", "including",
+        "contain", "contains", "contained", "containing",
+        "have", "has", "had", "having",
+        "require", "requires", "required", "requiring",
+        "should", "must", "will", "can", "may",
+        "our", "my", "their", "its", "this", "that", "these", "those",
+        "new", "simple", "basic", "complex", "main", "primary", "user",
+        "also", "plus", "along",
+    }
+    # Another UI component keyword in the modifier slot means we're spanning
+    # two separate components (e.g. "navigation sidebar search bar" produces
+    # name "NavigationSidebarSearchBar"). Stop before that token.
+    other_component_keywords = {
+        k.replace(" ", "") for k in UI_COMPONENT_VOCAB.keys() if k != keyword
+    } | set(UI_COMPONENT_VOCAB.keys())
+    # Take last 1-2 non-stop, non-component tokens
+    modifiers = []
+    for tok in reversed(tokens):
+        tok_low = tok.lower()
+        if tok_low in stop:
+            if modifiers:
+                break
+            continue
+        if tok_low in other_component_keywords:
+            # Another distinct component name -- stop scanning modifiers.
+            break
+        modifiers.append(tok)
+        if len(modifiers) >= 2:
+            break
+    modifiers.reverse()
+    if not modifiers:
+        return default
+    # PascalCase the modifiers + default
+    parts = [m.capitalize() for m in modifiers] + [default]
+    # Deduplicate adjacent parts (e.g. "UserUser")
+    out = [parts[0]]
+    for p in parts[1:]:
+        if p != out[-1]:
+            out.append(p)
+    name = "".join(out)
+    # Validate against name regex
+    if not re.match(r"^[A-Za-z][A-Za-z0-9_-]*$", name):
+        return default
+    return name
+
+
+def seed_specs(detected: list, project_dir: str = ".", overwrite: bool = False) -> list:
+    """Write stub specs to .loki/magic/specs/. Returns list of paths written.
+
+    If overwrite=False (default), existing specs are never replaced.
+    """
+    specs_dir = Path(project_dir) / ".loki" / "magic" / "specs"
+    specs_dir.mkdir(parents=True, exist_ok=True)
+    written = []
+    for item in detected:
+        if item.get("confidence") == "low":
+            continue
+        name = item["name"]
+        spec_path = specs_dir / f"{name}.md"
+        if spec_path.exists() and not overwrite:
+            continue
+        stub = STUB_TEMPLATE.format(name=name, evidence=item["evidence"])
+        spec_path.write_text(stub)
+        written.append(str(spec_path))
+    return written
+
+
+def scan_and_seed(prd_text: str, project_dir: str = ".", overwrite: bool = False) -> dict:
+    """Convenience: scan PRD, seed specs, return summary dict."""
+    detected = scan_prd(prd_text)
+    written = seed_specs(detected, project_dir=project_dir, overwrite=overwrite)
+    return {
+        "detected_count": len(detected),
+        "detected": detected,
+        "seeded_count": len(written),
+        "seeded_paths": written,
+    }
+
+
+if __name__ == "__main__":
+    import sys
+    import json
+    if len(sys.argv) < 2:
+        print("Usage: python -m magic.core.prd_scanner <PRD_PATH> [project_dir]")
+        sys.exit(1)
+    prd_path = sys.argv[1]
+    project = sys.argv[2] if len(sys.argv) > 2 else "."
+    prd_text = Path(prd_path).read_text()
+    result = scan_and_seed(prd_text, project_dir=project)
+    print(json.dumps(result, indent=2))