ma-agents 2.19.2 → 2.20.0

package/lib/bmad-cache/bmb/package.json

@@ -0,0 +1,96 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "bmad-builder",
+  "type": "module",
+  "version": "1.0.2",
+  "description": "A BMad Core expansion module that guides users through the creation of Modules Workflow and Agents",
+  "keywords": [
+    "bmad"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bmad-code-org/bmad-builder.git"
+  },
+  "license": "MIT",
+  "author": "Brian (BMad) Madison",
+  "files": [
+    "src/",
+    "CHANGELOG.md"
+  ],
+  "main": "",
+  "scripts": {
+    "docs:build": "node tools/build-docs.mjs",
+    "docs:dev": "astro dev --root website",
+    "docs:preview": "astro preview --root website",
+    "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,yaml}\"",
+    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,yaml}\"",
+    "lint": "eslint . --ext .js,.cjs,.mjs,.yaml --max-warnings=0",
+    "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
+    "lint:md": "markdownlint-cli2 \"**/*.md\"",
+    "prepare": "husky || exit 0",
+    "release": "npm run release:patch",
+    "release:major": "npm version major && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:prerelease": "npm version prerelease && git push --follow-tags",
+    "test": "npm run test:schemas && npm run test:refs && npm run validate:schemas && npm run lint && npm run lint:md && npm run format:check",
+    "test:refs": "node test/test-validate-file-refs.cjs",
+    "test:schemas": "node test/test-agent-schema.js",
+    "validate:refs": "node tools/validate-file-refs.mjs",
+    "validate:schemas": "node test/validate-agent-schema.js"
+  },
+  "lint-staged": {
+    "*.{js,cjs,mjs}": [
+      "npm run lint:fix",
+      "npm run format:fix"
+    ],
+    "*.yaml": [
+      "eslint --fix",
+      "npm run format:fix"
+    ],
+    "*.json": [
+      "npm run format:fix"
+    ],
+    "*.md": [
+      "markdownlint-cli2"
+    ]
+  },
+  "devDependencies": {
+    "@astrojs/sitemap": "^3.6.0",
+    "@astrojs/starlight": "^0.37.0",
+    "@eslint/js": "^9.33.0",
+    "archiver": "^7.0.1",
+    "astro": "^5.16.0",
+    "c8": "^10.1.3",
+    "csv-parse": "^6.1.0",
+    "eslint": "^9.33.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-n": "^17.21.3",
+    "eslint-plugin-unicorn": "^60.0.0",
+    "eslint-plugin-yml": "^1.18.0",
+    "figlet": "^1.8.0",
+    "glob": "^11.0.3",
+    "husky": "^9.1.7",
+    "ignore": "^7.0.5",
+    "jest": "^30.2.0",
+    "js-yaml": "^4.1.0",
+    "lint-staged": "^16.1.1",
+    "markdownlint-cli2": "^0.19.1",
+    "ora": "^5.4.1",
+    "prettier": "^3.7.4",
+    "prettier-plugin-packagejson": "^2.5.19",
+    "semver": "^7.6.3",
+    "sharp": "^0.33.5",
+    "wrap-ansi": "^7.0.0",
+    "xml2js": "^0.6.2",
+    "yaml": "^2.7.0",
+    "yaml-eslint-parser": "^1.2.3",
+    "yaml-lint": "^1.7.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/lib/bmad-cache/bmb/prettier.config.mjs

@@ -0,0 +1,32 @@
+export default {
+  $schema: 'https://json.schemastore.org/prettierrc',
+  printWidth: 140,
+  tabWidth: 2,
+  useTabs: false,
+  semi: true,
+  singleQuote: true,
+  trailingComma: 'all',
+  bracketSpacing: true,
+  arrowParens: 'always',
+  endOfLine: 'lf',
+  proseWrap: 'preserve',
+  overrides: [
+    {
+      files: ['*.md'],
+      options: { proseWrap: 'preserve' },
+    },
+    {
+      files: ['*.yaml'],
+      options: { singleQuote: false },
+    },
+    {
+      files: ['*.json', '*.jsonc'],
+      options: { singleQuote: false },
+    },
+    {
+      files: ['*.cjs'],
+      options: { parser: 'babel' },
+    },
+  ],
+  plugins: ['prettier-plugin-packagejson'],
+};

package/lib/bmad-cache/bmb/samples/bmad-agent-dream-weaver/bmad-manifest.json

@@ -0,0 +1,62 @@
+{
+  "persona": "A warm, perceptive dream guide who blends psychological insight with poetic intuition — part analyst, part coach, part poet, wholly fascinated by the landscapes of your sleeping mind.",
+  "has-memory": true,
+  "capabilities": [
+    {
+      "name": "dream-log",
+      "menu-code": "DL",
+      "description": "Capture a dream through guided conversation.",
+      "type": "prompt",
+      "prompt": "dream-log.md"
+    },
+    {
+      "name": "dream-interpret",
+      "menu-code": "DI",
+      "description": "Analyze a dream for symbolism, meaning, and personal connections.",
+      "type": "prompt",
+      "prompt": "dream-interpret.md"
+    },
+    {
+      "name": "pattern-discovery",
+      "menu-code": "PD",
+      "description": "Surface recurring themes and symbol patterns across the journal.",
+      "type": "prompt",
+      "prompt": "pattern-discovery.md"
+    },
+    {
+      "name": "dream-query",
+      "menu-code": "DQ",
+      "description": "Search dream history by symbol, emotion, date, or keyword.",
+      "type": "prompt",
+      "prompt": "dream-query.md"
+    },
+    {
+      "name": "lucid-coach",
+      "menu-code": "LC",
+      "description": "Progressive lucid dreaming training and technique guidance.",
+      "type": "prompt",
+      "prompt": "lucid-coach.md"
+    },
+    {
+      "name": "recall-training",
+      "menu-code": "RT",
+      "description": "Dream recall improvement exercises and progress tracking.",
+      "type": "prompt",
+      "prompt": "recall-training.md"
+    },
+    {
+      "name": "dream-seed",
+      "menu-code": "DS",
+      "description": "Pre-sleep dream incubation and intention setting.",
+      "type": "prompt",
+      "prompt": "dream-seed.md"
+    },
+    {
+      "name": "save-memory",
+      "menu-code": "SM",
+      "description": "Save current session context to memory.",
+      "type": "prompt",
+      "prompt": "save-memory.md"
+    }
+  ]
+}

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

@@ -0,0 +1,229 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml"]
+# ///
+"""
+Dream recall metrics calculator for Dream Weaver.
+
+Analyzes journal entries to calculate recall rates, streaks,
+vividness trends, and quality distributions.
+
+Usage:
+    uv run scripts/recall_metrics.py --journal-path PATH [--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) -> list[dict]:
+    """Scan all journal entries and extract metadata."""
+    entries = []
+    for file in sorted(journal_path.glob("*.md")):
+        fm = parse_frontmatter(file)
+        if not 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
+
+        entries.append({
+            "file": file.name,
+            "date": entry_date,
+            "vividness": fm.get("vividness"),
+            "recall_quality": fm.get("recall_quality", "medium"),
+            "lucid": fm.get("lucid", False),
+        })
+
+    return entries
+
+
+def calculate_metrics(entries: list[dict]) -> dict:
+    """Calculate recall metrics from journal entries."""
+    if not entries:
+        return {
+            "total_dreams": 0,
+            "dreams_per_week": 0,
+            "current_streak": 0,
+            "longest_streak": 0,
+            "avg_vividness": 0,
+            "vividness_trend": "insufficient_data",
+            "quality_distribution": {},
+            "lucid_count": 0,
+            "weekly_counts": [],
+        }
+
+    # Group by date
+    dreams_by_date = defaultdict(list)
+    for entry in entries:
+        if entry["date"]:
+            dreams_by_date[entry["date"]].append(entry)
+
+    sorted_dates = sorted(dreams_by_date.keys())
+
+    if not sorted_dates:
+        return {"total_dreams": len(entries), "error": "no_dated_entries"}
+
+    # Date range
+    first_date = sorted_dates[0]
+    last_date = sorted_dates[-1]
+    total_days = max((last_date - first_date).days, 1)
+    total_weeks = max(total_days / 7, 1)
+
+    # Dreams per week
+    dreams_per_week = round(len(entries) / total_weeks, 1)
+
+    # Streak calculation
+    today = datetime.now().date()
+    current_streak = 0
+    check_date = today
+    while check_date in dreams_by_date or check_date == today:
+        if check_date in dreams_by_date:
+            current_streak += 1
+        elif check_date != today:
+            break
+        check_date -= timedelta(days=1)
+
+    longest_streak = 0
+    streak = 0
+    for i, date in enumerate(sorted_dates):
+        if i == 0 or (date - sorted_dates[i - 1]).days == 1:
+            streak += 1
+        else:
+            longest_streak = max(longest_streak, streak)
+            streak = 1
+    longest_streak = max(longest_streak, streak)
+
+    # Vividness
+    vividness_scores = [
+        e["vividness"] for e in entries if e["vividness"] is not None
+    ]
+    avg_vividness = (
+        round(sum(vividness_scores) / len(vividness_scores), 1)
+        if vividness_scores
+        else 0
+    )
+
+    # Vividness trend (compare first half to second half)
+    vividness_trend = "insufficient_data"
+    if len(vividness_scores) >= 4:
+        mid = len(vividness_scores) // 2
+        first_half = sum(vividness_scores[:mid]) / mid
+        second_half = sum(vividness_scores[mid:]) / (len(vividness_scores) - mid)
+        diff = second_half - first_half
+        if diff > 0.5:
+            vividness_trend = "improving"
+        elif diff < -0.5:
+            vividness_trend = "declining"
+        else:
+            vividness_trend = "stable"
+
+    # Quality distribution
+    quality_counts = Counter(e["recall_quality"] for e in entries)
+
+    # Lucid count
+    lucid_count = sum(1 for e in entries if e.get("lucid"))
+
+    # Weekly counts (last 8 weeks)
+    weekly_counts = []
+    for weeks_ago in range(7, -1, -1):
+        week_start = today - timedelta(weeks=weeks_ago, days=today.weekday())
+        week_end = week_start + timedelta(days=6)
+        count = sum(
+            len(dreams)
+            for date, dreams in dreams_by_date.items()
+            if week_start <= date <= week_end
+        )
+        weekly_counts.append({
+            "week_start": str(week_start),
+            "count": count,
+        })
+
+    return {
+        "total_dreams": len(entries),
+        "dreams_per_week": dreams_per_week,
+        "current_streak": current_streak,
+        "longest_streak": longest_streak,
+        "avg_vividness": avg_vividness,
+        "vividness_trend": vividness_trend,
+        "quality_distribution": dict(quality_counts),
+        "lucid_count": lucid_count,
+        "weekly_counts": weekly_counts,
+        "date_range": {
+            "first": str(first_date),
+            "last": str(last_date),
+            "total_days": total_days,
+        },
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Calculate dream recall metrics"
+    )
+    parser.add_argument(
+        "--journal-path", required=True, help="Path to journal folder"
+    )
+    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": "recall_metrics",
+                "status": "error",
+                "error": f"Journal path not found: {journal_path}",
+            }),
+            file=sys.stdout,
+        )
+        sys.exit(2)
+
+    entries = scan_journal(journal_path)
+
+    if args.verbose:
+        print(f"Found {len(entries)} journal entries", file=sys.stderr)
+
+    metrics = calculate_metrics(entries)
+
+    output = {
+        "script": "recall_metrics",
+        "version": "1.0.0",
+        "journal_path": str(journal_path),
+        "timestamp": datetime.now().isoformat(),
+        "status": "pass",
+        "metrics": metrics,
+    }
+
+    print(json.dumps(output, indent=2))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()
+
+

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

@@ -0,0 +1,156 @@
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["pyyaml"]
+# ///
+"""
+Dream seed tracking and success rate analysis for Dream Weaver.
+
+Reads seed-log.yaml and calculates incubation success rates,
+technique effectiveness, and correlation stats.
+
+Usage:
+    uv run scripts/seed_tracker.py --seed-log PATH [--verbose]
+"""
+
+import argparse
+import json
+import sys
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+import yaml
+
+
+def load_seed_log(seed_log_path: Path) -> list[dict]:
+    """Load and parse seed-log.yaml."""
+    try:
+        content = seed_log_path.read_text(encoding="utf-8")
+        data = yaml.safe_load(content)
+        if not data or "seeds" not in data:
+            return []
+        return data["seeds"]
+    except (yaml.YAMLError, FileNotFoundError):
+        return []
+
+
+def analyze_seeds(seeds: list[dict]) -> dict:
+    """Analyze seed success rates and technique effectiveness."""
+    if not seeds:
+        return {
+            "total_seeds": 0,
+            "success_rate": 0,
+            "technique_stats": {},
+            "result_distribution": {},
+        }
+
+    # Result distribution
+    result_counts = Counter()
+    technique_results = {}
+
+    for seed in seeds:
+        result = seed.get("result", "pending")
+        technique = seed.get("technique", "unknown")
+
+        result_counts[result] += 1
+
+        if technique not in technique_results:
+            technique_results[technique] = Counter()
+        technique_results[technique][result] += 1
+
+    # Overall success rate (partial + full / total non-pending)
+    resolved = sum(
+        count for result, count in result_counts.items() if result != "pending"
+    )
+    successes = result_counts.get("partial", 0) + result_counts.get("full", 0)
+    success_rate = round(successes / resolved, 2) if resolved > 0 else 0
+
+    # Technique effectiveness
+    technique_stats = {}
+    for technique, results in technique_results.items():
+        tech_resolved = sum(
+            count for result, count in results.items() if result != "pending"
+        )
+        tech_successes = results.get("partial", 0) + results.get("full", 0)
+        technique_stats[technique] = {
+            "total": sum(results.values()),
+            "resolved": tech_resolved,
+            "successes": tech_successes,
+            "success_rate": (
+                round(tech_successes / tech_resolved, 2) if tech_resolved > 0 else 0
+            ),
+            "results": dict(results),
+        }
+
+    # Recent trend (last 5 resolved seeds)
+    resolved_seeds = [s for s in seeds if s.get("result") not in ("pending", None)]
+    recent = resolved_seeds[-5:] if len(resolved_seeds) >= 5 else resolved_seeds
+    recent_successes = sum(
+        1 for s in recent if s.get("result") in ("partial", "full")
+    )
+    recent_rate = (
+        round(recent_successes / len(recent), 2) if recent else 0
+    )
+
+    return {
+        "total_seeds": len(seeds),
+        "pending": result_counts.get("pending", 0),
+        "resolved": resolved,
+        "success_rate": success_rate,
+        "recent_trend_rate": recent_rate,
+        "result_distribution": dict(result_counts),
+        "technique_stats": technique_stats,
+        "best_technique": (
+            max(technique_stats, key=lambda t: technique_stats[t]["success_rate"])
+            if technique_stats
+            else None
+        ),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Analyze dream seed success rates"
+    )
+    parser.add_argument(
+        "--seed-log", required=True, help="Path to seed-log.yaml"
+    )
+    parser.add_argument(
+        "--verbose", action="store_true", help="Print diagnostics to stderr"
+    )
+    args = parser.parse_args()
+
+    seed_log_path = Path(args.seed_log)
+    if not seed_log_path.is_file():
+        print(
+            json.dumps({
+                "script": "seed_tracker",
+                "status": "error",
+                "error": f"Seed log not found: {seed_log_path}",
+            }),
+            file=sys.stdout,
+        )
+        sys.exit(2)
+
+    seeds = load_seed_log(seed_log_path)
+
+    if args.verbose:
+        print(f"Found {len(seeds)} seed entries", file=sys.stderr)
+
+    analysis = analyze_seeds(seeds)
+
+    output = {
+        "script": "seed_tracker",
+        "version": "1.0.0",
+        "seed_log_path": str(seed_log_path),
+        "timestamp": datetime.now().isoformat(),
+        "status": "pass",
+        "analysis": analysis,
+    }
+
+    print(json.dumps(output, indent=2))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()