agentic-flow 3.4.4 → 3.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agentic-flow",
-  "version": "3.4.4",
-  "description": "The agentic meta-harness — freeze the model, evolve the harness. An open runtime that routes each query to the cost-optimal model, evolves its own harness (planner/context/reviewer/retry/tool/memory/score policy) and autonomously repairs code, then orchestrates 66 specialized agents, 213 MCP tools, ReasoningBank memory, and multi-agent swarms on top. Built by @ruvnet on the Claude Agent SDK.",
+  "version": "3.5.1",
+  "description": "AI agents runtime and meta-harness: routes each query to a cost-optimal model (LLM routing), evolves its own harness and orchestrates coding agents over MCP.",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -71,78 +71,27 @@
     "benchmark:embeddings": "tsx src/benchmarks/embeddings-benchmark.ts",
     "test:orchestration": "vitest run tests/orchestration/ --reporter=verbose",
     "test:security": "vitest run tests/security tests/mcp/mcp-policy.test.ts tests/transport/quic-loader.test.ts",
-    "test:governance": "vitest run tests/harness/provenance.test.ts tests/harness/flywheel-governance.test.ts tests/mcp/mcp-policy.test.ts tests/mcp/package-surface.test.ts tests/mcp/zod4-migration.test.ts tests/embeddings/huggingface-offline.test.ts tests/repair/darwin-repair.test.ts tests/integrations",
+    "test:governance": "vitest run tests/harness/provenance.test.ts tests/harness/flywheel-governance.test.ts tests/mcp/mcp-policy.test.ts tests/mcp/package-surface.test.ts tests/mcp/zod4-migration.test.ts tests/mcp/server-version.test.ts tests/embeddings/huggingface-offline.test.ts tests/repair/darwin-repair.test.ts tests/integrations",
     "test:orchestration:smoke": "tsx tests/orchestration/orchestration-api.smoke.ts && tsx tests/orchestration/loop-policy.smoke.ts && tsx tests/orchestration/memory-plane.smoke.ts",
     "test:integrations": "vitest run tests/integrations"
   },
   "keywords": [
-    "meta-harness",
+    "ai-agents",
+    "llm-routing",
+    "agent-orchestration",
+    "coding-agent",
+    "self-learning",
+    "mcp",
+    "agentic-flow",
     "metaharness",
     "agent-harness",
-    "harness-evolution",
-    "model-routing",
-    "cost-optimal-routing",
-    "self-improving",
-    "darwin",
     "ai",
-    "ai-agents",
-    "ai-orchestration",
-    "agentic",
-    "agents",
-    "agent-swarm",
+    "agentic-ai",
+    "swarm",
     "anthropic",
-    "anthropic-claude",
     "automation",
     "autonomous-agents",
-    "byzantine-consensus",
-    "claude",
-    "claude-agent-sdk",
-    "claude-code",
-    "reasoning-memory",
-    "reasoningbank",
-    "agent-learning",
-    "memory-system",
-    "consensus-protocols",
-    "coordination",
-    "crdt",
-    "devops",
-    "distributed-systems",
-    "docker",
-    "fastmcp",
-    "flow-nexus",
-    "github",
-    "github-integration",
-    "goal-planning",
-    "goap",
-    "hive-mind",
-    "huggingface",
-    "llm",
-    "llm-orchestration",
-    "machine-learning",
-    "mcp",
-    "mcp-server",
-    "mcp-tools",
-    "memory-persistence",
-    "mesh-network",
-    "multi-agent",
-    "multi-agent-systems",
-    "neural-networks",
-    "onnx",
-    "onnxruntime",
-    "orchestration",
-    "pagerank",
-    "parallel-processing",
-    "raft",
-    "ruv",
-    "ruvnet",
-    "sparc",
-    "sublinear-algorithms",
-    "swarm",
-    "swarm-intelligence",
-    "task-orchestration",
-    "typescript",
-    "workflow",
-    "workflow-automation"
+    "claude"
   ],
   "author": {
     "name": "ruv",
@@ -156,13 +105,14 @@
   ],
   "license": "MIT",
   "repository": {
+    "directory": "agentic-flow",
     "type": "git",
-    "url": "https://github.com/ruvnet/agentic-flow.git"
+    "url": "git+https://github.com/ruvnet/agentic-flow.git"
   },
   "bugs": {
     "url": "https://github.com/ruvnet/agentic-flow/issues"
   },
-  "homepage": "https://github.com/ruvnet/agentic-flow#readme",
+  "homepage": "https://ruv.io",
   "engines": {
     "node": ">=20.0.0"
   },
@@ -196,6 +146,7 @@
     "@rollup/rollup-darwin-arm64": "^4.59.0",
     "@ruvector/attention": "^2.3.0",
     "@ruvector/mincut-wasm": "^2.3.0",
+    "@ruvector/rudag": "^0.1.2",
     "@ruvector/sona": "^0.1.11",
     "@ruvnet/sublinear-core": "^1.0.1",
     "agent-booster": "^0.2.2",

package/dist/core/agentdb-wrapper.d.ts

@@ -1,149 +0,0 @@
-/**
- * AgentDBWrapper - Clean API over raw AgentDB v2.0.0-alpha.2.11
- *
- * Provides a unified interface for:
- * - Vector search with HNSW indexing
- * - Memory operations (insert, search, update, delete)
- * - TypeScript-first type safety
- * - Error handling and validation
- *
- * Note: AgentDB is optional - falls back gracefully on Windows
- *
- * @module agentdb-wrapper
- */
-import type { AgentDBConfig, VectorEntry, VectorSearchOptions, VectorSearchResult, MemoryInsertOptions, MemoryUpdateOptions, MemoryDeleteOptions, MemoryGetOptions, AgentDBStats, BatchInsertResult } from '../types/agentdb.js';
-/**
- * Main wrapper class for AgentDB operations
- *
- * @example
- * ```typescript
- * const wrapper = new AgentDBWrapper({
- *   dbPath: ':memory:',
- *   dimension: 384,
- *   hnswConfig: { M: 16, efConstruction: 200 }
- * });
- *
- * await wrapper.initialize();
- *
- * // Insert a vector
- * const vector = new Float32Array(384);
- * await wrapper.insert({ vector, metadata: { type: 'test' } });
- *
- * // Search
- * const results = await wrapper.vectorSearch(queryVector, { k: 10 });
- *
- * await wrapper.close();
- * ```
- */
-export declare class AgentDBWrapper {
-    private agentDB;
-    private config;
-    private initialized;
-    private dimension;
-    private namespace;
-    private reflexionController;
-    private embedder;
-    private vectorBackend;
-    _agentDB?: any;
-    _embedder?: any;
-    _vectorBackend?: any;
-    /**
-     * Create a new AgentDBWrapper instance
-     *
-     * @param config - Configuration options
-     */
-    constructor(config?: AgentDBConfig);
-    /**
-     * Initialize the AgentDB instance and dependencies
-     *
-     * @throws {DatabaseError} If initialization fails
-     */
-    initialize(): Promise<void>;
-    /**
-     * Ensure wrapper is initialized before operations
-     *
-     * @throws {Error} If not initialized
-     */
-    private ensureInitialized;
-    /**
-     * Validate vector dimension
-     *
-     * @param vector - Vector to validate
-     * @throws {ValidationError} If dimension is invalid
-     */
-    private validateVectorDimension;
-    /**
-     * Generate a unique ID
-     *
-     * @returns A unique identifier
-     */
-    private generateId;
-    /**
-     * Insert a vector with metadata into the database
-     *
-     * @param options - Insert options
-     * @returns The inserted entry with ID
-     * @throws {ValidationError} If vector dimension is invalid
-     * @throws {DatabaseError} If insertion fails
-     */
-    insert(options: MemoryInsertOptions): Promise<{
-        id: string;
-        timestamp: number;
-    }>;
-    /**
-     * Search for similar vectors using HNSW indexing
-     *
-     * @param query - Query vector
-     * @param options - Search options
-     * @returns Array of search results sorted by similarity (descending)
-     * @throws {ValidationError} If query dimension is invalid
-     */
-    vectorSearch(query: Float32Array, options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
-    /**
-     * Update a vector and/or its metadata
-     *
-     * @param options - Update options
-     * @returns True if update succeeded
-     * @throws {ValidationError} If vector dimension is invalid
-     * @throws {DatabaseError} If vector not found
-     */
-    update(options: MemoryUpdateOptions): Promise<boolean>;
-    /**
-     * Delete a vector by ID
-     *
-     * @param options - Delete options
-     * @returns True if deletion succeeded, false if not found
-     */
-    delete(options: MemoryDeleteOptions): Promise<boolean>;
-    /**
-     * Get a vector by ID
-     *
-     * @param options - Get options
-     * @returns Vector entry or null if not found
-     */
-    get(options: MemoryGetOptions): Promise<VectorEntry | null>;
-    /**
-     * Insert multiple vectors in a batch
-     *
-     * @param entries - Array of entries to insert
-     * @returns Batch insert result with success/failure counts
-     */
-    batchInsert(entries: MemoryInsertOptions[]): Promise<BatchInsertResult>;
-    /**
-     * Get database statistics
-     *
-     * @returns Database statistics including vector count and index info
-     */
-    getStats(): Promise<AgentDBStats>;
-    /**
-     * Close the database connection
-     */
-    close(): Promise<void>;
-    /**
-     * Get the underlying AgentDB instance (for advanced usage)
-     *
-     * @returns The raw AgentDB instance
-     */
-    getRawInstance(): any;
-}
-//# sourceMappingURL=agentdb-wrapper.d.ts.map

package/dist/core/agentdb-wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agentdb-wrapper.d.ts","sourceRoot":"","sources":["../../src/core/agentdb-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAaH,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EAKlB,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAO;IACtB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,mBAAmB,CAAM;IACjC,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,aAAa,CAAM;IAGpB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,cAAc,CAAC,EAAE,GAAG,CAAC;IAE5B;;;;OAIG;gBACS,MAAM,GAAE,aAAkB;IA0BtC;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA6CjC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAQzB;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAIlB;;;;;;;OAOG;IACG,MAAM,CACV,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAgC7C;;;;;;;OAOG;IACG,YAAY,CAChB,KAAK,EAAE,YAAY,EACnB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAsChC;;;;;;;OAOG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAkC5D;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB5D;;;;;OAKG;IACG,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAiCjE;;;;;OAKG;IACG,WAAW,CACf,OAAO,EAAE,mBAAmB,EAAE,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAiC7B;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAuBvC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;;;OAIG;IACH,cAAc,IAAI,GAAG;CAItB"}

package/dist/core/agentdb-wrapper.js

@@ -1,394 +0,0 @@
-/**
- * AgentDBWrapper - Clean API over raw AgentDB v2.0.0-alpha.2.11
- *
- * Provides a unified interface for:
- * - Vector search with HNSW indexing
- * - Memory operations (insert, search, update, delete)
- * - TypeScript-first type safety
- * - Error handling and validation
- *
- * Note: AgentDB is optional - falls back gracefully on Windows
- *
- * @module agentdb-wrapper
- */
-let AgentDB = null;
-let agentdbAvailable = false;
-try {
-    const mod = await import('agentdb');
-    AgentDB = mod.AgentDB;
-    agentdbAvailable = true;
-}
-catch {
-    console.warn('[AgentDB] Not available - some features disabled');
-}
-/**
- * Main wrapper class for AgentDB operations
- *
- * @example
- * ```typescript
- * const wrapper = new AgentDBWrapper({
- *   dbPath: ':memory:',
- *   dimension: 384,
- *   hnswConfig: { M: 16, efConstruction: 200 }
- * });
- *
- * await wrapper.initialize();
- *
- * // Insert a vector
- * const vector = new Float32Array(384);
- * await wrapper.insert({ vector, metadata: { type: 'test' } });
- *
- * // Search
- * const results = await wrapper.vectorSearch(queryVector, { k: 10 });
- *
- * await wrapper.close();
- * ```
- */
-export class AgentDBWrapper {
-    agentDB;
-    config;
-    initialized = false;
-    dimension;
-    namespace;
-    reflexionController;
-    embedder;
-    vectorBackend;
-    // For testing - allow dependency injection
-    _agentDB;
-    _embedder;
-    _vectorBackend;
-    /**
-     * Create a new AgentDBWrapper instance
-     *
-     * @param config - Configuration options
-     */
-    constructor(config = {}) {
-        this.config = {
-            dbPath: config.dbPath || ':memory:',
-            namespace: config.namespace || 'default',
-            dimension: config.dimension || 384,
-            hnswConfig: {
-                M: config.hnswConfig?.M || 16,
-                efConstruction: config.hnswConfig?.efConstruction || 200,
-                efSearch: config.hnswConfig?.efSearch || 100,
-            },
-            enableAttention: config.enableAttention || false,
-            attentionConfig: config.attentionConfig,
-            autoInit: config.autoInit !== false, // Default true
-        };
-        this.dimension = this.config.dimension;
-        this.namespace = this.config.namespace;
-        // Auto-initialize if configured
-        if (this.config.autoInit) {
-            this.initialize().catch((err) => {
-                console.error('Auto-initialization failed:', err);
-            });
-        }
-    }
-    /**
-     * Initialize the AgentDB instance and dependencies
-     *
-     * @throws {DatabaseError} If initialization fails
-     */
-    async initialize() {
-        if (this.initialized) {
-            return;
-        }
-        if (!agentdbAvailable || !AgentDB) {
-            throw new Error('AgentDB not available - install with: npm install agentdb (requires native build tools)');
-        }
-        try {
-            // Use injected dependencies for testing, otherwise create real instances
-            if (this._agentDB) {
-                this.agentDB = this._agentDB;
-                this.embedder = this._embedder;
-                this.vectorBackend = this._vectorBackend;
-            }
-            else {
-                // Create real AgentDB instance
-                this.agentDB = new AgentDB({
-                    dbPath: this.config.dbPath,
-                    namespace: this.namespace,
-                    enableAttention: this.config.enableAttention,
-                    attentionConfig: this.config.attentionConfig,
-                });
-                await this.agentDB.initialize();
-                // Get controllers
-                this.reflexionController = this.agentDB.getController('reflexion');
-                this.embedder = this.reflexionController?.embedder;
-                this.vectorBackend = this.reflexionController?.vectorBackend;
-            }
-            // Initialize embedder if available
-            if (this.embedder && this.embedder.initialize) {
-                await this.embedder.initialize();
-            }
-            this.initialized = true;
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize AgentDB: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Ensure wrapper is initialized before operations
-     *
-     * @throws {Error} If not initialized
-     */
-    ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error('AgentDBWrapper not initialized. Call initialize() first.');
-        }
-    }
-    /**
-     * Validate vector dimension
-     *
-     * @param vector - Vector to validate
-     * @throws {ValidationError} If dimension is invalid
-     */
-    validateVectorDimension(vector) {
-        if (vector.length !== this.dimension) {
-            throw new Error(`Invalid vector dimension: expected ${this.dimension}, got ${vector.length}`);
-        }
-    }
-    /**
-     * Generate a unique ID
-     *
-     * @returns A unique identifier
-     */
-    generateId() {
-        return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    }
-    /**
-     * Insert a vector with metadata into the database
-     *
-     * @param options - Insert options
-     * @returns The inserted entry with ID
-     * @throws {ValidationError} If vector dimension is invalid
-     * @throws {DatabaseError} If insertion fails
-     */
-    async insert(options) {
-        this.ensureInitialized();
-        this.validateVectorDimension(options.vector);
-        const id = options.id || this.generateId();
-        const timestamp = Date.now();
-        const metadata = {
-            ...options.metadata,
-            timestamp,
-            namespace: options.namespace || this.namespace,
-        };
-        try {
-            const controller = this._agentDB
-                ? this._agentDB.getController('reflexion')
-                : this.reflexionController;
-            await controller.store({
-                id,
-                vector: options.vector,
-                metadata,
-            });
-            return { id, timestamp };
-        }
-        catch (error) {
-            throw new Error(`Failed to insert vector: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Search for similar vectors using HNSW indexing
-     *
-     * @param query - Query vector
-     * @param options - Search options
-     * @returns Array of search results sorted by similarity (descending)
-     * @throws {ValidationError} If query dimension is invalid
-     */
-    async vectorSearch(query, options = {}) {
-        this.ensureInitialized();
-        this.validateVectorDimension(query);
-        const { k = 10, metric = 'cosine', filter, includeVectors = false, hnswParams, } = options;
-        try {
-            const controller = this._agentDB
-                ? this._agentDB.getController('reflexion')
-                : this.reflexionController;
-            const results = await controller.retrieve(query, {
-                k,
-                metric,
-                filter,
-                includeVectors,
-                hnswParams,
-            });
-            return results.map((result) => ({
-                id: result.id,
-                score: result.score,
-                metadata: result.metadata,
-                ...(includeVectors && { vector: result.vector }),
-            }));
-        }
-        catch (error) {
-            throw new Error(`Vector search failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Update a vector and/or its metadata
-     *
-     * @param options - Update options
-     * @returns True if update succeeded
-     * @throws {ValidationError} If vector dimension is invalid
-     * @throws {DatabaseError} If vector not found
-     */
-    async update(options) {
-        this.ensureInitialized();
-        if (options.vector) {
-            this.validateVectorDimension(options.vector);
-        }
-        try {
-            const controller = this._agentDB
-                ? this._agentDB.getController('reflexion')
-                : this.reflexionController;
-            const updateData = {};
-            if (options.vector) {
-                updateData.vector = options.vector;
-            }
-            if (options.metadata) {
-                updateData.metadata = options.metadata;
-            }
-            const result = await controller.update(options.id, updateData);
-            if (!result) {
-                throw new Error(`Vector not found: ${options.id}`);
-            }
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    /**
-     * Delete a vector by ID
-     *
-     * @param options - Delete options
-     * @returns True if deletion succeeded, false if not found
-     */
-    async delete(options) {
-        this.ensureInitialized();
-        try {
-            const controller = this._agentDB
-                ? this._agentDB.getController('reflexion')
-                : this.reflexionController;
-            const result = await controller.delete(options.id);
-            return result;
-        }
-        catch (error) {
-            throw new Error(`Delete failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get a vector by ID
-     *
-     * @param options - Get options
-     * @returns Vector entry or null if not found
-     */
-    async get(options) {
-        this.ensureInitialized();
-        try {
-            const controller = this._agentDB
-                ? this._agentDB.getController('reflexion')
-                : this.reflexionController;
-            const result = await controller.get(options.id);
-            if (!result) {
-                return null;
-            }
-            const entry = {
-                id: result.id,
-                vector: result.vector,
-                metadata: result.metadata,
-            };
-            // Exclude vector if not requested
-            if (options.includeVector === false) {
-                delete entry.vector;
-            }
-            return entry;
-        }
-        catch (error) {
-            throw new Error(`Get failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Insert multiple vectors in a batch
-     *
-     * @param entries - Array of entries to insert
-     * @returns Batch insert result with success/failure counts
-     */
-    async batchInsert(entries) {
-        this.ensureInitialized();
-        const startTime = Date.now();
-        const result = {
-            inserted: 0,
-            failed: [],
-            duration: 0,
-        };
-        const controller = this._agentDB
-            ? this._agentDB.getController('reflexion')
-            : this.reflexionController;
-        for (let i = 0; i < entries.length; i++) {
-            const entry = entries[i];
-            try {
-                await this.insert(entry);
-                result.inserted++;
-            }
-            catch (error) {
-                result.failed.push({
-                    index: i,
-                    id: entry.id,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        result.duration = Date.now() - startTime;
-        return result;
-    }
-    /**
-     * Get database statistics
-     *
-     * @returns Database statistics including vector count and index info
-     */
-    async getStats() {
-        this.ensureInitialized();
-        try {
-            const backend = this._vectorBackend || this.vectorBackend;
-            const stats = await backend.getStats();
-            return {
-                vectorCount: stats.vectorCount || 0,
-                dimension: this.dimension,
-                databaseSize: stats.databaseSize || 0,
-                hnswStats: stats.hnswStats,
-                memoryUsage: stats.memoryUsage,
-                indexBuildTime: stats.indexBuildTime,
-            };
-        }
-        catch (error) {
-            throw new Error(`Failed to get stats: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Close the database connection
-     */
-    async close() {
-        if (!this.initialized) {
-            return;
-        }
-        try {
-            const db = this._agentDB || this.agentDB;
-            await db.close();
-            this.initialized = false;
-        }
-        catch (error) {
-            throw new Error(`Failed to close database: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Get the underlying AgentDB instance (for advanced usage)
-     *
-     * @returns The raw AgentDB instance
-     */
-    getRawInstance() {
-        this.ensureInitialized();
-        return this.agentDB;
-    }
-}
-//# sourceMappingURL=agentdb-wrapper.js.map