@ruvector/ruvllm 0.2.0

package/dist/cjs/native.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Native bindings loader for RuvLLM
+ *
+ * Automatically loads the correct native binary for the current platform.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNativeModule = getNativeModule;
+exports.version = version;
+exports.hasSimdSupport = hasSimdSupport;
+const path_1 = require("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((0, path_1.join)(__dirname, '..', '..', 'ruvllm.node')),
+        // Try loading from local .node file (root)
+        () => require((0, path_1.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
+function getNativeModule() {
+    return loadNativeModule();
+}
+function version() {
+    const mod = loadNativeModule();
+    return mod?.version() ?? '0.1.0-js';
+}
+function hasSimdSupport() {
+    const mod = loadNativeModule();
+    return mod?.hasSimdSupport() ?? false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/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/cjs/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/cjs/session.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Session Management for multi-turn conversations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+/**
+ * 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
+ * ```
+ */
+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');
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AASH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAa,cAAc;IAIzB,YAAY,GAAsJ;QAH1J,aAAQ,GAAqC,IAAI,GAAG,EAAE,CAAC;QAI7D,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,QAAkC;QACvC,MAAM,EAAE,GAAG,WAAW,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC7E,MAAM,OAAO,GAAwB;YACnC,EAAE;YACF,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,YAAY,EAAE,CAAC;YACf,QAAQ,EAAE,EAAE;YACZ,OAAO,EAAE,EAAE;YACX,eAAe,EAAE,EAAE;YACnB,QAAQ,EAAE,QAAQ,IAAI,EAAE;SACzB,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC/B,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,SAAiB;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,SAAiB,EAAE,OAAe,EAAE,MAAyB;QAChE,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,mBAAmB;QACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;YACpB,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,OAAO;YAChB,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC,CAAC;QAEH,qCAAqC;QACrC,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;QAEjD,qBAAqB;QACrB,MAAM,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,aAAa,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;QAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAEhD,yBAAyB;QACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;YACpB,IAAI,EAAE,WAAW;YACjB,OAAO,EAAE,QAAQ,CAAC,IAAI;YACtB,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,SAAS,EAAE,QAAQ,CAAC,SAAS;SAC9B,CAAC,CAAC;QAEH,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;QAE/C,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,SAAiB,EAAE,OAAe;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;YACpB,IAAI,EAAE,QAAQ;YACd,OAAO;YACP,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC,CAAC;QACH,OAAO,CAAC,YAAY,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,SAAiB,EAAE,OAAe;QAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAC;QACrD,CAAC;QAED,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE9B,qCAAqC;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,EAAE;YAC3C,SAAS;YACT,IAAI,EAAE,SAAS;YACf,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACpC,CAAC,CAAC;QAEH,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,UAAU,CAAC,SAAiB,EAAE,KAAc;QAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAClC,OAAO,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACnD,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,SAAiB;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,CAAC,QAAQ,GAAG,EAAE,CAAC;YACtB,OAAO,CAAC,OAAO,GAAG,EAAE,CAAC;YACrB,OAAO,CAAC,YAAY,GAAG,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,SAAiB;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,IAAI;QACF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,SAAiB;QACtB,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAY;QACjB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC9B,MAAM,OAAO,GAAwB;YACnC,GAAG,IAAI;YACP,SAAS,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;YACnC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAsB,EAAE,EAAE,CAAC,CAAC;gBACvD,GAAG,CAAC;gBACJ,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;aACjC,CAAC,CAAC;SACJ,CAAC;QAEF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACvC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,OAA4B,EAAE,WAAW,GAAG,EAAE;QACjE,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WAAW,CAAC,CAAC;QACpD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,YAAY,GAAa,EAAE,CAAC;QAElC,yBAAyB;QACzB,IAAI,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,YAAY,CAAC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/D,CAAC;QAED,2BAA2B;QAC3B,MAAM,OAAO,GAAG,MAAM;aACnB,GAAG,CAAC,CAAC,CAAC,EAAE;YACP,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC1F,OAAO,GAAG,IAAI,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC;QACjC,CAAC,CAAC;aACD,IAAI,CAAC,IAAI,CAAC,CAAC;QAEd,IAAI,OAAO,EAAE,CAAC;YACZ,YAAY,CAAC,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;CACF;AA/MD,wCA+MC","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/cjs/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/cjs/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"}