@ruvector/ruvllm 0.2.0

package/dist/esm/native.js

@@ -0,0 +1,65 @@
+/**
+ * Native bindings loader for RuvLLM
+ *
+ * Automatically loads the correct native binary for the current platform.
+ */
+import { join } from 'path';
+// Try to load the native module
+let nativeModule = null;
+// Platform-specific package names
+const PLATFORM_PACKAGES = {
+    'darwin-x64': '@ruvector/ruvllm-darwin-x64',
+    'darwin-arm64': '@ruvector/ruvllm-darwin-arm64',
+    'linux-x64': '@ruvector/ruvllm-linux-x64-gnu',
+    'linux-arm64': '@ruvector/ruvllm-linux-arm64-gnu',
+    'win32-x64': '@ruvector/ruvllm-win32-x64-msvc',
+};
+function getPlatformKey() {
+    const platform = process.platform;
+    const arch = process.arch;
+    return `${platform}-${arch}`;
+}
+function loadNativeModule() {
+    if (nativeModule) {
+        return nativeModule;
+    }
+    const platformKey = getPlatformKey();
+    const packageName = PLATFORM_PACKAGES[platformKey];
+    if (!packageName) {
+        // Silently fail - JS fallback will be used
+        return null;
+    }
+    // Try loading from optional dependencies
+    const attempts = [
+        // Try the platform-specific package
+        () => require(packageName),
+        // Try loading from local .node file (CJS build)
+        () => require(join(__dirname, '..', '..', 'ruvllm.node')),
+        // Try loading from local .node file (root)
+        () => require(join(__dirname, '..', 'ruvllm.node')),
+    ];
+    for (const attempt of attempts) {
+        try {
+            nativeModule = attempt();
+            return nativeModule;
+        }
+        catch {
+            // Continue to next attempt
+        }
+    }
+    // Silently fall back to JS implementation
+    return null;
+}
+// Export functions to get native bindings
+export function getNativeModule() {
+    return loadNativeModule();
+}
+export function version() {
+    const mod = loadNativeModule();
+    return mod?.version() ?? '0.1.0-js';
+}
+export function hasSimdSupport() {
+    const mod = loadNativeModule();
+    return mod?.hasSimdSupport() ?? false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/session.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Session Management for multi-turn conversations
+ */
+import { ConversationSession, ConversationMessage, QueryResponse, GenerationConfig } from './types';
+/**
+ * Session Manager for multi-turn conversations
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM();
+ * const sessions = new SessionManager(llm);
+ *
+ * // Create a new session
+ * const session = sessions.create();
+ *
+ * // Chat with context
+ * const response1 = sessions.chat(session.id, 'What is Python?');
+ * const response2 = sessions.chat(session.id, 'How do I install it?');
+ * // Second query automatically has context from first
+ * ```
+ */
+export declare class SessionManager {
+    private sessions;
+    private llm;
+    constructor(llm: {
+        query: (text: string, config?: GenerationConfig) => QueryResponse;
+        addMemory: (content: string, metadata?: Record<string, unknown>) => number;
+    });
+    /**
+     * Create a new conversation session
+     */
+    create(metadata?: Record<string, unknown>): ConversationSession;
+    /**
+     * Get session by ID
+     */
+    get(sessionId: string): ConversationSession | undefined;
+    /**
+     * Chat within a session (maintains context)
+     */
+    chat(sessionId: string, message: string, config?: GenerationConfig): QueryResponse;
+    /**
+     * Add system message to session
+     */
+    addSystemMessage(sessionId: string, content: string): void;
+    /**
+     * Add context to session (persisted to memory)
+     */
+    addContext(sessionId: string, context: string): number;
+    /**
+     * Get conversation history
+     */
+    getHistory(sessionId: string, limit?: number): ConversationMessage[];
+    /**
+     * Clear session history (keep session active)
+     */
+    clearHistory(sessionId: string): void;
+    /**
+     * End and delete session
+     */
+    end(sessionId: string): boolean;
+    /**
+     * List all active sessions
+     */
+    list(): ConversationSession[];
+    /**
+     * Export session as JSON
+     */
+    export(sessionId: string): string | null;
+    /**
+     * Import session from JSON
+     */
+    import(json: string): ConversationSession;
+    /**
+     * Build context string from recent messages
+     */
+    private buildContext;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/esm/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAA+C;IAC/D,OAAO,CAAC,GAAG,CAAoJ;gBAEnJ,GAAG,EAAE;QAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,KAAK,aAAa,CAAC;QAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAA;KAAE;IAIlK;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,mBAAmB;IAe/D;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIvD;;OAEG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,gBAAgB,GAAG,aAAa;IAiClF;;OAEG;IACH,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAc1D;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAmBtD;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,mBAAmB,EAAE;IAUpE;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IASrC;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B;;OAEG;IACH,IAAI,IAAI,mBAAmB,EAAE;IAI7B;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASxC;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB;IAezC;;OAEG;IACH,OAAO,CAAC,YAAY;CA2BrB"}

package/dist/esm/session.js

@@ -0,0 +1,199 @@
+/**
+ * Session Management for multi-turn conversations
+ */
+/**
+ * Session Manager for multi-turn conversations
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM();
+ * const sessions = new SessionManager(llm);
+ *
+ * // Create a new session
+ * const session = sessions.create();
+ *
+ * // Chat with context
+ * const response1 = sessions.chat(session.id, 'What is Python?');
+ * const response2 = sessions.chat(session.id, 'How do I install it?');
+ * // Second query automatically has context from first
+ * ```
+ */
+export class SessionManager {
+    constructor(llm) {
+        this.sessions = new Map();
+        this.llm = llm;
+    }
+    /**
+     * Create a new conversation session
+     */
+    create(metadata) {
+        const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const session = {
+            id,
+            createdAt: new Date(),
+            messageCount: 0,
+            messages: [],
+            context: [],
+            activeMemoryIds: [],
+            metadata: metadata ?? {},
+        };
+        this.sessions.set(id, session);
+        return session;
+    }
+    /**
+     * Get session by ID
+     */
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    /**
+     * Chat within a session (maintains context)
+     */
+    chat(sessionId, message, config) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        // Add user message
+        session.messages.push({
+            role: 'user',
+            content: message,
+            timestamp: new Date(),
+        });
+        // Build context from recent messages
+        const contextWindow = this.buildContext(session);
+        // Query with context
+        const prompt = contextWindow ? `${contextWindow}\n\nUser: ${message}` : message;
+        const response = this.llm.query(prompt, config);
+        // Add assistant response
+        session.messages.push({
+            role: 'assistant',
+            content: response.text,
+            timestamp: new Date(),
+            requestId: response.requestId,
+        });
+        session.messageCount = session.messages.length;
+        return response;
+    }
+    /**
+     * Add system message to session
+     */
+    addSystemMessage(sessionId, content) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.messages.push({
+            role: 'system',
+            content,
+            timestamp: new Date(),
+        });
+        session.messageCount = session.messages.length;
+    }
+    /**
+     * Add context to session (persisted to memory)
+     */
+    addContext(sessionId, context) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        session.context.push(context);
+        // Also store in memory for retrieval
+        const memoryId = this.llm.addMemory(context, {
+            sessionId,
+            type: 'context',
+            timestamp: new Date().toISOString(),
+        });
+        session.activeMemoryIds.push(memoryId);
+        return memoryId;
+    }
+    /**
+     * Get conversation history
+     */
+    getHistory(sessionId, limit) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return [];
+        }
+        const messages = session.messages;
+        return limit ? messages.slice(-limit) : messages;
+    }
+    /**
+     * Clear session history (keep session active)
+     */
+    clearHistory(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.messages = [];
+            session.context = [];
+            session.messageCount = 0;
+        }
+    }
+    /**
+     * End and delete session
+     */
+    end(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    /**
+     * List all active sessions
+     */
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    /**
+     * Export session as JSON
+     */
+    export(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return null;
+        }
+        return JSON.stringify(session, null, 2);
+    }
+    /**
+     * Import session from JSON
+     */
+    import(json) {
+        const data = JSON.parse(json);
+        const session = {
+            ...data,
+            createdAt: new Date(data.createdAt),
+            messages: data.messages.map((m) => ({
+                ...m,
+                timestamp: new Date(m.timestamp),
+            })),
+        };
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    /**
+     * Build context string from recent messages
+     */
+    buildContext(session, maxMessages = 10) {
+        const recent = session.messages.slice(-maxMessages);
+        if (recent.length === 0) {
+            return '';
+        }
+        const contextParts = [];
+        // Add persistent context
+        if (session.context.length > 0) {
+            contextParts.push('Context:\n' + session.context.join('\n'));
+        }
+        // Add conversation history
+        const history = recent
+            .map(m => {
+            const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';
+            return `${role}: ${m.content}`;
+        })
+            .join('\n');
+        if (history) {
+            contextParts.push('Conversation:\n' + history);
+        }
+        return contextParts.join('\n\n');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Session Management for multi-turn conversations\n */\n\nimport {\n  ConversationSession,\n  ConversationMessage,\n  QueryResponse,\n  GenerationConfig,\n} from './types';\n\n/**\n * Session Manager for multi-turn conversations\n *\n * @example\n * ```typescript\n * import { RuvLLM, SessionManager } from '@ruvector/ruvllm';\n *\n * const llm = new RuvLLM();\n * const sessions = new SessionManager(llm);\n *\n * // Create a new session\n * const session = sessions.create();\n *\n * // Chat with context\n * const response1 = sessions.chat(session.id, 'What is Python?');\n * const response2 = sessions.chat(session.id, 'How do I install it?');\n * // Second query automatically has context from first\n * ```\n */\nexport class SessionManager {\n  private sessions: Map<string, ConversationSession> = new Map();\n  private llm: { query: (text: string, config?: GenerationConfig) => QueryResponse; addMemory: (content: string, metadata?: Record<string, unknown>) => number };\n\n  constructor(llm: { query: (text: string, config?: GenerationConfig) => QueryResponse; addMemory: (content: string, metadata?: Record<string, unknown>) => number }) {\n    this.llm = llm;\n  }\n\n  /**\n   * Create a new conversation session\n   */\n  create(metadata?: Record<string, unknown>): ConversationSession {\n    const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n    const session: ConversationSession = {\n      id,\n      createdAt: new Date(),\n      messageCount: 0,\n      messages: [],\n      context: [],\n      activeMemoryIds: [],\n      metadata: metadata ?? {},\n    };\n    this.sessions.set(id, session);\n    return session;\n  }\n\n  /**\n   * Get session by ID\n   */\n  get(sessionId: string): ConversationSession | undefined {\n    return this.sessions.get(sessionId);\n  }\n\n  /**\n   * Chat within a session (maintains context)\n   */\n  chat(sessionId: string, message: string, config?: GenerationConfig): QueryResponse {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    // Add user message\n    session.messages.push({\n      role: 'user',\n      content: message,\n      timestamp: new Date(),\n    });\n\n    // Build context from recent messages\n    const contextWindow = this.buildContext(session);\n\n    // Query with context\n    const prompt = contextWindow ? `${contextWindow}\\n\\nUser: ${message}` : message;\n    const response = this.llm.query(prompt, config);\n\n    // Add assistant response\n    session.messages.push({\n      role: 'assistant',\n      content: response.text,\n      timestamp: new Date(),\n      requestId: response.requestId,\n    });\n\n    session.messageCount = session.messages.length;\n\n    return response;\n  }\n\n  /**\n   * Add system message to session\n   */\n  addSystemMessage(sessionId: string, content: string): void {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    session.messages.push({\n      role: 'system',\n      content,\n      timestamp: new Date(),\n    });\n    session.messageCount = session.messages.length;\n  }\n\n  /**\n   * Add context to session (persisted to memory)\n   */\n  addContext(sessionId: string, context: string): number {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      throw new Error(`Session not found: ${sessionId}`);\n    }\n\n    session.context.push(context);\n\n    // Also store in memory for retrieval\n    const memoryId = this.llm.addMemory(context, {\n      sessionId,\n      type: 'context',\n      timestamp: new Date().toISOString(),\n    });\n\n    session.activeMemoryIds.push(memoryId);\n    return memoryId;\n  }\n\n  /**\n   * Get conversation history\n   */\n  getHistory(sessionId: string, limit?: number): ConversationMessage[] {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return [];\n    }\n\n    const messages = session.messages;\n    return limit ? messages.slice(-limit) : messages;\n  }\n\n  /**\n   * Clear session history (keep session active)\n   */\n  clearHistory(sessionId: string): void {\n    const session = this.sessions.get(sessionId);\n    if (session) {\n      session.messages = [];\n      session.context = [];\n      session.messageCount = 0;\n    }\n  }\n\n  /**\n   * End and delete session\n   */\n  end(sessionId: string): boolean {\n    return this.sessions.delete(sessionId);\n  }\n\n  /**\n   * List all active sessions\n   */\n  list(): ConversationSession[] {\n    return Array.from(this.sessions.values());\n  }\n\n  /**\n   * Export session as JSON\n   */\n  export(sessionId: string): string | null {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return null;\n    }\n\n    return JSON.stringify(session, null, 2);\n  }\n\n  /**\n   * Import session from JSON\n   */\n  import(json: string): ConversationSession {\n    const data = JSON.parse(json);\n    const session: ConversationSession = {\n      ...data,\n      createdAt: new Date(data.createdAt),\n      messages: data.messages.map((m: ConversationMessage) => ({\n        ...m,\n        timestamp: new Date(m.timestamp),\n      })),\n    };\n\n    this.sessions.set(session.id, session);\n    return session;\n  }\n\n  /**\n   * Build context string from recent messages\n   */\n  private buildContext(session: ConversationSession, maxMessages = 10): string {\n    const recent = session.messages.slice(-maxMessages);\n    if (recent.length === 0) {\n      return '';\n    }\n\n    const contextParts: string[] = [];\n\n    // Add persistent context\n    if (session.context.length > 0) {\n      contextParts.push('Context:\\n' + session.context.join('\\n'));\n    }\n\n    // Add conversation history\n    const history = recent\n      .map(m => {\n        const role = m.role === 'user' ? 'User' : m.role === 'assistant' ? 'Assistant' : 'System';\n        return `${role}: ${m.content}`;\n      })\n      .join('\\n');\n\n    if (history) {\n      contextParts.push('Conversation:\\n' + history);\n    }\n\n    return contextParts.join('\\n\\n');\n  }\n}\n"]}

package/dist/esm/simd.d.ts

@@ -0,0 +1,90 @@
+/**
+ * SIMD Operations for vector computations
+ *
+ * Uses native SIMD instructions (AVX2/AVX512/SSE4.1/NEON) when available,
+ * falls back to JavaScript implementations otherwise.
+ */
+/**
+ * SIMD Operations class
+ *
+ * Provides hardware-accelerated vector operations when native module is available.
+ *
+ * @example
+ * ```typescript
+ * import { SimdOps } from '@ruvector/ruvllm';
+ *
+ * const simd = new SimdOps();
+ *
+ * // Compute dot product
+ * const result = simd.dotProduct([1, 2, 3], [4, 5, 6]);
+ * console.log(result); // 32
+ *
+ * // Check capabilities
+ * console.log(simd.capabilities()); // ['AVX2', 'FMA']
+ * ```
+ */
+export declare class SimdOps {
+    private native;
+    constructor();
+    /**
+     * Compute dot product of two vectors
+     */
+    dotProduct(a: number[], b: number[]): number;
+    /**
+     * Compute cosine similarity between two vectors
+     */
+    cosineSimilarity(a: number[], b: number[]): number;
+    /**
+     * Compute L2 (Euclidean) distance between two vectors
+     */
+    l2Distance(a: number[], b: number[]): number;
+    /**
+     * Matrix-vector multiplication
+     */
+    matvec(matrix: number[][], vector: number[]): number[];
+    /**
+     * Softmax activation function
+     */
+    softmax(input: number[]): number[];
+    /**
+     * Element-wise addition
+     */
+    add(a: number[], b: number[]): number[];
+    /**
+     * Element-wise multiplication
+     */
+    mul(a: number[], b: number[]): number[];
+    /**
+     * Scale vector by scalar
+     */
+    scale(a: number[], scalar: number): number[];
+    /**
+     * Normalize vector to unit length
+     */
+    normalize(a: number[]): number[];
+    /**
+     * ReLU activation
+     */
+    relu(input: number[]): number[];
+    /**
+     * GELU activation (approximate)
+     */
+    gelu(input: number[]): number[];
+    /**
+     * Sigmoid activation
+     */
+    sigmoid(input: number[]): number[];
+    /**
+     * Layer normalization
+     */
+    layerNorm(input: number[], eps?: number): number[];
+    /**
+     * Check if native SIMD is available
+     */
+    isNative(): boolean;
+    /**
+     * Get available SIMD capabilities
+     */
+    capabilities(): string[];
+}
+//# sourceMappingURL=simd.d.ts.map

package/dist/esm/simd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simd.d.ts","sourceRoot":"","sources":["../../src/simd.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAA8B;;IAa5C;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAc5C;;OAEG;IACH,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAqBlD;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM;IAe5C;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAStD;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAYlC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IASvC;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IASvC;;OAEG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAI5C;;OAEG;IACH,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAKhC;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAI/B;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAM/B;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAIlC;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,SAAO,GAAG,MAAM,EAAE;IAOhD;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;CAkBzB"}