doc2vec 1.3.0 → 2.2.0

package/dist/electron-app/src/mcp-server.js

@@ -0,0 +1,496 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
+const express_1 = __importDefault(require("express"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sqliteVec = __importStar(require("sqlite-vec"));
+const openai_1 = __importDefault(require("openai"));
+const crypto_1 = require("crypto");
+class McpServer {
+    constructor(port = 3333) {
+        this.server = null;
+        this.dbPath = null;
+        this.openaiApiKey = null;
+        this.sessions = new Map();
+        this.port = port;
+        this.app = (0, express_1.default)();
+        this.app.use(express_1.default.json());
+        this.setupRoutes();
+    }
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', database: this.dbPath ? 'connected' : 'not connected' });
+        });
+        // MCP-style tool listing
+        this.app.get('/tools', (_req, res) => {
+            res.json({
+                tools: [{
+                        name: 'query_documents',
+                        description: 'Search through synced documents using semantic vector search.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                query: {
+                                    type: 'string',
+                                    description: 'The natural language query to search for.'
+                                },
+                                limit: {
+                                    type: 'number',
+                                    description: 'Maximum number of results to return (1-20). Defaults to 5.',
+                                    default: 5
+                                }
+                            },
+                            required: ['query']
+                        }
+                    }]
+            });
+        });
+        // Query endpoint
+        this.app.post('/query', async (req, res) => {
+            try {
+                const { query, queryText, limit = 5 } = req.body;
+                const searchQuery = query || queryText; // Support both parameter names
+                if (!searchQuery) {
+                    res.status(400).json({ error: 'query is required' });
+                    return;
+                }
+                if (!this.dbPath) {
+                    res.status(503).json({ error: 'Database not configured. Please select a database in the app.' });
+                    return;
+                }
+                if (!this.openaiApiKey) {
+                    res.status(503).json({ error: 'OpenAI API key not configured. Please add your API key in the app.' });
+                    return;
+                }
+                const results = await this.queryDatabase(searchQuery, Math.min(limit, 20));
+                res.json({
+                    query: searchQuery,
+                    count: results.length,
+                    results
+                });
+            }
+            catch (error) {
+                console.error('Query error:', error);
+                res.status(500).json({ error: error.message });
+            }
+        });
+        // MCP Streamable HTTP endpoint - proper JSON-RPC handling
+        this.app.post('/mcp', async (req, res) => {
+            try {
+                const request = req.body;
+                const { jsonrpc, id, method, params } = request;
+                // Get or create session
+                let sessionId = req.headers['mcp-session-id'];
+                if (!sessionId && method === 'initialize') {
+                    sessionId = (0, crypto_1.randomUUID)();
+                    this.sessions.set(sessionId, true);
+                }
+                // Set session header
+                if (sessionId) {
+                    res.setHeader('mcp-session-id', sessionId);
+                }
+                console.log(`MCP Request: ${method}`, params ? JSON.stringify(params).substring(0, 100) : '');
+                // Handle MCP methods
+                switch (method) {
+                    case 'initialize':
+                        res.json({
+                            jsonrpc: '2.0',
+                            id,
+                            result: {
+                                protocolVersion: '2024-11-05',
+                                capabilities: {
+                                    tools: {}
+                                },
+                                serverInfo: {
+                                    name: 'docs4ai',
+                                    version: '1.0.0'
+                                }
+                            }
+                        });
+                        return;
+                    case 'notifications/initialized':
+                        // Client acknowledged initialization - no response needed for notifications
+                        res.status(204).send();
+                        return;
+                    case 'tools/list':
+                        res.json({
+                            jsonrpc: '2.0',
+                            id,
+                            result: {
+                                tools: [
+                                    {
+                                        name: 'query_documents',
+                                        description: 'Search through synced documents using semantic vector search. Returns relevant document chunks with their chunk_index and total_chunks so you can retrieve additional chunks from the same document using get_chunks.',
+                                        inputSchema: {
+                                            type: 'object',
+                                            properties: {
+                                                query: {
+                                                    type: 'string',
+                                                    description: 'The natural language search query'
+                                                },
+                                                limit: {
+                                                    type: 'number',
+                                                    description: 'Maximum number of results to return (1-20)',
+                                                    default: 5
+                                                }
+                                            },
+                                            required: ['query']
+                                        }
+                                    },
+                                    {
+                                        name: 'get_chunks',
+                                        description: 'Retrieve specific chunks from a document by file path. Use this to get more context from a document after finding it with query_documents. You can retrieve individual chunks or a range of chunks.',
+                                        inputSchema: {
+                                            type: 'object',
+                                            properties: {
+                                                file_path: {
+                                                    type: 'string',
+                                                    description: 'The file path (url) of the document to retrieve chunks from'
+                                                },
+                                                chunk_indices: {
+                                                    type: 'array',
+                                                    items: { type: 'number' },
+                                                    description: 'Array of chunk indices to retrieve (0-based). If not provided, returns all chunks.'
+                                                }
+                                            },
+                                            required: ['file_path']
+                                        }
+                                    }
+                                ]
+                            }
+                        });
+                        return;
+                    case 'tools/call':
+                        const { name, arguments: args } = params || {};
+                        if (name === 'query_documents') {
+                            if (!this.dbPath || !this.openaiApiKey) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: 'Error: Database or API key not configured in Docs4ai app. Please configure them in the app settings.' }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                            const query = args?.query || args?.queryText || '';
+                            if (!query) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: 'Error: query parameter is required' }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                            try {
+                                const results = await this.queryDatabase(query, Math.min(args?.limit || 5, 20));
+                                if (results.length === 0) {
+                                    res.json({
+                                        jsonrpc: '2.0',
+                                        id,
+                                        result: {
+                                            content: [{ type: 'text', text: `No results found for "${query}"` }]
+                                        }
+                                    });
+                                    return;
+                                }
+                                const formatted = results.map((r, i) => `**Result ${i + 1}** (distance: ${r.distance.toFixed(4)})\n` +
+                                    `File: ${r.url}\n` +
+                                    `Section: ${r.section}\n` +
+                                    `Chunk: ${r.chunk_index + 1} of ${r.total_chunks}\n` +
+                                    `${r.content}\n` +
+                                    `---`).join('\n\n');
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: `Found ${results.length} results for "${query}":\n\n${formatted}` }]
+                                    }
+                                });
+                                return;
+                            }
+                            catch (queryError) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: `Error querying database: ${queryError.message}` }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                        }
+                        if (name === 'get_chunks') {
+                            if (!this.dbPath) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: 'Error: Database not configured in Docs4ai app.' }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                            const filePath = args?.file_path || '';
+                            if (!filePath) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: 'Error: file_path parameter is required' }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                            try {
+                                const chunks = this.getChunksForFile(filePath, args?.chunk_indices);
+                                if (chunks.length === 0) {
+                                    res.json({
+                                        jsonrpc: '2.0',
+                                        id,
+                                        result: {
+                                            content: [{ type: 'text', text: `No chunks found for file: ${filePath}` }]
+                                        }
+                                    });
+                                    return;
+                                }
+                                const formatted = chunks.map((c) => `**Chunk ${c.chunk_index + 1} of ${c.total_chunks}**\n` +
+                                    `Section: ${c.section}\n` +
+                                    `${c.content}\n` +
+                                    `---`).join('\n\n');
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: `Retrieved ${chunks.length} chunk(s) from "${filePath}":\n\n${formatted}` }]
+                                    }
+                                });
+                                return;
+                            }
+                            catch (chunkError) {
+                                res.json({
+                                    jsonrpc: '2.0',
+                                    id,
+                                    result: {
+                                        content: [{ type: 'text', text: `Error retrieving chunks: ${chunkError.message}` }],
+                                        isError: true
+                                    }
+                                });
+                                return;
+                            }
+                        }
+                        res.json({
+                            jsonrpc: '2.0',
+                            id,
+                            error: {
+                                code: -32601,
+                                message: `Unknown tool: ${name}`
+                            }
+                        });
+                        return;
+                    default:
+                        res.json({
+                            jsonrpc: '2.0',
+                            id,
+                            error: {
+                                code: -32601,
+                                message: `Method not found: ${method}`
+                            }
+                        });
+                        return;
+                }
+            }
+            catch (error) {
+                console.error('MCP error:', error);
+                res.json({
+                    jsonrpc: '2.0',
+                    id: req.body?.id,
+                    error: {
+                        code: -32603,
+                        message: error.message
+                    }
+                });
+            }
+        });
+        // Handle GET for SSE (not implemented, return 404)
+        this.app.get('/mcp', (_req, res) => {
+            res.status(404).json({ error: 'SSE not supported, use POST for Streamable HTTP' });
+        });
+    }
+    async queryDatabase(queryText, limit) {
+        if (!this.dbPath || !this.openaiApiKey) {
+            throw new Error('Database or API key not configured');
+        }
+        // Generate embedding for query
+        const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+        const embeddingResponse = await openai.embeddings.create({
+            model: 'text-embedding-3-large',
+            input: queryText
+        });
+        const queryEmbedding = embeddingResponse.data[0].embedding;
+        // Query database
+        const db = new better_sqlite3_1.default(this.dbPath);
+        sqliteVec.load(db);
+        try {
+            const stmt = db.prepare(`
+                SELECT
+                    chunk_id,
+                    distance,
+                    content,
+                    url,
+                    section,
+                    heading_hierarchy,
+                    chunk_index,
+                    total_chunks
+                FROM vec_items
+                WHERE embedding MATCH ?
+                ORDER BY distance
+                LIMIT ?
+            `);
+            const rows = stmt.all(new Float32Array(queryEmbedding), limit);
+            return rows;
+        }
+        finally {
+            db.close();
+        }
+    }
+    getChunksForFile(filePath, chunkIndices) {
+        if (!this.dbPath) {
+            throw new Error('Database not configured');
+        }
+        const db = new better_sqlite3_1.default(this.dbPath);
+        sqliteVec.load(db);
+        try {
+            let rows;
+            if (chunkIndices && chunkIndices.length > 0) {
+                // Get specific chunks by index
+                const placeholders = chunkIndices.map(() => '?').join(',');
+                const stmt = db.prepare(`
+                    SELECT
+                        chunk_id,
+                        content,
+                        section,
+                        heading_hierarchy,
+                        chunk_index,
+                        total_chunks
+                    FROM vec_items
+                    WHERE url = ? AND chunk_index IN (${placeholders})
+                    ORDER BY chunk_index
+                `);
+                rows = stmt.all(filePath, ...chunkIndices);
+            }
+            else {
+                // Get all chunks for the file
+                const stmt = db.prepare(`
+                    SELECT
+                        chunk_id,
+                        content,
+                        section,
+                        heading_hierarchy,
+                        chunk_index,
+                        total_chunks
+                    FROM vec_items
+                    WHERE url = ?
+                    ORDER BY chunk_index
+                `);
+                rows = stmt.all(filePath);
+            }
+            return rows;
+        }
+        finally {
+            db.close();
+        }
+    }
+    setDatabase(dbPath) {
+        this.dbPath = dbPath;
+        console.log(`MCP Server: Database set to ${dbPath}`);
+    }
+    setApiKey(apiKey) {
+        this.openaiApiKey = apiKey;
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            try {
+                const server = this.app.listen(this.port, () => {
+                    console.log(`MCP Server running on http://localhost:${this.port}`);
+                    resolve();
+                });
+                server.on('error', (error) => {
+                    if (error.code === 'EADDRINUSE') {
+                        console.error(`MCP Server: Port ${this.port} already in use`);
+                    }
+                    reject(error);
+                });
+                this.server = server;
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('MCP Server stopped');
+                    this.server = null;
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    isRunning() {
+        return this.server !== null;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+exports.McpServer = McpServer;

package/dist/electron-app/src/preload.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+electron_1.contextBridge.exposeInMainWorld('api', {
+    getSettings: () => electron_1.ipcRenderer.invoke('get-settings'),
+    saveSettings: (settings) => electron_1.ipcRenderer.invoke('save-settings', settings),
+    selectFolder: () => electron_1.ipcRenderer.invoke('select-folder'),
+    selectDatabase: () => electron_1.ipcRenderer.invoke('select-database'),
+    getStats: () => electron_1.ipcRenderer.invoke('get-stats'),
+    getFiles: () => electron_1.ipcRenderer.invoke('get-files'),
+    getChunks: (filePath) => electron_1.ipcRenderer.invoke('get-chunks', filePath),
+    startWatching: () => electron_1.ipcRenderer.invoke('start-watching'),
+    stopWatching: () => electron_1.ipcRenderer.invoke('stop-watching'),
+    forceSync: () => electron_1.ipcRenderer.invoke('force-sync'),
+    startMcpServer: () => electron_1.ipcRenderer.invoke('start-mcp-server'),
+    stopMcpServer: () => electron_1.ipcRenderer.invoke('stop-mcp-server'),
+    getMcpStatus: () => electron_1.ipcRenderer.invoke('get-mcp-status'),
+    onStatsUpdate: (callback) => {
+        electron_1.ipcRenderer.on('stats-update', (_event, stats) => callback(stats));
+    },
+    onApiKeyError: (callback) => {
+        electron_1.ipcRenderer.on('api-key-error', (_event, message) => callback(message));
+    }
+});