dev-mcp-server 0.0.2

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "dev-mcp-server",
+    "version": "0.0.2",
+    "description": "Model Context Platform — AI that understands YOUR codebase",
+    "main": "src/api/server.js",
+    "type": "commonjs",
+    "author": {
+        "name": "Anand Pilania",
+        "email": "pilaniaanand@gmail.com",
+        "url": "https://github.com/AnandPilania"
+    },
+    "bin": {
+        "dev-mcp": "./cli.js",
+        "dev-mcp-server": "./cli.js"
+    },
+    "scripts": {
+        "start": "node src/api/server.js",
+        "dev": "nodemon src/api/server.js",
+        "ingest": "node cli.js ingest",
+        "query": "node cli.js query",
+        "stats": "node cli.js stats",
+        "clear": "node cli.js clear"
+    },
+    "dependencies": {
+        "@anthropic-ai/sdk": "^0.24.0",
+        "chalk": "^4.1.2",
+        "commander": "^12.0.0",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.5",
+        "express": "^4.19.2",
+        "glob": "^10.4.1",
+        "morgan": "^1.10.0",
+        "natural": "^8.0.1",
+        "openai": "^4.52.0",
+        "ora": "^5.4.1",
+        "winston": "^3.13.0"
+    },
+    "devDependencies": {
+        "nodemon": "^3.1.2"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "files": [
+        "cli.js",
+        "src/",
+        ".env.example",
+        "README.md"
+    ],
+    "keywords": [
+        "mcp",
+        "codebase",
+        "ai",
+        "developer-tools",
+        "anthropic",
+        "ollama",
+        "azure-openai"
+    ],
+    "license": "MIT"
+}

package/src/api/routes/ingest.js

@@ -0,0 +1,69 @@
+const express = require('express');
+const router = express.Router();
+const ingester = require('../../core/ingester');
+const indexer = require('../../core/indexer');
+const store = require('../../storage/store');
+const logger = require('../../utils/logger');
+
+router.post('/file', async (req, res) => {
+    const { filePath } = req.body;
+
+    if (!filePath) {
+        return res.status(400).json({ error: 'filePath is required' });
+    }
+
+    try {
+        const result = await ingester.ingestFile(filePath);
+        indexer.build();
+        res.json({ success: true, result });
+    } catch (err) {
+        logger.error(`Ingest file error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/directory', async (req, res) => {
+    const { dirPath } = req.body;
+
+    if (!dirPath) {
+        return res.status(400).json({ error: 'dirPath is required' });
+    }
+
+    try {
+        const result = await ingester.ingestDirectory(dirPath);
+        res.json({ success: true, result });
+    } catch (err) {
+        logger.error(`Ingest directory error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/raw', async (req, res) => {
+    const { content, kind, label, tags } = req.body;
+
+    if (!content) {
+        return res.status(400).json({ error: 'content is required' });
+    }
+
+    try {
+        const result = await ingester.ingestRawText(content, { kind, label, tags });
+        indexer.build();
+        res.json({ success: true, result });
+    } catch (err) {
+        logger.error(`Ingest raw error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.delete('/clear', (req, res) => {
+    store.clear();
+    indexer.invalidate();
+    res.json({ success: true, message: 'Knowledge base cleared' });
+});
+
+router.get('/files', (req, res) => {
+    const files = store.getIngestedFiles();
+    res.json({ files, count: files.length });
+});
+
+module.exports = router;

package/src/api/routes/knowledge.js

@@ -0,0 +1,65 @@
+const express = require('express');
+const router = express.Router();
+const store = require('../../storage/store');
+const indexer = require('../../core/indexer');
+
+router.get('/stats', (req, res) => {
+    const stats = store.getStats();
+    res.json(stats);
+});
+
+router.get('/search', (req, res) => {
+    const { q, topK = '8', kind } = req.query;
+
+    if (!q) {
+        return res.status(400).json({ error: 'q query parameter is required' });
+    }
+
+    const filter = kind ? { kind } : {};
+    const results = indexer.search(q, parseInt(topK), filter);
+
+    res.json({
+        query: q,
+        count: results.length,
+        results: results.map(r => ({
+            file: r.filename,
+            path: r.filePath,
+            kind: r.kind,
+            relevanceScore: r.relevanceScore,
+            snippet: r.content.slice(0, 300) + (r.content.length > 300 ? '...' : ''),
+            metadata: r.metadata,
+        })),
+    });
+});
+
+router.get('/files', (req, res) => {
+    const { kind } = req.query;
+    const docs = kind ? store.getByKind(kind) : store.getAll();
+
+    const grouped = {};
+    for (const doc of docs) {
+        if (!grouped[doc.filePath]) {
+            grouped[doc.filePath] = {
+                filePath: doc.filePath,
+                filename: doc.filename,
+                kind: doc.kind,
+                chunks: 0,
+                ingestedAt: doc.ingestedAt,
+                metadata: doc.metadata,
+            };
+        }
+        grouped[doc.filePath].chunks++;
+    }
+
+    res.json({
+        count: Object.keys(grouped).length,
+        files: Object.values(grouped),
+    });
+});
+
+router.post('/rebuild', (req, res) => {
+    const count = indexer.build();
+    res.json({ success: true, documentsIndexed: count });
+});
+
+module.exports = router;

package/src/api/routes/query.js

@@ -0,0 +1,105 @@
+const express = require('express');
+const router = express.Router();
+const { QueryEngine, QUERY_MODES } = require('../../core/queryEngine');
+const logger = require('../../utils/logger');
+
+router.post('/', async (req, res) => {
+    const { question, topK, filter, mode } = req.body;
+
+    if (!question) {
+        return res.status(400).json({ error: 'question is required' });
+    }
+
+    try {
+        const result = await QueryEngine.query(question, { topK, filter, mode });
+        res.json(result);
+    } catch (err) {
+        logger.error(`Query error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/debug', async (req, res) => {
+    const { error, stackTrace, question, topK } = req.body;
+
+    if (!error && !question) {
+        return res.status(400).json({ error: 'error or question is required' });
+    }
+
+    try {
+        let result;
+        if (error) {
+            result = await QueryEngine.debugError(error, stackTrace, { topK });
+        } else {
+            result = await QueryEngine.query(question, { mode: QUERY_MODES.DEBUG, topK });
+        }
+        res.json(result);
+    } catch (err) {
+        logger.error(`Debug query error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/usage', async (req, res) => {
+    const { symbol, topK } = req.body;
+
+    if (!symbol) {
+        return res.status(400).json({ error: 'symbol is required' });
+    }
+
+    try {
+        const result = await QueryEngine.findUsages(symbol, { topK });
+        res.json(result);
+    } catch (err) {
+        logger.error(`Usage query error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/impact', async (req, res) => {
+    const { target, changeDescription, topK } = req.body;
+
+    if (!target) {
+        return res.status(400).json({ error: 'target is required' });
+    }
+
+    try {
+        const result = await QueryEngine.analyzeImpact(target, changeDescription, { topK });
+        res.json(result);
+    } catch (err) {
+        logger.error(`Impact query error: ${err.message}`);
+        res.status(500).json({ error: err.message });
+    }
+});
+
+router.post('/stream', async (req, res) => {
+    const { question, topK, mode } = req.body;
+
+    if (!question) {
+        return res.status(400).json({ error: 'question is required' });
+    }
+
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+
+    try {
+        const generator = await QueryEngine.query(question, { topK, mode, stream: true });
+
+        for await (const chunk of generator) {
+            res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+
+            if (chunk.type === 'done') {
+                res.end();
+                return;
+            }
+        }
+    } catch (err) {
+        logger.error(`Stream query error: ${err.message}`);
+        res.write(`data: ${JSON.stringify({ type: 'error', error: err.message })}\n\n`);
+        res.end();
+    }
+});
+
+module.exports = router;

package/src/api/server.js

@@ -0,0 +1,91 @@
+const path = require('path');
+require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
+const express = require('express');
+const cors = require('cors');
+const morgan = require('morgan');
+const logger = require('../utils/logger');
+const indexer = require('../core/indexer');
+const store = require('../storage/store');
+
+const ingestRoutes = require('./routes/ingest');
+const queryRoutes = require('./routes/query');
+const knowledgeRoutes = require('./routes/knowledge');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(cors());
+app.use(express.json({ limit: '10mb' }));
+app.use(morgan('dev', {
+    stream: { write: (msg) => logger.info(msg.trim()) },
+}));
+
+app.use('/api/ingest', ingestRoutes);
+app.use('/api/query', queryRoutes);
+app.use('/api/knowledge', knowledgeRoutes);
+
+app.get('/health', (req, res) => {
+    const stats = store.getStats();
+    res.json({
+        status: 'ok',
+        uptime: process.uptime(),
+        memory: process.memoryUsage(),
+        knowledgeBase: stats,
+    });
+});
+
+app.get('/', (req, res) => {
+    res.json({
+        name: 'Dev MCP Server — Model Context Platform',
+        version: '1.0.0',
+        description: 'AI that understands YOUR codebase',
+        endpoints: {
+            health: 'GET /health',
+            ingest: {
+                file: 'POST /api/ingest/file',
+                directory: 'POST /api/ingest/directory',
+                raw: 'POST /api/ingest/raw',
+                clear: 'DELETE /api/ingest/clear',
+                listFiles: 'GET /api/ingest/files',
+            },
+            query: {
+                general: 'POST /api/query',
+                debug: 'POST /api/query/debug',
+                usage: 'POST /api/query/usage',
+                impact: 'POST /api/query/impact',
+                stream: 'POST /api/query/stream',
+            },
+            knowledge: {
+                stats: 'GET /api/knowledge/stats',
+                search: 'GET /api/knowledge/search?q=<query>',
+                files: 'GET /api/knowledge/files',
+                rebuild: 'POST /api/knowledge/rebuild',
+            },
+        },
+    });
+});
+
+app.use((req, res) => {
+    res.status(404).json({ error: `Route not found: ${req.method} ${req.path}` });
+});
+
+app.use((err, req, res, next) => {
+    logger.error(`Unhandled error: ${err.message}`);
+    res.status(500).json({ error: 'Internal server error', detail: err.message });
+});
+
+app.listen(PORT, () => {
+    logger.info(`🚀 Dev MCP Server running on http://localhost:${PORT}`);
+    logger.info(`📚 Knowledge base: ${store.getStats().totalDocs} documents`);
+
+    const stats = store.getStats();
+    if (stats.totalDocs > 0) {
+        logger.info('🔍 Rebuilding search index...');
+        const count = indexer.build();
+        logger.info(`✅ Index ready: ${count} documents`);
+    } else {
+        logger.info('📭 Knowledge base is empty — run: node cli.js ingest <path>');
+    }
+});
+
+module.exports = app;

package/src/core/indexer.js

@@ -0,0 +1,171 @@
+const natural = require('natural');
+const store = require('../storage/store');
+const logger = require('../utils/logger');
+
+const tokenizer = new natural.WordTokenizer();
+const TfIdf = natural.TfIdf;
+
+class Indexer {
+    constructor() {
+        this.tfidf = new TfIdf();
+        this._docMap = [];
+        this._built = false;
+    }
+
+    build() {
+        this.tfidf = new TfIdf();
+        this._docMap = [];
+
+        const docs = store.getAll();
+        for (const doc of docs) {
+            const text = this._docToText(doc);
+            this.tfidf.addDocument(text);
+            this._docMap.push(doc.id);
+        }
+
+        this._built = true;
+        logger.info(`Index built: ${docs.length} documents`);
+        return docs.length;
+    }
+
+    search(query, topK = 8, filter = {}) {
+        if (!this._built || this._docMap.length === 0) {
+            this.build();
+        }
+
+        const queryTokens = tokenizer.tokenize(query.toLowerCase());
+        const scores = new Array(this._docMap.length).fill(0);
+
+        for (const token of queryTokens) {
+            this.tfidf.tfidfs(token, (i, measure) => {
+                if (i < scores.length) {
+                    scores[i] += measure;
+                }
+            });
+        }
+
+        const allDocs = store.getAll();
+        scores.forEach((_, i) => {
+            const doc = allDocs[i];
+            if (!doc) return;
+            const textLower = doc.content.toLowerCase();
+            for (const token of queryTokens) {
+                if (token.length > 3 && textLower.includes(token)) {
+                    scores[i] += 0.5;
+                }
+            }
+
+            if (doc.metadata) {
+                const metaText = JSON.stringify(doc.metadata).toLowerCase();
+                for (const token of queryTokens) {
+                    if (token.length > 3 && metaText.includes(token)) {
+                        scores[i] += 1.0;
+                    }
+                }
+            }
+        });
+
+        let results = scores
+            .map((score, i) => ({ score, doc: allDocs[i] }))
+            .filter(r => r.doc && r.score > 0);
+
+        if (filter.kind) {
+            results = results.filter(r => r.doc.kind === filter.kind);
+        }
+        if (filter.filename) {
+            results = results.filter(r =>
+                r.doc.filename.toLowerCase().includes(filter.filename.toLowerCase())
+            );
+        }
+
+        results.sort((a, b) => b.score - a.score);
+
+        const seenFiles = new Map();
+        const deduped = [];
+        for (const r of results) {
+            const fp = r.doc.filePath;
+            if (!seenFiles.has(fp)) {
+                seenFiles.set(fp, r);
+                deduped.push(r);
+            } else if (r.score > seenFiles.get(fp).score) {
+                const idx = deduped.findIndex(d => d.doc.filePath === fp);
+                deduped[idx] = r;
+            }
+            if (deduped.length >= topK) break;
+        }
+
+        return deduped.slice(0, topK).map(r => ({
+            ...r.doc,
+            relevanceScore: parseFloat(r.score.toFixed(4)),
+        }));
+    }
+
+    searchForErrors(errorType, topK = 6) {
+        const results = this.search(errorType, topK * 2);
+        return results
+            .map(doc => ({
+                ...doc,
+                relevanceScore: doc.kind === 'log'
+                    ? doc.relevanceScore * 1.5
+                    : doc.metadata?.isBugFix
+                        ? doc.relevanceScore * 1.3
+                        : doc.relevanceScore,
+            }))
+            .sort((a, b) => b.relevanceScore - a.relevanceScore)
+            .slice(0, topK);
+    }
+
+    searchForUsages(symbol, topK = 8) {
+        const query = `${symbol} usage import call reference`;
+        const results = this.search(query, topK * 2);
+
+        return results
+            .map(doc => {
+                let boost = 1;
+                if (doc.content.includes(symbol)) boost = 2;
+                if (doc.metadata?.imports?.some(i => i.includes(symbol))) boost = 2.5;
+                if (doc.metadata?.functions?.includes(symbol)) boost = 3;
+                return { ...doc, relevanceScore: doc.relevanceScore * boost };
+            })
+            .sort((a, b) => b.relevanceScore - a.relevanceScore)
+            .slice(0, topK);
+    }
+
+    searchForImpact(target, topK = 8) {
+        const query = `${target} depends import module connection`;
+        const results = this.search(query, topK * 2);
+
+        return results
+            .map(doc => {
+                let boost = 1;
+                if (doc.content.includes(target)) boost = 2;
+                if (doc.metadata?.imports?.some(i => i.includes(target))) boost = 3;
+                return { ...doc, relevanceScore: doc.relevanceScore * boost };
+            })
+            .sort((a, b) => b.relevanceScore - a.relevanceScore)
+            .slice(0, topK);
+    }
+
+    _docToText(doc) {
+        const parts = [
+            doc.filename,
+            doc.kind,
+            doc.content,
+            doc.metadata?.functions?.join(' ') || '',
+            doc.metadata?.classes?.join(' ') || '',
+            doc.metadata?.imports?.join(' ') || '',
+            doc.metadata?.exports?.join(' ') || '',
+            doc.metadata?.errors?.join(' ') || '',
+            doc.metadata?.patterns?.join(' ') || '',
+            doc.metadata?.tables?.join(' ') || '',
+        ];
+        return parts.join(' ');
+    }
+
+    invalidate() {
+        this._built = false;
+    }
+}
+
+const indexer = new Indexer();
+module.exports = indexer;