claude-flow 2.7.0-alpha.12 → 2.7.0-alpha.14

package/.claude/skills/reasoningbank-agentdb/SKILL.md

@@ -0,0 +1,446 @@
+---
+name: "ReasoningBank with AgentDB"
+description: "Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems."
+---
+
+# ReasoningBank with AgentDB
+
+## What This Skill Does
+
+Provides ReasoningBank adaptive learning patterns using AgentDB's high-performance backend (150x-12,500x faster). Enables agents to learn from experiences, judge outcomes, distill memories, and improve decision-making over time with 100% backward compatibility.
+
+**Performance**: 150x faster pattern retrieval, 500x faster batch operations, <1ms memory access.
+
+## Prerequisites
+
+- Node.js 18+
+- AgentDB v1.0.7+ (via agentic-flow)
+- Understanding of reinforcement learning concepts (optional)
+
+---
+
+## Quick Start with CLI
+
+### Initialize ReasoningBank Database
+
+```bash
+# Initialize AgentDB for ReasoningBank
+npx agentdb@latest init ./.agentdb/reasoningbank.db --dimension 1536
+
+# Start MCP server for Claude Code integration
+npx agentdb@latest mcp
+claude mcp add agentdb npx agentdb@latest mcp
+```
+
+### Migrate from Legacy ReasoningBank
+
+```bash
+# Automatic migration with validation
+npx agentdb@latest migrate --source .swarm/memory.db
+
+# Verify migration
+npx agentdb@latest stats ./.agentdb/reasoningbank.db
+```
+
+---
+
+## Quick Start with API
+
+```typescript
+import { createAgentDBAdapter, computeEmbedding } from 'agentic-flow/reasoningbank';
+
+// Initialize ReasoningBank with AgentDB
+const rb = await createAgentDBAdapter({
+  dbPath: '.agentdb/reasoningbank.db',
+  enableLearning: true,      // Enable learning plugins
+  enableReasoning: true,      // Enable reasoning agents
+  cacheSize: 1000,            // 1000 pattern cache
+});
+
+// Store successful experience
+const query = "How to optimize database queries?";
+const embedding = await computeEmbedding(query);
+
+await rb.insertPattern({
+  id: '',
+  type: 'experience',
+  domain: 'database-optimization',
+  pattern_data: JSON.stringify({
+    embedding,
+    pattern: {
+      query,
+      approach: 'indexing + query optimization',
+      outcome: 'success',
+      metrics: { latency_reduction: 0.85 }
+    }
+  }),
+  confidence: 0.95,
+  usage_count: 1,
+  success_count: 1,
+  created_at: Date.now(),
+  last_used: Date.now(),
+});
+
+// Retrieve similar experiences with reasoning
+const result = await rb.retrieveWithReasoning(embedding, {
+  domain: 'database-optimization',
+  k: 5,
+  useMMR: true,              // Diverse results
+  synthesizeContext: true,    // Rich context synthesis
+});
+
+console.log('Memories:', result.memories);
+console.log('Context:', result.context);
+console.log('Patterns:', result.patterns);
+```
+
+---
+
+## Core ReasoningBank Concepts
+
+### 1. Trajectory Tracking
+
+Track agent execution paths and outcomes:
+
+```typescript
+// Record trajectory (sequence of actions)
+const trajectory = {
+  task: 'optimize-api-endpoint',
+  steps: [
+    { action: 'analyze-bottleneck', result: 'found N+1 query' },
+    { action: 'add-eager-loading', result: 'reduced queries' },
+    { action: 'add-caching', result: 'improved latency' }
+  ],
+  outcome: 'success',
+  metrics: { latency_before: 2500, latency_after: 150 }
+};
+
+const embedding = await computeEmbedding(JSON.stringify(trajectory));
+
+await rb.insertPattern({
+  id: '',
+  type: 'trajectory',
+  domain: 'api-optimization',
+  pattern_data: JSON.stringify({ embedding, pattern: trajectory }),
+  confidence: 0.9,
+  usage_count: 1,
+  success_count: 1,
+  created_at: Date.now(),
+  last_used: Date.now(),
+});
+```
+
+### 2. Verdict Judgment
+
+Judge whether a trajectory was successful:
+
+```typescript
+// Retrieve similar past trajectories
+const similar = await rb.retrieveWithReasoning(queryEmbedding, {
+  domain: 'api-optimization',
+  k: 10,
+});
+
+// Judge based on similarity to successful patterns
+const verdict = similar.memories.filter(m =>
+  m.pattern.outcome === 'success' &&
+  m.similarity > 0.8
+).length > 5 ? 'likely_success' : 'needs_review';
+
+console.log('Verdict:', verdict);
+console.log('Confidence:', similar.memories[0]?.similarity || 0);
+```
+
+### 3. Memory Distillation
+
+Consolidate similar experiences into patterns:
+
+```typescript
+// Get all experiences in domain
+const experiences = await rb.retrieveWithReasoning(embedding, {
+  domain: 'api-optimization',
+  k: 100,
+  optimizeMemory: true,  // Automatic consolidation
+});
+
+// Distill into high-level pattern
+const distilledPattern = {
+  domain: 'api-optimization',
+  pattern: 'For N+1 queries: add eager loading, then cache',
+  success_rate: 0.92,
+  sample_size: experiences.memories.length,
+  confidence: 0.95
+};
+
+await rb.insertPattern({
+  id: '',
+  type: 'distilled-pattern',
+  domain: 'api-optimization',
+  pattern_data: JSON.stringify({
+    embedding: await computeEmbedding(JSON.stringify(distilledPattern)),
+    pattern: distilledPattern
+  }),
+  confidence: 0.95,
+  usage_count: 0,
+  success_count: 0,
+  created_at: Date.now(),
+  last_used: Date.now(),
+});
+```
+
+---
+
+## Integration with Reasoning Agents
+
+AgentDB provides 4 reasoning modules that enhance ReasoningBank:
+
+### 1. PatternMatcher
+
+Find similar successful patterns:
+
+```typescript
+const result = await rb.retrieveWithReasoning(queryEmbedding, {
+  domain: 'problem-solving',
+  k: 10,
+  useMMR: true,  // Maximal Marginal Relevance for diversity
+});
+
+// PatternMatcher returns diverse, relevant memories
+result.memories.forEach(mem => {
+  console.log(`Pattern: ${mem.pattern.approach}`);
+  console.log(`Similarity: ${mem.similarity}`);
+  console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);
+});
+```
+
+### 2. ContextSynthesizer
+
+Generate rich context from multiple memories:
+
+```typescript
+const result = await rb.retrieveWithReasoning(queryEmbedding, {
+  domain: 'code-optimization',
+  synthesizeContext: true,  // Enable context synthesis
+  k: 5,
+});
+
+// ContextSynthesizer creates coherent narrative
+console.log('Synthesized Context:', result.context);
+// "Based on 5 similar optimizations, the most effective approach
+//  involves profiling, identifying bottlenecks, and applying targeted
+//  improvements. Success rate: 87%"
+```
+
+### 3. MemoryOptimizer
+
+Automatically consolidate and prune:
+
+```typescript
+const result = await rb.retrieveWithReasoning(queryEmbedding, {
+  domain: 'testing',
+  optimizeMemory: true,  // Enable automatic optimization
+});
+
+// MemoryOptimizer consolidates similar patterns and prunes low-quality
+console.log('Optimizations:', result.optimizations);
+// { consolidated: 15, pruned: 3, improved_quality: 0.12 }
+```
+
+### 4. ExperienceCurator
+
+Filter by quality and relevance:
+
+```typescript
+const result = await rb.retrieveWithReasoning(queryEmbedding, {
+  domain: 'debugging',
+  k: 20,
+  minConfidence: 0.8,  // Only high-confidence experiences
+});
+
+// ExperienceCurator returns only quality experiences
+result.memories.forEach(mem => {
+  console.log(`Confidence: ${mem.confidence}`);
+  console.log(`Success Rate: ${mem.success_count / mem.usage_count}`);
+});
+```
+
+---
+
+## Legacy API Compatibility
+
+AgentDB maintains 100% backward compatibility with legacy ReasoningBank:
+
+```typescript
+import {
+  retrieveMemories,
+  judgeTrajectory,
+  distillMemories
+} from 'agentic-flow/reasoningbank';
+
+// Legacy API works unchanged (uses AgentDB backend automatically)
+const memories = await retrieveMemories(query, {
+  domain: 'code-generation',
+  agent: 'coder'
+});
+
+const verdict = await judgeTrajectory(trajectory, query);
+
+const newMemories = await distillMemories(
+  trajectory,
+  verdict,
+  query,
+  { domain: 'code-generation' }
+);
+```
+
+---
+
+## Performance Characteristics
+
+- **Pattern Search**: 150x faster (100µs vs 15ms)
+- **Memory Retrieval**: <1ms (with cache)
+- **Batch Insert**: 500x faster (2ms vs 1s for 100 patterns)
+- **Trajectory Judgment**: <5ms (including retrieval + analysis)
+- **Memory Distillation**: <50ms (consolidate 100 patterns)
+
+---
+
+## Advanced Patterns
+
+### Hierarchical Memory
+
+Organize memories by abstraction level:
+
+```typescript
+// Low-level: Specific implementation
+await rb.insertPattern({
+  type: 'concrete',
+  domain: 'debugging/null-pointer',
+  pattern_data: JSON.stringify({
+    embedding,
+    pattern: { bug: 'NPE in UserService.getUser()', fix: 'Add null check' }
+  }),
+  confidence: 0.9,
+  // ...
+});
+
+// Mid-level: Pattern across similar cases
+await rb.insertPattern({
+  type: 'pattern',
+  domain: 'debugging',
+  pattern_data: JSON.stringify({
+    embedding,
+    pattern: { category: 'null-pointer', approach: 'defensive-checks' }
+  }),
+  confidence: 0.85,
+  // ...
+});
+
+// High-level: General principle
+await rb.insertPattern({
+  type: 'principle',
+  domain: 'software-engineering',
+  pattern_data: JSON.stringify({
+    embedding,
+    pattern: { principle: 'fail-fast with clear errors' }
+  }),
+  confidence: 0.95,
+  // ...
+});
+```
+
+### Multi-Domain Learning
+
+Transfer learning across domains:
+
+```typescript
+// Learn from backend optimization
+const backendExperience = await rb.retrieveWithReasoning(embedding, {
+  domain: 'backend-optimization',
+  k: 10,
+});
+
+// Apply to frontend optimization
+const transferredKnowledge = backendExperience.memories.map(mem => ({
+  ...mem,
+  domain: 'frontend-optimization',
+  adapted: true,
+}));
+```
+
+---
+
+## CLI Operations
+
+### Database Management
+
+```bash
+# Export trajectories and patterns
+npx agentdb@latest export ./.agentdb/reasoningbank.db ./backup.json
+
+# Import experiences
+npx agentdb@latest import ./experiences.json
+
+# Get statistics
+npx agentdb@latest stats ./.agentdb/reasoningbank.db
+# Shows: total patterns, domains, confidence distribution
+```
+
+### Migration
+
+```bash
+# Migrate from legacy ReasoningBank
+npx agentdb@latest migrate --source .swarm/memory.db --target .agentdb/reasoningbank.db
+
+# Validate migration
+npx agentdb@latest stats .agentdb/reasoningbank.db
+```
+
+---
+
+## Troubleshooting
+
+### Issue: Migration fails
+```bash
+# Check source database exists
+ls -la .swarm/memory.db
+
+# Run with verbose logging
+DEBUG=agentdb:* npx agentdb@latest migrate --source .swarm/memory.db
+```
+
+### Issue: Low confidence scores
+```typescript
+// Enable context synthesis for better quality
+const result = await rb.retrieveWithReasoning(embedding, {
+  synthesizeContext: true,
+  useMMR: true,
+  k: 10,
+});
+```
+
+### Issue: Memory growing too large
+```typescript
+// Enable automatic optimization
+const result = await rb.retrieveWithReasoning(embedding, {
+  optimizeMemory: true,  // Consolidates similar patterns
+});
+
+// Or manually optimize
+await rb.optimize();
+```
+
+---
+
+## Learn More
+
+- **AgentDB Integration**: node_modules/agentic-flow/docs/AGENTDB_INTEGRATION.md
+- **GitHub**: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
+- **MCP Integration**: `npx agentdb@latest mcp`
+- **Website**: https://agentdb.ruv.io
+
+---
+
+**Category**: Machine Learning / Reinforcement Learning
+**Difficulty**: Intermediate
+**Estimated Time**: 20-30 minutes

package/CHANGELOG.md

@@ -5,6 +5,94 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.7.0-alpha.14] - 2025-10-20
+
+> **📚 AgentDB Skills Expansion**: Comprehensive AgentDB documentation with 6 specialized skills covering all CLI commands and advanced features
+
+### ✨ New Features
+
+#### **AgentDB Skills Suite (6 Total)**
+
+**Updated Skills (2)**:
+- **agentdb-memory-patterns** - Enhanced with all `npx agentdb@latest` CLI commands
+  - Added: `init`, `mcp`, `create-plugin`, `query`, `import/export`, `stats`, `benchmark`
+  - Added: 9 learning algorithms documentation
+  - Added: 4 reasoning agents (PatternMatcher, ContextSynthesizer, MemoryOptimizer, ExperienceCurator)
+  - Added: Performance characteristics (150x-12,500x improvements)
+  - Added: MCP server integration instructions
+
+- **agentdb-vector-search** - Comprehensive vector search documentation
+  - Added: All CLI commands with distance metrics (cosine, euclidean, dot)
+  - Added: Quantization options (binary 32x, scalar 4x, product 8-16x)
+  - Added: HNSW indexing details (<100µs search)
+  - Added: MCP integration and performance benchmarks
+  - Added: RAG pipeline examples
+
+**New Skills (4)**:
+- **reasoningbank-agentdb** (~420 lines) - ReasoningBank integration with AgentDB backend
+  - Trajectory tracking and verdict judgment
+  - Memory distillation and pattern recognition
+  - 4 reasoning agents integration
+  - Legacy API 100% backward compatibility
+  - Migration tools from legacy ReasoningBank
+
+- **agentdb-learning** (~450 lines) - AI learning plugins and reinforcement learning
+  - 9 RL algorithms: Decision Transformer, Q-Learning, SARSA, Actor-Critic, Active Learning, Adversarial Training, Curriculum Learning, Federated Learning, Multi-Task Learning
+  - Plugin creation and management via CLI
+  - Training workflows and experience replay
+  - Multi-agent training patterns
+
+- **agentdb-optimization** (~480 lines) - Performance optimization and scalability
+  - Quantization strategies (4-32x memory reduction)
+  - HNSW indexing (O(log n) search, <100µs)
+  - Caching strategies (LRU cache, <1ms retrieval)
+  - Batch operations (500x faster)
+  - Optimization recipes for different scales (small to massive)
+  - Scaling strategies and performance monitoring
+
+- **agentdb-advanced** (~490 lines) - Advanced distributed systems features
+  - QUIC synchronization (<1ms latency)
+  - Custom distance metrics
+  - Hybrid search (vector + metadata filtering)
+  - Multi-database management and sharding
+  - MMR (Maximal Marginal Relevance)
+  - Production patterns (connection pooling, error handling, monitoring)
+  - Multi-node deployment
+
+### 📊 Coverage
+
+**CLI Commands**: All 12 AgentDB commands fully documented
+- `init`, `mcp`, `create-plugin`, `list-plugins`, `list-templates`, `plugin-info`
+- `query`, `import`, `export`, `stats`, `benchmark`, `version`
+
+**Algorithms**: 9 reinforcement learning algorithms
+**Reasoning Agents**: 4 modules for intelligent pattern matching
+**Quantization**: 3 types with 4-32x memory reduction
+**Performance**: 150x-12,500x improvements documented
+
+### 📦 Distribution
+
+- ✅ All 6 AgentDB skills included in `.claude/skills/` directory
+- ✅ Skills distributed with npm package via `.claude/` in files array
+- ✅ Total: ~2,520 lines of comprehensive documentation
+- ✅ All skills follow skill-builder specification with proper YAML frontmatter
+- ✅ Progressive disclosure structure (4 levels)
+- ✅ Cross-references between skills
+
+### 🎯 Use Case Mapping
+
+- **Stateful chatbots** → `agentdb-memory-patterns`
+- **Semantic search/RAG** → `agentdb-vector-search`
+- **Self-learning agents** → `reasoningbank-agentdb`, `agentdb-learning`
+- **Performance tuning** → `agentdb-optimization`
+- **Distributed AI systems** → `agentdb-advanced`
+
+### 🔗 Resources
+
+- GitHub: https://github.com/ruvnet/agentic-flow/tree/main/packages/agentdb
+- Website: https://agentdb.ruv.io
+- MCP Integration: `npx agentdb@latest mcp`
+
 ## [2.7.0-alpha.12] - 2025-10-20
 
 > **🔧 Critical Bug Fixes**: Skills system and statusline initialization now work correctly in all npm install scenarios

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.7.0-alpha.12"
+VERSION="2.7.0-alpha.14"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

package/dist/agents/agent-loader.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Dynamic Agent Loader - Reads agent definitions from .claude/agents/ directory
+ * This is the single source of truth for all agent types in the system
+ */
+declare const LEGACY_AGENT_MAPPING: {
+    readonly analyst: "code-analyzer";
+    readonly coordinator: "task-orchestrator";
+    readonly optimizer: "perf-analyzer";
+    readonly documenter: "api-docs";
+    readonly monitor: "performance-benchmarker";
+    readonly specialist: "system-architect";
+    readonly architect: "system-architect";
+};
+/**
+ * Resolve legacy agent types to current equivalents
+ */
+declare function resolveLegacyAgentType(legacyType: string): string;
+export interface AgentDefinition {
+    name: string;
+    type?: string;
+    color?: string;
+    description: string;
+    capabilities?: string[];
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    hooks?: {
+        pre?: string;
+        post?: string;
+    };
+    content?: string;
+}
+export interface AgentCategory {
+    name: string;
+    agents: AgentDefinition[];
+}
+declare class AgentLoader {
+    private agentCache;
+    private categoriesCache;
+    private lastLoadTime;
+    private cacheExpiry;
+    /**
+     * Get the .claude/agents directory path
+     */
+    private getAgentsDirectory;
+    /**
+     * Parse agent definition from markdown file
+     */
+    private parseAgentFile;
+    /**
+     * Load all agent definitions from .claude/agents directory
+     */
+    private loadAgents;
+    /**
+     * Check if cache needs refresh
+     */
+    private needsRefresh;
+    /**
+     * Ensure agents are loaded and cache is fresh
+     */
+    private ensureLoaded;
+    /**
+     * Get all available agent types
+     */
+    getAvailableAgentTypes(): Promise<string[]>;
+    /**
+     * Get agent definition by name
+     */
+    getAgent(name: string): Promise<AgentDefinition | null>;
+    /**
+     * Get all agent definitions
+     */
+    getAllAgents(): Promise<AgentDefinition[]>;
+    /**
+     * Get agents organized by category
+     */
+    getAgentCategories(): Promise<AgentCategory[]>;
+    /**
+     * Search agents by capabilities, description, or name
+     */
+    searchAgents(query: string): Promise<AgentDefinition[]>;
+    /**
+     * Check if an agent type is valid
+     */
+    isValidAgentType(name: string): Promise<boolean>;
+    /**
+     * Get agents by category name
+     */
+    getAgentsByCategory(category: string): Promise<AgentDefinition[]>;
+    /**
+     * Force refresh the agent cache
+     */
+    refresh(): Promise<void>;
+}
+export declare const agentLoader: AgentLoader;
+export declare const getAvailableAgentTypes: () => Promise<string[]>;
+export declare const getAgent: (name: string) => Promise<AgentDefinition>;
+export declare const getAllAgents: () => Promise<AgentDefinition[]>;
+export declare const getAgentCategories: () => Promise<AgentCategory[]>;
+export declare const searchAgents: (query: string) => Promise<AgentDefinition[]>;
+export declare const isValidAgentType: (name: string) => Promise<boolean>;
+export declare const getAgentsByCategory: (category: string) => Promise<AgentDefinition[]>;
+export declare const refreshAgents: () => Promise<void>;
+export { resolveLegacyAgentType, LEGACY_AGENT_MAPPING };
+//# sourceMappingURL=agent-loader.d.ts.map

package/dist/agents/agent-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-loader.d.ts","sourceRoot":"","sources":["../../src/agents/agent-loader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,QAAA,MAAM,oBAAoB;;;;;;;;CAQhB,CAAC;AAEX;;GAEG;AACH,iBAAS,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAClD,KAAK,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,cAAM,WAAW;IACf,OAAO,CAAC,UAAU,CAA2C;IAC7D,OAAO,CAAC,eAAe,CAAuB;IAC9C,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,WAAW,CAAS;IAE5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,CAAC,cAAc;IAmCtB;;OAEG;YACW,UAAU;IAiDxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;YACW,YAAY;IAM1B;;OAEG;IACG,sBAAsB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAUjD;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;IAM7D;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAKhD;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAKpD;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAc7D;;OAEG;IACG,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAMtD;;OAEG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAMvE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAI/B;AAGD,eAAO,MAAM,WAAW,aAAoB,CAAC;AAG7C,eAAO,MAAM,sBAAsB,yBAA6C,CAAC;AACjF,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,6BAA+B,CAAC;AACrE,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAC7D,eAAO,MAAM,kBAAkB,gCAAyC,CAAC;AACzE,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,+BAAoC,CAAC;AAC/E,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,qBAAuC,CAAC;AACrF,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,+BAA8C,CAAC;AACnG,eAAO,MAAM,aAAa,qBAA8B,CAAC;AAGzD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAC"}