dev-mcp-server 0.0.2 → 1.0.0

package/src/api/routes/git.js

@@ -0,0 +1,72 @@
+const express = require('express');
+const router = express.Router();
+const GitTool = require('../../tools/GitTool');
+const logger = require('../../utils/logger');
+
+/** GET /api/git/status */
+router.get('/status', async (req, res) => {
+  const { cwd } = req.query;
+  try {
+    const status = await GitTool.status(cwd);
+    res.json(status);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/git/diff */
+router.get('/diff', async (req, res) => {
+  const { cwd, staged, file, stat } = req.query;
+  try {
+    const result = await GitTool.diff({ cwd, staged: staged === 'true', file, stat: stat === 'true' });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/git/commit */
+router.post('/commit', async (req, res) => {
+  const { cwd, files, message, autoMessage } = req.body;
+  try {
+    const result = await GitTool.commit({ cwd, files, message, autoMessage });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/git/review */
+router.post('/review', async (req, res) => {
+  const { cwd, staged, file, focus } = req.body;
+  try {
+    const result = await GitTool.review({ cwd, staged, file, focus });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/git/log */
+router.get('/log', async (req, res) => {
+  const { cwd, limit, file, oneline } = req.query;
+  try {
+    const result = await GitTool.log({ cwd, limit: parseInt(limit) || 10, file, oneline: oneline === 'true' });
+    res.json({ commits: result });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/git/branches */
+router.get('/branches', async (req, res) => {
+  const { cwd } = req.query;
+  try {
+    const result = await GitTool.branches(cwd);
+    res.json({ branches: result });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/src/api/routes/ingest.js

@@ -5,65 +5,85 @@ const indexer = require('../../core/indexer');
 const store = require('../../storage/store');
 const logger = require('../../utils/logger');
 
+/**
+ * POST /api/ingest/file
+ * Ingest a single file by path
+ */
 router.post('/file', async (req, res) => {
-    const { filePath } = req.body;
+  const { filePath } = req.body;
 
-    if (!filePath) {
-        return res.status(400).json({ error: 'filePath is required' });
-    }
+  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 });
-    }
+  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 });
+  }
 });
 
+/**
+ * POST /api/ingest/directory
+ * Ingest all supported files in a directory
+ */
 router.post('/directory', async (req, res) => {
-    const { dirPath } = req.body;
+  const { dirPath } = req.body;
 
-    if (!dirPath) {
-        return res.status(400).json({ error: 'dirPath is required' });
-    }
+  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 });
-    }
+  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 });
+  }
 });
 
+/**
+ * POST /api/ingest/raw
+ * Ingest raw text (error logs, bug descriptions, API responses)
+ */
 router.post('/raw', async (req, res) => {
-    const { content, kind, label, tags } = req.body;
+  const { content, kind, label, tags } = req.body;
 
-    if (!content) {
-        return res.status(400).json({ error: 'content is required' });
-    }
+  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 });
-    }
+  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 });
+  }
 });
 
+/**
+ * DELETE /api/ingest/clear
+ * Clear the entire knowledge base
+ */
 router.delete('/clear', (req, res) => {
-    store.clear();
-    indexer.invalidate();
-    res.json({ success: true, message: 'Knowledge base cleared' });
+  store.clear();
+  indexer.invalidate();
+  res.json({ success: true, message: 'Knowledge base cleared' });
 });
 
+/**
+ * GET /api/ingest/files
+ * List all ingested files
+ */
 router.get('/files', (req, res) => {
-    const files = store.getIngestedFiles();
-    res.json({ files, count: files.length });
+  const files = store.getIngestedFiles();
+  res.json({ files, count: files.length });
 });
 
 module.exports = router;

package/src/api/routes/knowledge.js

@@ -3,63 +3,81 @@ const router = express.Router();
 const store = require('../../storage/store');
 const indexer = require('../../core/indexer');
 
+/**
+ * GET /api/knowledge/stats
+ * Get knowledge base statistics
+ */
 router.get('/stats', (req, res) => {
-    const stats = store.getStats();
-    res.json(stats);
+  const stats = store.getStats();
+  res.json(stats);
 });
 
+/**
+ * GET /api/knowledge/search
+ * Raw TF-IDF search (no AI, just retrieval)
+ * Query params: q, topK, kind
+ */
 router.get('/search', (req, res) => {
-    const { q, topK = '8', kind } = req.query;
+  const { q, topK = '8', kind } = req.query;
 
-    if (!q) {
-        return res.status(400).json({ error: 'q query parameter is required' });
-    }
+  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);
+  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,
-        })),
-    });
+  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,
+    })),
+  });
 });
 
+/**
+ * GET /api/knowledge/files
+ * List all ingested files with metadata
+ */
 router.get('/files', (req, res) => {
-    const { kind } = req.query;
-    const docs = kind ? store.getByKind(kind) : store.getAll();
+  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++;
+  // Group by file path
+  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),
-    });
+  res.json({
+    count: Object.keys(grouped).length,
+    files: Object.values(grouped),
+  });
 });
 
+/**
+ * POST /api/knowledge/rebuild
+ * Force rebuild of the search index
+ */
 router.post('/rebuild', (req, res) => {
-    const count = indexer.build();
-    res.json({ success: true, documentsIndexed: count });
+  const count = indexer.build();
+  res.json({ success: true, documentsIndexed: count });
 });
 
 module.exports = router;

package/src/api/routes/memory.js

@@ -0,0 +1,41 @@
+const express = require('express');
+const router = express.Router();
+const { MemoryManager, MEMORY_TYPES } = require('../../memory/memoryManager');
+
+/** GET /api/memory — list all memories */
+router.get('/', (req, res) => {
+  const { type } = req.query;
+  const memories = MemoryManager.list(type || null);
+  res.json({ memories, stats: MemoryManager.getStats() });
+});
+
+/** POST /api/memory — add a memory manually */
+router.post('/', (req, res) => {
+  const { content, type, tags } = req.body;
+  if (!content) return res.status(400).json({ error: 'content is required' });
+  try {
+    const entry = MemoryManager.add(content, type || MEMORY_TYPES.FACT, tags || []);
+    res.json({ success: true, entry });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** DELETE /api/memory/:id — delete a memory */
+router.delete('/:id', (req, res) => {
+  const deleted = MemoryManager.delete(req.params.id);
+  res.json({ success: deleted });
+});
+
+/** DELETE /api/memory — clear all memories */
+router.delete('/', (req, res) => {
+  MemoryManager.clear();
+  res.json({ success: true, message: 'All memories cleared' });
+});
+
+/** GET /api/memory/types — list valid memory types */
+router.get('/types', (req, res) => {
+  res.json({ types: Object.values(MEMORY_TYPES) });
+});
+
+module.exports = router;

package/src/api/routes/newRoutes.js

@@ -0,0 +1,168 @@
+// ── skills.js ──────────────────────────────────────────────────────────────────
+const express = require('express');
+const skillsRouter = express.Router();
+const skillsManager = require('../../skills/skillsManager');
+
+skillsRouter.get('/', (req, res) => res.json({ skills: skillsManager.list(req.query) }));
+skillsRouter.post('/', (req, res) => {
+  try { res.json({ skill: skillsManager.create(req.body.name, req.body.description, req.body.prompt, req.body.tags) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+skillsRouter.post('/:name', async (req, res) => {
+  const { target, sessionId, extraContext } = req.body;
+  if (!target) return res.status(400).json({ error: 'target is required' });
+  try { res.json(await skillsManager.run(req.params.name, target, { sessionId, extraContext })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+skillsRouter.delete('/:name', (req, res) => {
+  try { res.json({ success: skillsManager.delete(req.params.name) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+module.exports.skillsRouter = skillsRouter;
+
+// ── lsp.js ─────────────────────────────────────────────────────────────────────
+const lspRouter = express.Router();
+const symbolNavigator = require('../../lsp/symbolNavigator');
+
+lspRouter.get('/definition/:symbol', async (req, res) => {
+  try { res.json(await symbolNavigator.goToDefinition(req.params.symbol, req.query.cwd)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+lspRouter.get('/references/:symbol', async (req, res) => {
+  try { res.json(await symbolNavigator.findReferences(req.params.symbol, req.query.cwd)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+lspRouter.post('/hover', async (req, res) => {
+  try { res.json(await symbolNavigator.hover(req.body.symbol, req.body.filePath, req.body.sessionId)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+lspRouter.get('/outline', async (req, res) => {
+  if (!req.query.path) return res.status(400).json({ error: 'path is required' });
+  try { res.json(await symbolNavigator.outline(req.query.path)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+lspRouter.get('/symbols', async (req, res) => {
+  if (!req.query.q) return res.status(400).json({ error: 'q is required' });
+  try { res.json(await symbolNavigator.workspaceSymbols(req.query.q, req.query.cwd)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+lspRouter.post('/rename', async (req, res) => {
+  const { oldName, newName, cwd } = req.body;
+  if (!oldName || !newName) return res.status(400).json({ error: 'oldName and newName required' });
+  try { res.json(await symbolNavigator.renameSymbol(oldName, newName, cwd)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+module.exports.lspRouter = lspRouter;
+
+// ── files.js ───────────────────────────────────────────────────────────────────
+const filesRouter = express.Router();
+const FileEditTool = require('../../tools/FileEditTool');
+
+filesRouter.get('/read', (req, res) => {
+  if (!req.query.path) return res.status(400).json({ error: 'path is required' });
+  try { res.json(FileEditTool.read(req.query.path, { startLine: req.query.startLine, endLine: req.query.endLine })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+filesRouter.post('/str-replace', async (req, res) => {
+  const { filePath, oldStr, newStr, dryRun, backup } = req.body;
+  if (!filePath || !oldStr) return res.status(400).json({ error: 'filePath and oldStr required' });
+  try { res.json(await FileEditTool.strReplace(filePath, oldStr, newStr || '', { dryRun, backup })); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+filesRouter.post('/insert-after', async (req, res) => {
+  const { filePath, afterStr, insertText, dryRun } = req.body;
+  if (!filePath || !afterStr || !insertText) return res.status(400).json({ error: 'filePath, afterStr, insertText required' });
+  try { res.json(await FileEditTool.insertAfter(filePath, afterStr, insertText, { dryRun })); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+filesRouter.post('/rewrite', async (req, res) => {
+  const { filePath, content, dryRun, backup } = req.body;
+  if (!filePath || !content) return res.status(400).json({ error: 'filePath and content required' });
+  try { res.json(await FileEditTool.rewrite(filePath, content, { dryRun, backup })); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+filesRouter.post('/ai-edit', async (req, res) => {
+  const { filePath, instruction, dryRun, sessionId } = req.body;
+  if (!filePath || !instruction) return res.status(400).json({ error: 'filePath and instruction required' });
+  try { res.json(await FileEditTool.aiEdit(filePath, instruction, { dryRun, sessionId })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+filesRouter.post('/undo', (req, res) => {
+  if (!req.body.filePath) return res.status(400).json({ error: 'filePath required' });
+  try { res.json(FileEditTool.undo(req.body.filePath)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+module.exports.filesRouter = filesRouter;
+
+// ── monitor.js ─────────────────────────────────────────────────────────────────
+const monitorRouter = express.Router();
+const { ProactiveMonitor } = require('../../monitor/proactiveMonitor');
+
+monitorRouter.get('/status', (req, res) => res.json(ProactiveMonitor.getStatus()));
+monitorRouter.get('/alerts', (req, res) => {
+  const { severity, unacknowledged, limit } = req.query;
+  res.json({ alerts: ProactiveMonitor.getAlerts({ severity, unacknowledged: unacknowledged === 'true', limit: parseInt(limit) || 50 }) });
+});
+monitorRouter.post('/run-all', async (req, res) => {
+  try { res.json({ results: await ProactiveMonitor.runAll() }); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+monitorRouter.post('/run/:checkId', async (req, res) => {
+  try { res.json(await ProactiveMonitor.runCheck(req.params.checkId)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+monitorRouter.post('/alerts/:id/acknowledge', (req, res) => {
+  try { res.json(ProactiveMonitor.acknowledge(req.params.id)); }
+  catch (e) { res.status(404).json({ error: e.message }); }
+});
+monitorRouter.post('/acknowledge-all', (req, res) => {
+  const count = ProactiveMonitor.acknowledgeAll();
+  res.json({ success: true, acknowledged: count });
+});
+monitorRouter.post('/start', (req, res) => {
+  ProactiveMonitor.start(req.body.cwd);
+  res.json({ success: true, message: 'Monitor started' });
+});
+monitorRouter.post('/stop', (req, res) => {
+  ProactiveMonitor.stop();
+  res.json({ success: true });
+});
+module.exports.monitorRouter = monitorRouter;
+
+// ── conversation.js ────────────────────────────────────────────────────────────
+const convRouter = express.Router();
+const conversationEngine = require('../../core/conversationEngine');
+
+convRouter.post('/', async (req, res) => {
+  const { message, convId, sessionId, topK } = req.body;
+  if (!message) return res.status(400).json({ error: 'message is required' });
+  try { res.json(await conversationEngine.chat(message, convId || 'default', { sessionId, topK })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+convRouter.post('/follow-up', async (req, res) => {
+  const { message, convId, sessionId } = req.body;
+  if (!message) return res.status(400).json({ error: 'message is required' });
+  try { res.json(await conversationEngine.followUp(message, convId || 'default', { sessionId })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+convRouter.get('/', (req, res) => res.json({ conversations: conversationEngine.list() }));
+convRouter.get('/:id/history', (req, res) => res.json({ history: conversationEngine.getHistory(req.params.id) }));
+convRouter.delete('/:id', (req, res) => { conversationEngine.reset(req.params.id); res.json({ success: true }); });
+module.exports.convRouter = convRouter;
+
+// ── watcher.js ─────────────────────────────────────────────────────────────────
+const watcherRouter = express.Router();
+const fileWatcher = require('../../watcher/fileWatcher');
+
+watcherRouter.get('/status', (req, res) => res.json(fileWatcher.getStatus()));
+watcherRouter.post('/watch', (req, res) => {
+  if (!req.body.path) return res.status(400).json({ error: 'path is required' });
+  try { res.json(fileWatcher.watch(req.body.path)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+watcherRouter.post('/unwatch', (req, res) => {
+  if (!req.body.path) return res.status(400).json({ error: 'path is required' });
+  res.json({ success: fileWatcher.unwatch(req.body.path) });
+});
+watcherRouter.post('/stop', (req, res) => { fileWatcher.stopAll(); res.json({ success: true }); });
+module.exports.watcherRouter = watcherRouter;

package/src/api/routes/pipelines.js

@@ -0,0 +1,41 @@
+const express = require('express');
+const router = express.Router();
+const pipelineEngine = require('../../pipelines/pipelineEngine');
+const logger = require('../../utils/logger');
+
+/** GET /api/pipelines — list all available pipelines and steps */
+router.get('/', (req, res) => {
+  res.json({
+    pipelines: pipelineEngine.getAvailablePipelines(),
+    availableSteps: pipelineEngine.getAvailableSteps(),
+  });
+});
+
+/** POST /api/pipelines/:name — run a named pipeline */
+router.post('/:name', async (req, res) => {
+  const { task, sessionId, topK, ...rest } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+
+  try {
+    const result = await pipelineEngine.run(req.params.name, { task, ...rest }, { sessionId, topK });
+    res.json(result);
+  } catch (err) {
+    logger.error(`Pipeline error: ${err.message}`);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/pipelines/custom/run — run a custom steps pipeline */
+router.post('/custom/run', async (req, res) => {
+  const { steps, task, sessionId, topK, ...rest } = req.body;
+  if (!task || !steps?.length) return res.status(400).json({ error: 'task and steps[] are required' });
+
+  try {
+    const result = await pipelineEngine.runCustom(steps, { task, ...rest }, { sessionId, topK });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/src/api/routes/planner.js

@@ -0,0 +1,54 @@
+const express = require('express');
+const router = express.Router();
+const plannerEngine = require('../../planner/plannerEngine');
+const costTracker = require('../../utils/costTracker');
+const indexer = require('../../core/indexer');
+const logger = require('../../utils/logger');
+
+/** POST /api/plan — generate an execution plan for a task */
+router.post('/', async (req, res) => {
+  const { task, sessionId } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+
+  try {
+    // Retrieve relevant context chunks for the plan
+    const context = indexer.search(task, 6);
+    const plan = await plannerEngine.generatePlan(task, context, sessionId);
+    res.json(plan);
+  } catch (err) {
+    logger.error(`Plan error: ${err.message}`);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/plan/compact — compact a conversation history */
+router.post('/compact', async (req, res) => {
+  const { messages, sessionId } = req.body;
+  if (!messages || !Array.isArray(messages)) {
+    return res.status(400).json({ error: 'messages array is required' });
+  }
+  try {
+    const result = await plannerEngine.compact(messages, sessionId);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/plan/doctor — environment health check */
+router.get('/doctor', async (req, res) => {
+  try {
+    const result = await plannerEngine.doctor();
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/cost — get cost summary */
+router.get('/cost', (req, res) => {
+  const { sessionId } = req.query;
+  res.json(costTracker.getSummary(sessionId || 'default'));
+});
+
+module.exports = router;