ma-agents 2.19.2 → 2.20.1

package/lib/bmad-cache/bmb/samples/bmad-agent-dream-weaver/scripts/symbol_stats.py

@@ -0,0 +1,162 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml"]
+# ///
+"""
+Symbol frequency analysis for Dream Weaver journal entries.
+
+Scans journal folder for dream entries with YAML frontmatter,
+extracts symbols, and outputs frequency statistics as JSON.
+
+Usage:
+    uv run scripts/symbol_stats.py --journal-path PATH [--days N] [--verbose]
+"""
+
+import argparse
+import json
+import sys
+from collections import Counter, defaultdict
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import yaml
+
+
+def parse_frontmatter(file_path: Path) -> dict | None:
+    """Extract YAML frontmatter from a markdown file."""
+    try:
+        content = file_path.read_text(encoding="utf-8")
+        if not content.startswith("---"):
+            return None
+        end = content.index("---", 3)
+        return yaml.safe_load(content[3:end])
+    except (ValueError, yaml.YAMLError):
+        return None
+
+
+def scan_journal(journal_path: Path, days: int | None = None) -> list[dict]:
+    """Scan journal entries and extract frontmatter data."""
+    entries = []
+    cutoff = None
+    if days:
+        cutoff = datetime.now().date() - timedelta(days=days)
+
+    for file in sorted(journal_path.glob("*.md")):
+        fm = parse_frontmatter(file)
+        if not fm or "symbols" not in fm:
+            continue
+
+        entry_date = fm.get("date")
+        if isinstance(entry_date, str):
+            try:
+                entry_date = datetime.strptime(entry_date, "%Y-%m-%d").date()
+            except ValueError:
+                continue
+
+        if cutoff and entry_date and entry_date < cutoff:
+            continue
+
+        entries.append({
+            "file": file.name,
+            "date": str(entry_date) if entry_date else None,
+            "symbols": fm.get("symbols", []),
+            "emotions": fm.get("emotions", []),
+            "vividness": fm.get("vividness"),
+            "lucid": fm.get("lucid", False),
+        })
+
+    return entries
+
+
+def analyze_symbols(entries: list[dict]) -> dict:
+    """Analyze symbol frequency and emotion correlations."""
+    symbol_count = Counter()
+    symbol_emotions = defaultdict(Counter)
+    symbol_dates = defaultdict(list)
+    symbol_contexts = defaultdict(set)
+
+    for entry in entries:
+        symbols = entry.get("symbols", [])
+        emotions = entry.get("emotions", [])
+        date = entry.get("date")
+
+        for symbol in symbols:
+            symbol = symbol.lower().strip()
+            symbol_count[symbol] += 1
+            if date:
+                symbol_dates[symbol].append(date)
+            for emotion in emotions:
+                symbol_emotions[symbol][emotion.lower().strip()] += 1
+
+    results = {}
+    for symbol, count in symbol_count.most_common():
+        dates = sorted(symbol_dates[symbol])
+        results[symbol] = {
+            "count": count,
+            "first_seen": dates[0] if dates else None,
+            "last_seen": dates[-1] if dates else None,
+            "emotion_correlation": dict(symbol_emotions[symbol]),
+        }
+
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Analyze dream journal symbol frequency"
+    )
+    parser.add_argument(
+        "--journal-path", required=True, help="Path to journal folder"
+    )
+    parser.add_argument(
+        "--days", type=int, default=None, help="Limit to last N days"
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print diagnostics to stderr"
+    )
+    args = parser.parse_args()
+
+    journal_path = Path(args.journal_path)
+    if not journal_path.is_dir():
+        print(
+            json.dumps({
+                "script": "symbol_stats",
+                "status": "error",
+                "error": f"Journal path not found: {journal_path}",
+            }),
+            file=sys.stdout,
+        )
+        sys.exit(2)
+
+    entries = scan_journal(journal_path, args.days)
+
+    if args.verbose:
+        print(f"Found {len(entries)} journal entries", file=sys.stderr)
+
+    symbols = analyze_symbols(entries)
+
+    output = {
+        "script": "symbol_stats",
+        "version": "1.0.0",
+        "journal_path": str(journal_path),
+        "timestamp": datetime.now().isoformat(),
+        "status": "pass",
+        "entries_scanned": len(entries),
+        "unique_symbols": len(symbols),
+        "symbols": symbols,
+        "summary": {
+            "total_symbols": sum(s["count"] for s in symbols.values()),
+            "unique_symbols": len(symbols),
+            "top_5": [
+                {"symbol": s, "count": symbols[s]["count"]}
+                for s in list(symbols.keys())[:5]
+            ],
+        },
+    }
+
+    print(json.dumps(output, indent=2))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/lib/bmad-cache/bmb/samples/bmad-agent-dream-weaver/scripts/tests/test_recall_metrics.py

@@ -0,0 +1,115 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml", "pytest"]
+# ///
+"""Tests for recall_metrics.py."""
+
+import json
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from recall_metrics import calculate_metrics, parse_frontmatter, scan_journal
+
+
+@pytest.fixture
+def journal_dir(tmp_path):
+    """Create a journal directory with entries spanning multiple days."""
+    journal = tmp_path / "journal"
+    journal.mkdir()
+
+    today = datetime.now().date()
+    for i in range(7):
+        day = today - timedelta(days=i)
+        entry = journal / f"{day}-1.md"
+        vividness = 5 + (i % 4)
+        lucid = "true" if i == 2 else "false"
+        quality = "high" if i < 3 else "medium"
+        entry.write_text(
+            f"---\ndate: {day}\nsequence: 1\nvividness: {vividness}\n"
+            f"lucid: {lucid}\nrecall_quality: {quality}\n"
+            f"emotions: [curiosity]\nsymbols: [water]\nseeded: false\n---\n\nDream.\n"
+        )
+
+    return journal
+
+
+@pytest.fixture
+def empty_journal(tmp_path):
+    journal = tmp_path / "journal"
+    journal.mkdir()
+    return journal
+
+
+class TestParseFrontmatter:
+    def test_valid(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("---\ndate: 2026-03-10\nvividness: 7\n---\nContent")
+        result = parse_frontmatter(f)
+        assert result["vividness"] == 7
+
+    def test_missing(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("No frontmatter")
+        assert parse_frontmatter(f) is None
+
+
+class TestScanJournal:
+    def test_scans_all(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        assert len(entries) == 7
+
+    def test_empty(self, empty_journal):
+        entries = scan_journal(empty_journal)
+        assert len(entries) == 0
+
+    def test_extracts_vividness(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        assert all(e["vividness"] is not None for e in entries)
+
+
+class TestCalculateMetrics:
+    def test_basic_metrics(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert metrics["total_dreams"] == 7
+        assert metrics["dreams_per_week"] > 0
+        assert metrics["current_streak"] > 0
+        assert metrics["avg_vividness"] > 0
+
+    def test_empty_entries(self):
+        metrics = calculate_metrics([])
+        assert metrics["total_dreams"] == 0
+        assert metrics["dreams_per_week"] == 0
+        assert metrics["current_streak"] == 0
+
+    def test_quality_distribution(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert "high" in metrics["quality_distribution"]
+        assert "medium" in metrics["quality_distribution"]
+
+    def test_lucid_count(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert metrics["lucid_count"] == 1
+
+    def test_weekly_counts(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert len(metrics["weekly_counts"]) == 8
+
+    def test_vividness_trend_with_data(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert metrics["vividness_trend"] in (
+            "improving", "declining", "stable", "insufficient_data"
+        )
+
+    def test_streak_calculation(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        metrics = calculate_metrics(entries)
+        assert metrics["longest_streak"] >= metrics["current_streak"]

package/lib/bmad-cache/bmb/samples/bmad-agent-dream-weaver/scripts/tests/test_seed_tracker.py

@@ -0,0 +1,140 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml", "pytest"]
+# ///
+"""Tests for seed_tracker.py."""
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from seed_tracker import analyze_seeds, load_seed_log
+
+
+@pytest.fixture
+def seed_log(tmp_path):
+    """Create a seed-log.yaml with mixed results."""
+    log = tmp_path / "seed-log.yaml"
+    data = {
+        "seeds": [
+            {
+                "date": "2026-03-01",
+                "intention": "Dream about the ocean",
+                "technique": "visualization",
+                "result": "full",
+                "dream_ref": "2026-03-02-1",
+                "notes": "Dreamed of swimming in deep water",
+            },
+            {
+                "date": "2026-03-03",
+                "intention": "Meet my grandmother",
+                "technique": "mantra",
+                "result": "none",
+                "dream_ref": None,
+                "notes": None,
+            },
+            {
+                "date": "2026-03-05",
+                "intention": "Fly over mountains",
+                "technique": "visualization",
+                "result": "partial",
+                "dream_ref": "2026-03-06-1",
+                "notes": "Floated but didn't fly",
+            },
+            {
+                "date": "2026-03-08",
+                "intention": "Open the locked door",
+                "technique": "symbol-return",
+                "result": "pending",
+                "dream_ref": None,
+                "notes": None,
+            },
+            {
+                "date": "2026-03-10",
+                "intention": "Explore underwater",
+                "technique": "question",
+                "result": "full",
+                "dream_ref": "2026-03-11-1",
+                "notes": "Breathed underwater",
+            },
+        ],
+        "success_rate": 0.5,
+    }
+    log.write_text(yaml.dump(data))
+    return log
+
+
+@pytest.fixture
+def empty_seed_log(tmp_path):
+    log = tmp_path / "seed-log.yaml"
+    log.write_text(yaml.dump({"seeds": []}))
+    return log
+
+
+class TestLoadSeedLog:
+    def test_loads_seeds(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        assert len(seeds) == 5
+
+    def test_empty_log(self, empty_seed_log):
+        seeds = load_seed_log(empty_seed_log)
+        assert len(seeds) == 0
+
+    def test_missing_file(self, tmp_path):
+        seeds = load_seed_log(tmp_path / "nonexistent.yaml")
+        assert len(seeds) == 0
+
+    def test_invalid_yaml(self, tmp_path):
+        f = tmp_path / "bad.yaml"
+        f.write_text(": [invalid yaml {{")
+        seeds = load_seed_log(f)
+        assert len(seeds) == 0
+
+
+class TestAnalyzeSeeds:
+    def test_basic_analysis(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        assert result["total_seeds"] == 5
+        assert result["pending"] == 1
+        assert result["resolved"] == 4
+
+    def test_success_rate(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        # 3 successes (full + partial) out of 4 resolved = 0.75
+        assert result["success_rate"] == 0.75
+
+    def test_technique_stats(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        assert "visualization" in result["technique_stats"]
+        assert result["technique_stats"]["visualization"]["total"] == 2
+
+    def test_best_technique(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        assert result["best_technique"] is not None
+
+    def test_empty_seeds(self):
+        result = analyze_seeds([])
+        assert result["total_seeds"] == 0
+        assert result["success_rate"] == 0
+
+    def test_result_distribution(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        dist = result["result_distribution"]
+        assert dist["full"] == 2
+        assert dist["partial"] == 1
+        assert dist["none"] == 1
+        assert dist["pending"] == 1
+
+    def test_recent_trend(self, seed_log):
+        seeds = load_seed_log(seed_log)
+        result = analyze_seeds(seeds)
+        assert 0 <= result["recent_trend_rate"] <= 1

package/lib/bmad-cache/bmb/samples/bmad-agent-dream-weaver/scripts/tests/test_symbol_stats.py

@@ -0,0 +1,113 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml", "pytest"]
+# ///
+"""Tests for symbol_stats.py."""
+
+import json
+import sys
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+# Add parent to path for import
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from symbol_stats import analyze_symbols, parse_frontmatter, scan_journal
+
+
+@pytest.fixture
+def journal_dir(tmp_path):
+    """Create a temporary journal directory with sample entries."""
+    journal = tmp_path / "journal"
+    journal.mkdir()
+
+    today = datetime.now().date()
+    yesterday = today - timedelta(days=1)
+
+    entry1 = journal / f"{today}-1.md"
+    entry1.write_text(
+        f"---\ndate: {today}\nsequence: 1\nvividness: 7\nlucid: false\n"
+        f"emotions: [anxiety, curiosity]\nsymbols: [water, doorway]\n"
+        f"recall_quality: high\nseeded: false\n---\n\nDream narrative here.\n"
+    )
+
+    entry2 = journal / f"{yesterday}-1.md"
+    entry2.write_text(
+        f"---\ndate: {yesterday}\nsequence: 1\nvividness: 5\nlucid: true\n"
+        f"emotions: [peace, awe]\nsymbols: [water, flying]\n"
+        f"recall_quality: medium\nseeded: true\n---\n\nAnother dream.\n"
+    )
+
+    return journal
+
+
+@pytest.fixture
+def empty_journal(tmp_path):
+    """Create an empty journal directory."""
+    journal = tmp_path / "journal"
+    journal.mkdir()
+    return journal
+
+
+class TestParseFrontmatter:
+    def test_valid_frontmatter(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("---\ndate: 2026-03-10\nsymbols: [water]\n---\nContent")
+        result = parse_frontmatter(f)
+        assert result is not None
+        assert result["symbols"] == ["water"]
+
+    def test_no_frontmatter(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("No frontmatter here.")
+        assert parse_frontmatter(f) is None
+
+    def test_invalid_yaml(self, tmp_path):
+        f = tmp_path / "test.md"
+        f.write_text("---\n: invalid: yaml: [[\n---\nContent")
+        assert parse_frontmatter(f) is None
+
+
+class TestScanJournal:
+    def test_scans_entries(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        assert len(entries) == 2
+
+    def test_empty_journal(self, empty_journal):
+        entries = scan_journal(empty_journal)
+        assert len(entries) == 0
+
+    def test_days_filter(self, journal_dir):
+        entries = scan_journal(journal_dir, days=0)
+        # With days=0, cutoff is today, so yesterday's entry is excluded
+        assert len(entries) <= 2
+
+    def test_extracts_symbols(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        all_symbols = [s for e in entries for s in e["symbols"]]
+        assert "water" in all_symbols
+        assert "doorway" in all_symbols
+
+
+class TestAnalyzeSymbols:
+    def test_basic_analysis(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        result = analyze_symbols(entries)
+        assert "water" in result
+        assert result["water"]["count"] == 2
+
+    def test_emotion_correlation(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        result = analyze_symbols(entries)
+        assert "anxiety" in result["water"]["emotion_correlation"]
+
+    def test_empty_entries(self):
+        result = analyze_symbols([])
+        assert result == {}
+
+    def test_first_last_seen(self, journal_dir):
+        entries = scan_journal(journal_dir)
+        result = analyze_symbols(entries)
+        assert result["water"]["first_seen"] is not None
+        assert result["water"]["last_seen"] is not None

package/lib/bmad-cache/bmb/samples/bmad-excalidraw/bmad-manifest.json

@@ -0,0 +1,18 @@
+{
+  "capabilities": [
+    {
+      "name": "guided-design",
+      "menu-code": "GD",
+      "description": "Facilitates diagram design through conversational discovery.",
+      "supports-headless": true,
+      "prompt": "guided-design.md"
+    },
+    {
+      "name": "diagram-generation",
+      "menu-code": "DG",
+      "description": "Generates Excalidraw diagram files from specifications.",
+      "supports-headless": true,
+      "prompt": "diagram-generation.md"
+    }
+  ]
+}