claude-flow 3.7.0-alpha.46 → 3.7.0-alpha.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.46",
+  "version": "3.7.0-alpha.47",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/mcp-tools/embeddings-tools.js

@@ -940,5 +940,94 @@ export const embeddingsTools = [
             };
         },
     },
+    // ============================================================
+    // ADR-121 Phase 5b — DiskannSnapshot MCP tools (alpha.47 CLI)
+    // ============================================================
+    //
+    // Process-level registry of named DiskannSnapshot handles. Build
+    // an index once, search it many times. Persistence to disk via
+    // the snapshot's storagePath; the handle is keyed by `name`.
+    // For in-memory snapshots, set persist: false and the index is
+    // re-built only while this process lives.
+    {
+        name: 'embeddings_diskann_build',
+        description: 'Build a DiskANN/Vamana ANN index from a batch of (id, vector) pairs. Use when you have a fixed corpus (≥10k vectors typical) that needs sub-millisecond ANN search and you want persistence across process restarts — for streaming inserts at smaller scale use SearchableEmbeddingCache instead, for batch in-memory 32×-compressed use RabitqSnapshot. Pair with embeddings_diskann_search to query, embeddings_diskann_status to inspect. Requires @ruvector/diskann (optional peer dep — throws a clear named error if missing).',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Snapshot handle name (used by search + status). Must be unique per process.' },
+                dimension: { type: 'number', description: 'Embedding dimension.' },
+                entries: {
+                    type: 'array',
+                    description: 'Vectors to index. Each entry: { id: string, vector: number[] }.',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            id: { type: 'string' },
+                            vector: { type: 'array', items: { type: 'number' } },
+                        },
+                        required: ['id', 'vector'],
+                    },
+                },
+                storagePath: { type: 'string', description: 'Optional directory for on-disk persistence (snapshot survives restarts via embeddings_diskann_load).' },
+            },
+            required: ['name', 'dimension', 'entries'],
+        },
+        handler: async (input) => {
+            const { getDiskannRegistry } = await import('../memory/diskann-registry.js');
+            const registry = getDiskannRegistry();
+            const name = input.name;
+            const dimension = input.dimension;
+            const entries = input.entries;
+            const storagePath = input.storagePath;
+            try {
+                const stats = await registry.build({ name, dimension, entries, storagePath });
+                return { success: true, name, ...stats };
+            }
+            catch (err) {
+                return { success: false, name, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    },
+    {
+        name: 'embeddings_diskann_search',
+        description: 'Search a previously-built DiskANN index for the k nearest neighbors of a query vector. Use when you built an index via embeddings_diskann_build and now need ANN retrieval — returns ids + L2² distances sorted ascending. For text→vector→search in one call, pair with embeddings_generate first. For exact-match key lookup over a streaming cache, use SearchableEmbeddingCache.get instead.',
+        category: 'embeddings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Snapshot handle name (set by embeddings_diskann_build).' },
+                vector: { type: 'array', items: { type: 'number' }, description: 'Query vector. Must match the index dimension.' },
+                k: { type: 'number', description: 'Number of nearest neighbors to return.' },
+            },
+            required: ['name', 'vector', 'k'],
+        },
+        handler: async (input) => {
+            const { getDiskannRegistry } = await import('../memory/diskann-registry.js');
+            const registry = getDiskannRegistry();
+            const name = input.name;
+            const vector = new Float32Array(input.vector);
+            const k = input.k;
+            try {
+                const hits = await registry.search(name, vector, k);
+                return { success: true, name, k, hits };
+            }
+            catch (err) {
+                return { success: false, name, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    },
+    {
+        name: 'embeddings_diskann_status',
+        description: 'List all DiskANN snapshots currently held by this MCP server, with their dimension, vector count, and storage path. Use when you want to inventory in-process indexes before opening a new one, or when debugging "which snapshot did I build?". For checking whether the @ruvector/diskann peer dep itself is installed, use embeddings_check_ruvector_sidecar (the family probe) instead.',
+        category: 'embeddings',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+            const { getDiskannRegistry } = await import('../memory/diskann-registry.js');
+            const registry = getDiskannRegistry();
+            return { success: true, snapshots: registry.list() };
+        },
+    },
 ];
 //# sourceMappingURL=embeddings-tools.js.map

package/v3/@claude-flow/cli/dist/src/memory/diskann-registry.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Process-level registry of named `DiskannSnapshot` handles backing
+ * the `embeddings_diskann_*` MCP tools.
+ *
+ * Lifecycle:
+ *   - `build({ name, dimension, entries, storagePath? })` →
+ *     creates a snapshot, adds the entries, builds the Vamana graph,
+ *     persists if storagePath is set, stashes the handle under `name`.
+ *   - `search(name, vector, k)` → top-k against the named snapshot.
+ *   - `list()` → inventory of all current snapshots (name, dimension,
+ *     count, storagePath?).
+ *
+ * The registry is process-level; agents that want cross-restart
+ * persistence should pass `storagePath` on build and reload from
+ * disk via a separate `embeddings_diskann_load` follow-up tool.
+ *
+ * ADR-121 Phase 5b — cli alpha.47.
+ */
+export interface DiskannBuildInput {
+    readonly name: string;
+    readonly dimension: number;
+    readonly entries: ReadonlyArray<{
+        id: string;
+        vector: number[];
+    }>;
+    readonly storagePath?: string;
+}
+export interface DiskannBuildResult {
+    readonly dimension: number;
+    readonly count: number;
+    readonly buildMs: number;
+    readonly storagePath?: string;
+}
+export interface DiskannSearchHit {
+    readonly id: string;
+    readonly distance: number;
+}
+export interface DiskannSnapshotInfo {
+    readonly name: string;
+    readonly dimension: number;
+    readonly count: number;
+    readonly storagePath?: string;
+}
+declare class DiskannRegistry {
+    private readonly entries;
+    private snapshotCtor;
+    private loadCtor;
+    build(input: DiskannBuildInput): Promise<DiskannBuildResult>;
+    search(name: string, vector: Float32Array, k: number): Promise<DiskannSearchHit[]>;
+    list(): DiskannSnapshotInfo[];
+    /** Test seam — clear the registry between tests. */
+    clear(): void;
+}
+export declare function getDiskannRegistry(): DiskannRegistry;
+export {};
+//# sourceMappingURL=diskann-registry.d.ts.map

package/v3/@claude-flow/cli/dist/src/memory/diskann-registry.js

@@ -0,0 +1,88 @@
+/**
+ * Process-level registry of named `DiskannSnapshot` handles backing
+ * the `embeddings_diskann_*` MCP tools.
+ *
+ * Lifecycle:
+ *   - `build({ name, dimension, entries, storagePath? })` →
+ *     creates a snapshot, adds the entries, builds the Vamana graph,
+ *     persists if storagePath is set, stashes the handle under `name`.
+ *   - `search(name, vector, k)` → top-k against the named snapshot.
+ *   - `list()` → inventory of all current snapshots (name, dimension,
+ *     count, storagePath?).
+ *
+ * The registry is process-level; agents that want cross-restart
+ * persistence should pass `storagePath` on build and reload from
+ * disk via a separate `embeddings_diskann_load` follow-up tool.
+ *
+ * ADR-121 Phase 5b — cli alpha.47.
+ */
+class DiskannRegistry {
+    entries = new Map();
+    snapshotCtor = null;
+    async loadCtor() {
+        if (this.snapshotCtor)
+            return this.snapshotCtor;
+        // Same wildcard sub-path import the sidecar tool uses (Phase 5 full).
+        const mod = await import('@claude-flow/embeddings/diskann-snapshot');
+        this.snapshotCtor = mod.DiskannSnapshot;
+        return this.snapshotCtor;
+    }
+    async build(input) {
+        const ctor = await this.loadCtor();
+        const t0 = Date.now();
+        const snap = await ctor.create({
+            dimension: input.dimension,
+            storagePath: input.storagePath,
+        });
+        // Convert plain-number arrays from the MCP input into Float32Array.
+        const float32Entries = input.entries.map(e => ({
+            id: e.id,
+            vector: new Float32Array(e.vector),
+        }));
+        snap.add(float32Entries);
+        await snap.build();
+        const buildMs = Date.now() - t0;
+        // Replace any existing snapshot under this name.
+        this.entries.set(input.name, {
+            snapshot: snap,
+            dimension: input.dimension,
+            storagePath: input.storagePath,
+        });
+        return {
+            dimension: input.dimension,
+            count: snap.count(),
+            buildMs,
+            storagePath: input.storagePath,
+        };
+    }
+    async search(name, vector, k) {
+        const entry = this.entries.get(name);
+        if (!entry) {
+            throw new Error(`embeddings_diskann_search: no snapshot named "${name}" — call embeddings_diskann_build first`);
+        }
+        return entry.snapshot.search(vector, k);
+    }
+    list() {
+        const out = [];
+        for (const [name, entry] of this.entries) {
+            out.push({
+                name,
+                dimension: entry.dimension,
+                count: entry.snapshot.count(),
+                storagePath: entry.storagePath,
+            });
+        }
+        return out;
+    }
+    /** Test seam — clear the registry between tests. */
+    clear() {
+        this.entries.clear();
+    }
+}
+let singleton = null;
+export function getDiskannRegistry() {
+    if (!singleton)
+        singleton = new DiskannRegistry();
+    return singleton;
+}
+//# sourceMappingURL=diskann-registry.js.map

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.46",
+  "version": "3.7.0-alpha.47",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",