@monoes/monomindcli 1.10.54 → 1.10.55

package/.claude/skills/agentdb-vector-search/SKILL.md

@@ -1,335 +0,0 @@
----
-name: agentdb-vector-search
-description: "Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Use when building RAG systems, semantic search engines, or intelligent knowledge bases."
----
-
-# AgentDB Vector Search
-
-## What This Skill Does
-
-Implements vector-based semantic search using AgentDB's high-performance vector database with **150x-12,500x faster** operations than traditional solutions. Features HNSW indexing, quantization, and sub-millisecond search (<100µs).
-
-## Prerequisites
-
-- Node.js 18+
-- @monomind/memory package
-- OpenAI API key (for embeddings) or custom embedding model
-
-## Quick Start with CLI
-
-### Initialize Vector Database
-
-```bash
-# Initialize with default dimensions (1536 for OpenAI ada-002)
-npx monomind memory init ./vectors.db
-
-# Custom dimensions for different embedding models
-npx monomind memory init ./vectors.db --dimension 768  # sentence-transformers
-npx monomind memory init ./vectors.db --dimension 384  # all-MiniLM-L6-v2
-
-# Use preset configurations
-npx monomind memory init ./vectors.db --preset small   # <10K vectors
-npx monomind memory init ./vectors.db --preset medium  # 10K-100K vectors
-npx monomind memory init ./vectors.db --preset large   # >100K vectors
-
-# In-memory database for testing
-npx monomind memory init ./vectors.db --in-memory
-```
-
-### Query Vector Database
-
-```bash
-# Basic similarity search
-npx monomind memory query ./vectors.db "[0.1,0.2,0.3,...]"
-
-# Top-k results
-npx monomind memory query ./vectors.db "[0.1,0.2,0.3]" -k 10
-
-# With similarity threshold (cosine similarity)
-npx monomind memory query ./vectors.db "0.1 0.2 0.3" -t 0.75 -m cosine
-
-# Different distance metrics
-npx monomind memory query ./vectors.db "[...]" -m euclidean  # L2 distance
-npx monomind memory query ./vectors.db "[...]" -m dot        # Dot product
-
-# JSON output for automation
-npx monomind memory query ./vectors.db "[...]" -f json -k 5
-
-# Verbose output with distances
-npx monomind memory query ./vectors.db "[...]" -v
-```
-
-### Import/Export Vectors
-
-```bash
-# Export vectors to JSON
-npx monomind memory export ./vectors.db ./backup.json
-
-# Import vectors from JSON
-npx monomind memory import ./backup.json
-
-# Get database statistics
-npx monomind memory stats ./vectors.db
-```
-
-## Quick Start with API
-
-```typescript
-import { createAgentDBAdapter, computeEmbedding } from '@monomind/memory';
-
-// Initialize with vector search optimizations
-const adapter = await createAgentDBAdapter({
-  dbPath: '.agentdb/vectors.db',
-  enableLearning: false,       // Vector search only
-  enableReasoning: true,       // Enable semantic matching
-  quantizationType: 'binary',  // 32x memory reduction
-  cacheSize: 1000,             // Fast retrieval
-});
-
-// Store document with embedding
-const text = "The quantum computer achieved 100 qubits";
-const embedding = await computeEmbedding(text);
-
-await adapter.insertPattern({
-  id: '',
-  type: 'document',
-  domain: 'technology',
-  pattern_data: JSON.stringify({
-    embedding,
-    text,
-    metadata: { category: "quantum", date: "2025-01-15" }
-  }),
-  confidence: 1.0,
-  usage_count: 0,
-  success_count: 0,
-  created_at: Date.now(),
-  last_used: Date.now(),
-});
-
-// Semantic search with MMR (Maximal Marginal Relevance)
-const queryEmbedding = await computeEmbedding("quantum computing advances");
-const results = await adapter.retrieveWithReasoning(queryEmbedding, {
-  domain: 'technology',
-  k: 10,
-  useMMR: true,              // Diverse results
-  synthesizeContext: true,    // Rich context
-});
-```
-
-## Core Features
-
-### 1. Vector Storage
-```typescript
-// Store with automatic embedding
-await db.storeWithEmbedding({
-  content: "Your document text",
-  metadata: { source: "docs", page: 42 }
-});
-```
-
-### 2. Similarity Search
-```typescript
-// Find similar documents
-const similar = await db.findSimilar("quantum computing", {
-  limit: 5,
-  minScore: 0.75
-});
-```
-
-### 3. Hybrid Search (Vector + Metadata)
-```typescript
-// Combine vector similarity with metadata filtering
-const results = await db.hybridSearch({
-  query: "machine learning models",
-  filters: {
-    category: "research",
-    date: { $gte: "2024-01-01" }
-  },
-  limit: 20
-});
-```
-
-## Advanced Usage
-
-### RAG (Retrieval Augmented Generation)
-```typescript
-// Build RAG pipeline
-async function ragQuery(question: string) {
-  // 1. Get relevant context
-  const context = await db.searchSimilar(
-    await embed(question),
-    { limit: 5, threshold: 0.7 }
-  );
-
-  // 2. Generate answer with context
-  const prompt = `Context: ${context.map(c => c.text).join('\n')}
-Question: ${question}`;
-
-  return await llm.generate(prompt);
-}
-```
-
-### Batch Operations
-```typescript
-// Efficient batch storage
-await db.batchStore(documents.map(doc => ({
-  text: doc.content,
-  embedding: doc.vector,
-  metadata: doc.meta
-})));
-```
-
-## MCP Server Integration
-
-```bash
-# Start Monomind MCP server for Claude Code
-npx monomind mcp start
-
-# Add to Claude Code (one-time setup)
-claude mcp add monomind npx monomind@latest mcp start
-
-# Now use MCP tools in Claude Code:
-# - agentdb_query: Semantic vector search
-# - agentdb_store: Store documents with embeddings
-# - agentdb_stats: Database statistics
-```
-
-## Performance Benchmarks
-
-```bash
-# Run comprehensive benchmarks
-npx monomind memory benchmark
-
-# Results:
-# Pattern Search: 150x faster (100µs vs 15ms)
-# Batch Insert: 500x faster (2ms vs 1s for 100 vectors)
-# Large-scale Query: 12,500x faster (8ms vs 100s at 1M vectors)
-# Memory Efficiency: 4-32x reduction with quantization
-```
-
-## Quantization Options
-
-AgentDB provides multiple quantization strategies for memory efficiency:
-
-### Binary Quantization (32x reduction)
-```typescript
-const adapter = await createAgentDBAdapter({
-  quantizationType: 'binary',  // 768-dim → 96 bytes
-});
-```
-
-### Scalar Quantization (4x reduction)
-```typescript
-const adapter = await createAgentDBAdapter({
-  quantizationType: 'scalar',  // 768-dim → 768 bytes
-});
-```
-
-### Product Quantization (8-16x reduction)
-```typescript
-const adapter = await createAgentDBAdapter({
-  quantizationType: 'product',  // 768-dim → 48-96 bytes
-});
-```
-
-## Distance Metrics
-
-```bash
-# Cosine similarity (default, best for most use cases)
-npx monomind memory query ./db.sqlite "[...]" -m cosine
-
-# Euclidean distance (L2 norm)
-npx monomind memory query ./db.sqlite "[...]" -m euclidean
-
-# Dot product (for normalized vectors)
-npx monomind memory query ./db.sqlite "[...]" -m dot
-```
-
-## Advanced Features
-
-### HNSW Indexing
-- **O(log n) search complexity**
-- **Sub-millisecond retrieval** (<100µs)
-- **Automatic index building**
-
-### Caching
-- **1000 pattern in-memory cache**
-- **<1ms pattern retrieval**
-- **Automatic cache invalidation**
-
-### MMR (Maximal Marginal Relevance)
-- **Diverse result sets**
-- **Avoid redundancy**
-- **Balance relevance and diversity**
-
-## Performance Tips
-
-1. **Enable HNSW indexing**: Automatic with AgentDB, 10-100x faster
-2. **Use quantization**: Binary (32x), Scalar (4x), Product (8-16x) memory reduction
-3. **Batch operations**: 500x faster for bulk inserts
-4. **Match dimensions**: 1536 (OpenAI), 768 (sentence-transformers), 384 (MiniLM)
-5. **Similarity threshold**: Start at 0.7 for quality, adjust based on use case
-6. **Enable caching**: 1000 pattern cache for frequent queries
-
-## Troubleshooting
-
-### Issue: Slow search performance
-```bash
-# Check if HNSW indexing is enabled (automatic)
-npx monomind memory stats ./vectors.db
-
-# Expected: <100µs search time
-```
-
-### Issue: High memory usage
-```bash
-# Enable binary quantization (32x reduction)
-# Use in adapter: quantizationType: 'binary'
-```
-
-### Issue: Poor relevance
-```bash
-# Adjust similarity threshold
-npx monomind memory query ./db.sqlite "[...]" -t 0.8  # Higher threshold
-
-# Or use MMR for diverse results
-# Use in adapter: useMMR: true
-```
-
-### Issue: Wrong dimensions
-```bash
-# Check embedding model dimensions:
-# - OpenAI ada-002: 1536
-# - sentence-transformers: 768
-# - all-MiniLM-L6-v2: 384
-
-npx monomind memory init ./db.sqlite --dimension 768
-```
-
-## Database Statistics
-
-```bash
-# Get comprehensive stats
-npx monomind memory stats ./vectors.db
-
-# Shows:
-# - Total patterns/vectors
-# - Database size
-# - Average confidence
-# - Domains distribution
-# - Index status
-```
-
-## Performance Characteristics
-
-- **Vector Search**: <100µs (HNSW indexing)
-- **Pattern Retrieval**: <1ms (with cache)
-- **Batch Insert**: 2ms for 100 vectors
-- **Memory Efficiency**: 4-32x reduction with quantization
-- **Scalability**: Handles 1M+ vectors efficiently
-- **Latency**: Sub-millisecond for most operations
-
-## Learn More
-
-- GitHub: https://github.com/nokhodian/monomind
-- MCP Integration: `npx monomind mcp start`

package/.claude/skills/agentic-integration/SKILL.md

@@ -1,265 +0,0 @@
----
-name: agentic-integration
-description: "Code deduplication architecture implementing ADR-001. Eliminates 10,000+ duplicate lines by consolidating overlapping coordination systems using SONA, Flash Attention, and AgentDB."
-triggers:
-  - reduce code duplication
-  - SONA integration
-  - Flash Attention integration
-  - ADR-001
-  - eliminate duplicate lines
-  - consolidate coordination systems
----
-
-# Agentic Integration
-
-## What This Skill Does
-
-This skill is a reference guide for the code deduplication architecture defined in ADR-001. Monomind consolidates overlapping coordination systems, eliminating massive code duplication while achieving performance improvements and feature parity.
-
-## Quick Start
-
-```bash
-# Initialize deep integration
-Task("Integration architecture", "Design adapter layer for deduplication ADR-001", "v1-integration-architect")
-
-# Feature integration (parallel)
-Task("SONA integration", "Integrate 5 SONA learning modes", "v1-integration-architect")
-Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v1-integration-architect")
-Task("AgentDB coordination", "Setup 150x-12,500x search", "v1-integration-architect")
-```
-
-## Code Deduplication Strategy
-
-### Current Overlap → Integration
-
-```
-┌─────────────────────────────────────────┐
-│  monomind          agentic-flow      │
-├─────────────────────────────────────────┤
-│ SwarmCoordinator  →   Swarm System      │ 80% overlap (eliminate)
-│ AgentManager      →   Agent Lifecycle   │ 70% overlap (eliminate)
-│ TaskScheduler     →   Task Execution    │ 60% overlap (eliminate)
-│ SessionManager    →   Session Mgmt      │ 50% overlap (eliminate)
-└─────────────────────────────────────────┘
-
-TARGET: <5,000 lines (vs 15,000+ currently)
-```
-
-## Feature Integration
-
-### SONA Learning Modes
-
-```typescript
-class SONAIntegration {
-  async initializeMode(mode: SONAMode): Promise<void> {
-    switch (mode) {
-      case "real-time": // ~0.05ms adaptation
-      case "balanced": // general purpose
-      case "research": // deep exploration
-      case "edge": // resource-constrained
-      case "batch": // high-throughput
-    }
-    await this.agenticFlow.sona.setMode(mode);
-  }
-}
-```
-
-### Flash Attention Integration
-
-```typescript
-class FlashAttentionIntegration {
-  async optimizeAttention(): Promise<AttentionResult> {
-    return this.agenticFlow.attention.flashAttention({
-      speedupTarget: "2.49x-7.47x",
-      memoryReduction: "50-75%",
-      mechanisms: ["multi-head", "linear", "local", "global"],
-    });
-  }
-}
-```
-
-### AgentDB Coordination
-
-```typescript
-class AgentDBIntegration {
-  async setupCrossAgentMemory(): Promise<void> {
-    await this.agentdb.enableCrossAgentSharing({
-      indexType: "HNSW",
-      speedupTarget: "150x-12500x",
-      dimensions: 1536,
-    });
-  }
-}
-```
-
-### MCP Tools Integration
-
-```typescript
-class MCPToolsIntegration {
-  async integrateBuiltinTools(): Promise<void> {
-    // Leverage 213 pre-built tools
-    const tools = await this.agenticFlow.mcp.getAvailableTools();
-    await this.registerMonomindSpecificTools(tools);
-
-    // Use 19 hook types
-    const hookTypes = await this.agenticFlow.hooks.getTypes();
-    await this.configureMonomindHooks(hookTypes);
-  }
-}
-```
-
-## Migration Implementation
-
-### Phase 1: Adapter Layer
-
-```typescript
-import { Agent as AgenticFlowAgent } from "agentic-flow@alpha";
-
-export class MonomindAgent extends AgenticFlowAgent {
-  async handleMonomindTask(task: ClaudeTask): Promise<TaskResult> {
-    return this.executeWithSONA(task);
-  }
-
-  // Backward compatibility
-  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
-    return this.adaptToNewAPI(oldAPI);
-  }
-}
-```
-
-### Phase 2: System Migration
-
-```typescript
-class SystemMigration {
-  async migrateSwarmCoordination(): Promise<void> {
-    // Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
-    const swarmConfig = await this.extractSwarmConfig();
-    await this.agenticFlow.swarm.initialize(swarmConfig);
-  }
-
-  async migrateAgentManagement(): Promise<void> {
-    // Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
-    const agents = await this.extractActiveAgents();
-    for (const agent of agents) {
-      await this.agenticFlow.agent.create(agent);
-    }
-  }
-
-  async migrateTaskExecution(): Promise<void> {
-    // Replace TaskScheduler with agentic-flow task graph
-    const tasks = await this.extractTasks();
-    await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
-  }
-}
-```
-
-### Phase 3: Cleanup
-
-```typescript
-class CodeCleanup {
-  async removeDeprecatedCode(): Promise<void> {
-    // Remove massive duplicate implementations
-    await this.removeFile("src/core/SwarmCoordinator.ts"); // 800+ lines
-    await this.removeFile("src/agents/AgentManager.ts"); // 1,736+ lines
-    await this.removeFile("src/task/TaskScheduler.ts"); // 500+ lines
-
-    // Total reduction: 10,000+ → <5,000 lines
-  }
-}
-```
-
-## RL Algorithm Integration
-
-```typescript
-class RLIntegration {
-  algorithms = [
-    "PPO",
-    "DQN",
-    "A2C",
-    "MCTS",
-    "Q-Learning",
-    "SARSA",
-    "Actor-Critic",
-    "Decision-Transformer",
-  ];
-
-  async optimizeAgentBehavior(): Promise<void> {
-    for (const algorithm of this.algorithms) {
-      await this.agenticFlow.rl.train(algorithm, {
-        episodes: 1000,
-        rewardFunction: this.monomindRewardFunction,
-      });
-    }
-  }
-}
-```
-
-## Performance Integration
-
-### Flash Attention Targets
-
-```typescript
-const attentionBenchmark = {
-  baseline: "current attention mechanism",
-  target: "2.49x-7.47x improvement",
-  memoryReduction: "50-75%",
-  implementation: "monomind Flash Attention",
-};
-```
-
-### AgentDB Search Performance
-
-```typescript
-const searchBenchmark = {
-  baseline: "linear search in current systems",
-  target: "150x-12,500x via HNSW indexing",
-  implementation: "monomind AgentDB (@monomind/memory)",
-};
-```
-
-## Backward Compatibility
-
-### Gradual Migration
-
-```typescript
-class BackwardCompatibility {
-  // Phase 1: Dual operation
-  async enableDualOperation(): Promise<void> {
-    this.oldSystem.continue();
-    this.newSystem.initialize();
-    this.syncState(this.oldSystem, this.newSystem);
-  }
-
-  // Phase 2: Feature-by-feature migration
-  async migrateGradually(): Promise<void> {
-    const features = this.getAllFeatures();
-    for (const feature of features) {
-      await this.migrateFeature(feature);
-      await this.validateFeatureParity(feature);
-    }
-  }
-
-  // Phase 3: Complete transition
-  async completeTransition(): Promise<void> {
-    await this.validateFullParity();
-    await this.deprecateOldSystem();
-  }
-}
-```
-
-## Success Metrics
-
-- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
-- **Performance**: 2.49x-7.47x Flash Attention speedup
-- **Search**: 150x-12,500x AgentDB improvement
-- **Memory**: 50-75% usage reduction
-- **Feature Parity**: 100% v2 functionality maintained
-- **SONA**: <0.05ms adaptation time
-- **Integration**: All 213 MCP tools + 19 hook types available
-
-## Related Skills
-
-- `memory-unification` - Memory system integration
-- `performance-optimization` - Performance target validation
-- `swarm-coordination` - Swarm system migration
-- `security-hardening` - Secure integration patterns