dev-mcp-server 0.0.2 → 1.0.0

package/src/lsp/symbolNavigator.js

@@ -0,0 +1,220 @@
+/**
+ * LSPTool — lightweight symbol navigation
+ * without requiring a full Language Server. Uses grep + indexer + AI.
+ *
+ * Provides:
+ *  - Go-to-definition: find where a symbol is defined
+ *  - Find references: find all usages of a symbol
+ *  - Hover docs: generate documentation for a symbol at a location
+ *  - Symbol outline: list all symbols in a file
+ *  - Workspace symbols: find symbols matching a query
+ */
+
+const llm = require('../utils/llmClient');
+const GrepTool = require('../tools/GrepTool');
+const store = require('../storage/store');
+const indexer = require('../core/indexer');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+const fs = require('fs');
+const path = require('path');
+
+class SymbolNavigator {
+    /**
+     * Go-to-definition: find where a symbol is defined
+     */
+    async goToDefinition(symbol, cwd = process.cwd()) {
+        logger.info(`[LSP] go-to-definition: ${symbol}`);
+
+        const definitions = await GrepTool.findDefinitions(symbol, cwd);
+
+        // Also search the indexed store for this symbol in metadata
+        const fromIndex = store.getAll()
+            .filter(doc => doc.metadata?.functions?.includes(symbol) || doc.metadata?.classes?.includes(symbol))
+            .map(doc => ({
+                file: doc.filePath,
+                lineNumber: null, // We don't store line numbers in index
+                kind: doc.metadata?.classes?.includes(symbol) ? 'class' : 'function',
+                fromIndex: true,
+            }));
+
+        const combined = [
+            ...definitions.map(d => ({ ...d, kind: this._inferKind(d.line), fromIndex: false })),
+            ...fromIndex,
+        ];
+
+        // Deduplicate by file
+        const seen = new Set();
+        const deduped = combined.filter(d => {
+            const key = d.file + (d.lineNumber || '');
+            if (seen.has(key)) return false;
+            seen.add(key);
+            return true;
+        });
+
+        return {
+            symbol,
+            definitions: deduped,
+            count: deduped.length,
+        };
+    }
+
+    /**
+     * Find all references to a symbol
+     */
+    async findReferences(symbol, cwd = process.cwd()) {
+        logger.info(`[LSP] find-references: ${symbol}`);
+
+        const usages = await GrepTool.search(symbol, { cwd, maxResults: 50, contextLines: 1 });
+        const imports = await GrepTool.findImports(symbol, cwd);
+
+        return {
+            symbol,
+            references: usages.matches.map(m => ({
+                file: m.file,
+                line: m.lineNumber,
+                text: m.line.trim(),
+                type: m.line.includes('import') || m.line.includes('require') ? 'import' : 'usage',
+            })),
+            total: usages.total,
+        };
+    }
+
+    /**
+     * Hover documentation: generate docs for a symbol using AI
+     */
+    async hover(symbol, filePath = null, sessionId = 'default') {
+        logger.info(`[LSP] hover: ${symbol}`);
+
+        // Find definition to get the actual code
+        const def = await this.goToDefinition(symbol);
+        const docs = indexer.searchForUsages(symbol, 4);
+
+        const contextParts = [];
+        if (filePath && fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8').slice(0, 3000);
+            contextParts.push(`File context:\n${content}`);
+        }
+        if (docs.length > 0) {
+            contextParts.push('Codebase context:\n' + docs.map(d => d.content.slice(0, 500)).join('\n---\n'));
+        }
+
+        const response = await llm.chat({
+            model: llm.model('fast'),
+            max_tokens: 400,
+            messages: [{
+                role: 'user',
+                content: `Generate concise hover documentation for the symbol "${symbol}".
+Include: type, purpose (1-2 sentences), parameters (if function), return value, and any gotchas.
+Format as markdown. Be brief — this is hover text, not a full doc.
+
+${contextParts.join('\n\n')}`,
+            }],
+        });
+
+        costTracker.record({
+            model: llm.model('fast'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: 'lsp-hover',
+        });
+
+        return {
+            symbol,
+            documentation: response.content[0].text,
+            definitions: def.definitions.slice(0, 3),
+        };
+    }
+
+    /**
+     * Symbol outline: list all symbols (functions, classes, exports) in a file
+     */
+    async outline(filePath) {
+        const abs = path.resolve(filePath);
+        if (!fs.existsSync(abs)) throw new Error(`File not found: ${abs}`);
+
+        const content = fs.readFileSync(abs, 'utf-8');
+        const symbols = [];
+        const lines = content.split('\n');
+
+        const patterns = [
+            { regex: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/, kind: 'function' },
+            { regex: /^(?:export\s+)?class\s+(\w+)/, kind: 'class' },
+            { regex: /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s*)?\(/, kind: 'arrow-function' },
+            { regex: /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{/, kind: 'method' },
+            { regex: /^module\.exports\s*=\s*(?:new\s+)?(\w+)/, kind: 'export' },
+            { regex: /^exports\.(\w+)\s*=/, kind: 'export' },
+        ];
+
+        lines.forEach((line, idx) => {
+            for (const { regex, kind } of patterns) {
+                const m = line.match(regex);
+                if (m && m[1] && !['if', 'for', 'while', 'catch', 'switch'].includes(m[1])) {
+                    symbols.push({ name: m[1], kind, line: idx + 1, text: line.trim().slice(0, 80) });
+                    break;
+                }
+            }
+        });
+
+        return {
+            filePath: abs,
+            filename: path.basename(abs),
+            symbols,
+            count: symbols.length,
+        };
+    }
+
+    /**
+     * Workspace symbol search: find any symbol matching a query
+     */
+    async workspaceSymbols(query, cwd = process.cwd()) {
+        const docs = indexer.search(query, 10);
+        const symbols = [];
+
+        for (const doc of docs) {
+            const meta = doc.metadata || {};
+            const allSymbols = [
+                ...(meta.functions || []).map(n => ({ name: n, kind: 'function', file: doc.filename, path: doc.filePath })),
+                ...(meta.classes || []).map(n => ({ name: n, kind: 'class', file: doc.filename, path: doc.filePath })),
+                ...(meta.exports || []).map(n => ({ name: n, kind: 'export', file: doc.filename, path: doc.filePath })),
+            ];
+            symbols.push(...allSymbols.filter(s => s.name.toLowerCase().includes(query.toLowerCase())));
+        }
+
+        // Deduplicate
+        const seen = new Set();
+        return {
+            query,
+            symbols: symbols.filter(s => {
+                const key = `${s.name}:${s.path}`;
+                if (seen.has(key)) return false;
+                seen.add(key);
+                return true;
+            }).slice(0, 30),
+        };
+    }
+
+    /**
+     * Rename symbol — suggest all places that need updating
+     */
+    async renameSymbol(oldName, newName, cwd = process.cwd()) {
+        const refs = await this.findReferences(oldName, cwd);
+        return {
+            oldName,
+            newName,
+            affectedFiles: [...new Set(refs.references.map(r => r.file))],
+            references: refs.references,
+            suggestion: `Update ${refs.references.length} occurrences across ${[...new Set(refs.references.map(r => r.file))].length} files`,
+        };
+    }
+
+    _inferKind(line = '') {
+        if (/class\s+\w/.test(line)) return 'class';
+        if (/function\s+\w/.test(line)) return 'function';
+        if (/const\s+\w+\s*=\s*(?:async\s*)?\(/.test(line)) return 'arrow-function';
+        return 'symbol';
+    }
+}
+
+module.exports = new SymbolNavigator();

package/src/memory/memoryManager.js

@@ -0,0 +1,186 @@
+/**
+ * Auto-extracts important facts from conversations and persists them.
+ * Memory is injected into future queries as additional context.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const llm = require('../utils/llmClient');
+const logger = require('../utils/logger');
+const costTracker = require('../utils/costTracker');
+
+const MEMORY_FILE = path.join(process.cwd(), 'data', 'memories.json');
+
+// Memory categories
+const MEMORY_TYPES = {
+    FACT: 'fact',           // Static facts about the codebase
+    PATTERN: 'pattern',    // Recurring patterns or conventions
+    BUG: 'bug',            // Known bugs and their fixes
+    DECISION: 'decision',  // Architecture/design decisions
+    PERSON: 'person',      // Who owns/knows what
+    PREFERENCE: 'preference', // Team preferences and conventions
+};
+
+class MemoryManager {
+    constructor() {
+        this._memories = this._load();
+    }
+
+    _load() {
+        try {
+            if (fs.existsSync(MEMORY_FILE)) {
+                return JSON.parse(fs.readFileSync(MEMORY_FILE, 'utf-8'));
+            }
+        } catch { }
+        return { entries: [], version: 1 };
+    }
+
+    _save() {
+        fs.writeFileSync(MEMORY_FILE, JSON.stringify(this._memories, null, 2));
+    }
+
+    /**
+     * Add a memory entry manually
+     */
+    add(content, type = MEMORY_TYPES.FACT, tags = []) {
+        const entry = {
+            id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+            content: content.trim(),
+            type,
+            tags,
+            createdAt: new Date().toISOString(),
+            useCount: 0,
+            lastUsedAt: null,
+        };
+        this._memories.entries.push(entry);
+        this._save();
+        logger.info(`[Memory] Added: "${content.slice(0, 80)}"`);
+        return entry;
+    }
+
+    /**
+     * Auto-extract memories from a Q&A exchange
+     */
+    async extractFromExchange(question, answer, sessionId = 'default') {
+        try {
+            const response = await llm.chat({
+                model: llm.model('fast'),
+                max_tokens: 400,
+                system: `Extract important, reusable facts from this developer Q&A exchange.
+Only extract things that would be useful context for FUTURE questions about this codebase.
+Return a JSON array of objects: [{"content": "...", "type": "fact|pattern|bug|decision|person|preference", "tags": ["tag1"]}]
+Return [] if nothing worth remembering. Be selective — only extract genuinely useful facts.
+Return ONLY the JSON array, no other text.`,
+                messages: [{
+                    role: 'user',
+                    content: `Question: ${question}\n\nAnswer: ${answer.slice(0, 1500)}`,
+                }],
+            });
+
+            costTracker.record({
+                model: llm.model('fast'),
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+                sessionId,
+                queryType: 'memory-extract',
+            });
+
+            const text = response.content[0].text.trim();
+            const extracted = JSON.parse(text.replace(/```json\n?|\n?```/g, '').trim());
+
+            if (!Array.isArray(extracted)) return [];
+
+            const added = [];
+            for (const item of extracted) {
+                if (item.content && item.content.length > 10) {
+                    const entry = this.add(item.content, item.type || MEMORY_TYPES.FACT, item.tags || []);
+                    added.push(entry);
+                }
+            }
+            return added;
+        } catch (err) {
+            logger.warn(`[Memory] Extraction failed: ${err.message}`);
+            return [];
+        }
+    }
+
+    /**
+     * Get memories relevant to a query (simple keyword match)
+     */
+    getRelevant(query, limit = 5) {
+        const q = query.toLowerCase();
+        const words = q.split(/\W+/).filter(w => w.length > 3);
+
+        const scored = this._memories.entries.map(mem => {
+            const text = (mem.content + ' ' + mem.tags.join(' ')).toLowerCase();
+            let score = 0;
+            for (const word of words) {
+                if (text.includes(word)) score += 1;
+            }
+            // Boost recent memories
+            const age = Date.now() - new Date(mem.createdAt).getTime();
+            const ageDays = age / (1000 * 60 * 60 * 24);
+            if (ageDays < 7) score += 0.5;
+            // Boost frequently used
+            score += mem.useCount * 0.1;
+            return { mem, score };
+        });
+
+        return scored
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit)
+            .map(s => {
+                s.mem.useCount++;
+                s.mem.lastUsedAt = new Date().toISOString();
+                return s.mem;
+            });
+    }
+
+    /**
+     * Format memories as context string for injection into prompts
+     */
+    formatAsContext(memories) {
+        if (!memories || memories.length === 0) return '';
+        return `## Persistent Memory (what I know about this codebase)\n` +
+            memories.map(m => `- [${m.type}] ${m.content}`).join('\n');
+    }
+
+    /**
+     * List all memories
+     */
+    list(type = null) {
+        const entries = type
+            ? this._memories.entries.filter(m => m.type === type)
+            : this._memories.entries;
+        return entries.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+    }
+
+    /**
+     * Delete a memory by ID
+     */
+    delete(id) {
+        const before = this._memories.entries.length;
+        this._memories.entries = this._memories.entries.filter(m => m.id !== id);
+        this._save();
+        return before !== this._memories.entries.length;
+    }
+
+    /**
+     * Clear all memories
+     */
+    clear() {
+        this._memories.entries = [];
+        this._save();
+    }
+
+    getStats() {
+        const byType = {};
+        for (const entry of this._memories.entries) {
+            byType[entry.type] = (byType[entry.type] || 0) + 1;
+        }
+        return { total: this._memories.entries.length, byType };
+    }
+}
+
+module.exports = { MemoryManager: new MemoryManager(), MEMORY_TYPES };

package/src/memory/teamMemory.js

@@ -0,0 +1,111 @@
+'use strict';
+/**
+ * A shared memory store that persists across all sessions and is visible
+ * to all agents. Unlike personal MemoryManager (per-session), team memory
+ * is a shared knowledge base that every agent reads from automatically.
+ *
+ * Use cases:
+ *  - Codebase-wide conventions that all agents should know
+ *  - Known bugs and their fixes
+ *  - Architecture decisions
+ *  - Onboarding facts for new developers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+
+const TEAM_MEM_FILE = path.join(process.cwd(), 'data', 'team-memory.json');
+
+class TeamMemory {
+    constructor() {
+        this._store = this._load();
+    }
+
+    _load() {
+        try { if (fs.existsSync(TEAM_MEM_FILE)) return JSON.parse(fs.readFileSync(TEAM_MEM_FILE, 'utf-8')); } catch { }
+        return { entries: {}, nextId: 1 };
+    }
+    _save() { fs.writeFileSync(TEAM_MEM_FILE, JSON.stringify(this._store, null, 2)); }
+
+    /**
+     * Add a team-wide memory entry
+     */
+    add({ team = 'global', content, type = 'fact', tags = [], author = 'system' }) {
+        if (!content) throw new Error('content required');
+        const id = `tmem_${this._store.nextId++}`;
+        const entry = { id, team, content, type, tags, author, createdAt: new Date().toISOString(), useCount: 0 };
+        if (!this._store.entries[team]) this._store.entries[team] = [];
+        this._store.entries[team].push(entry);
+        this._save();
+        logger.info(`[TeamMemory] Added to "${team}": ${content.slice(0, 60)}`);
+        return entry;
+    }
+
+    /**
+     * Get all entries for a team (or global if no team)
+     */
+    get(team = 'global', opts = {}) {
+        const { type, limit = 50 } = opts;
+        const entries = [
+            ...(this._store.entries['global'] || []),
+            ...(team !== 'global' ? (this._store.entries[team] || []) : []),
+        ];
+        const filtered = type ? entries.filter(e => e.type === type) : entries;
+        return filtered
+            .sort((a, b) => b.useCount - a.useCount || new Date(b.createdAt) - new Date(a.createdAt))
+            .slice(0, limit);
+    }
+
+    /**
+     * Search team memory by keyword
+     */
+    search(query, team = 'global') {
+        const entries = this.get(team, { limit: 200 });
+        const q = query.toLowerCase();
+        return entries
+            .filter(e => e.content.toLowerCase().includes(q) || e.tags.some(t => t.includes(q)))
+            .map(e => { e.useCount++; return e; });
+    }
+
+    /**
+     * Format team memory as a system context block for injection into agents
+     */
+    formatForAgent(team = 'global') {
+        const entries = this.get(team, { limit: 20 });
+        if (!entries.length) return '';
+        return `## Team Knowledge Base (${team})\n` +
+            entries.map(e => `- [${e.type}] ${e.content}`).join('\n');
+    }
+
+    /**
+     * List all teams
+     */
+    listTeams() {
+        return Object.keys(this._store.entries).map(team => ({
+            team,
+            count: this._store.entries[team].length,
+        }));
+    }
+
+    delete(id) {
+        for (const team of Object.keys(this._store.entries)) {
+            const before = this._store.entries[team].length;
+            this._store.entries[team] = this._store.entries[team].filter(e => e.id !== id);
+            if (this._store.entries[team].length !== before) { this._save(); return true; }
+        }
+        return false;
+    }
+
+    clearTeam(team) {
+        delete this._store.entries[team];
+        this._save();
+    }
+
+    getStats() {
+        const total = Object.values(this._store.entries).reduce((s, a) => s + a.length, 0);
+        return { total, teams: this.listTeams() };
+    }
+}
+
+module.exports = new TeamMemory();

package/src/messaging/messageBus.js

@@ -0,0 +1,177 @@
+'use strict';
+/**
+ * A lightweight in-process message bus allowing agents to communicate.
+ * Each agent has an inbox. Messages can be sent with priority levels.
+ *
+ * Used when:
+ *  - DebugAgent finds a security issue → notifies SecurityAgent
+ *  - PlannerAgent creates tasks → notifies the right specialist
+ *  - TeamCoordinator broadcasts findings to all agents
+ *  - Cron jobs need to alert about findings
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+
+const MSG_FILE = path.join(process.cwd(), 'data', 'messages.json');
+
+const PRIORITY = { LOW: 'low', NORMAL: 'normal', HIGH: 'high', URGENT: 'urgent' };
+
+class MessageBus {
+    constructor() {
+        this._store = this._load();
+        this._subscribers = new Map(); // agentName → callback[]
+    }
+
+    _load() {
+        try { if (fs.existsSync(MSG_FILE)) return JSON.parse(fs.readFileSync(MSG_FILE, 'utf-8')); } catch { }
+        return { messages: [], nextId: 1 };
+    }
+    _save() { fs.writeFileSync(MSG_FILE, JSON.stringify(this._store, null, 2)); }
+
+    /**
+     * Send a message from one agent to another
+     */
+    send({ from, to, content, priority = PRIORITY.NORMAL, metadata = {}, replyTo }) {
+        if (!from || !to || !content) throw new Error('from, to, content required');
+
+        const msg = {
+            id: this._store.nextId++,
+            from,
+            to,
+            content,
+            priority,
+            metadata,
+            replyTo: replyTo || null,
+            sentAt: new Date().toISOString(),
+            readAt: null,
+            read: false,
+        };
+
+        this._store.messages.push(msg);
+
+        // Keep last 500 messages
+        if (this._store.messages.length > 500) {
+            this._store.messages = this._store.messages.slice(-500);
+        }
+
+        this._save();
+        logger.info(`[MsgBus] ${from} → ${to}: "${content.slice(0, 60)}" [${priority}]`);
+
+        // Notify live subscribers (real-time delivery)
+        const subs = this._subscribers.get(to) || [];
+        for (const cb of subs) {
+            try { cb(msg); } catch { }
+        }
+
+        return msg;
+    }
+
+    /**
+     * Broadcast to all agents (or a list)
+     */
+    broadcast({ from, content, to: recipients, priority = PRIORITY.NORMAL, metadata = {} }) {
+        const all = recipients || ['DebugAgent', 'ArchitectureAgent', 'SecurityAgent', 'DocumentationAgent', 'RefactorAgent', 'PerformanceAgent', 'TestAgent', 'DevOpsAgent', 'DataAgent', 'PlannerAgent'];
+        return all.map(to => this.send({ from, to, content, priority, metadata }));
+    }
+
+    /**
+     * Get inbox for an agent
+     */
+    inbox(agentName, opts = {}) {
+        const { unreadOnly = false, priority, limit = 50 } = opts;
+        let msgs = this._store.messages.filter(m => m.to === agentName);
+        if (unreadOnly) msgs = msgs.filter(m => !m.read);
+        if (priority) msgs = msgs.filter(m => m.priority === priority);
+        return msgs
+            .sort((a, b) => {
+                const pOrder = { urgent: 0, high: 1, normal: 2, low: 3 };
+                return (pOrder[a.priority] ?? 2) - (pOrder[b.priority] ?? 2);
+            })
+            .slice(-limit)
+            .reverse();
+    }
+
+    /**
+     * Get all messages from a specific sender
+     */
+    sentBy(agentName, limit = 20) {
+        return this._store.messages
+            .filter(m => m.from === agentName)
+            .slice(-limit)
+            .reverse();
+    }
+
+    /**
+     * Mark a message as read
+     */
+    markRead(id) {
+        const msg = this._store.messages.find(m => m.id === id);
+        if (!msg) throw new Error(`Message ${id} not found`);
+        msg.read = true;
+        msg.readAt = new Date().toISOString();
+        this._save();
+        return msg;
+    }
+
+    markAllRead(agentName) {
+        let count = 0;
+        const now = new Date().toISOString();
+        for (const msg of this._store.messages) {
+            if (msg.to === agentName && !msg.read) {
+                msg.read = true; msg.readAt = now; count++;
+            }
+        }
+        this._save();
+        return count;
+    }
+
+    /**
+     * Reply to a message
+     */
+    reply(originalId, { from, content, priority = PRIORITY.NORMAL }) {
+        const original = this._store.messages.find(m => m.id === originalId);
+        if (!original) throw new Error(`Message ${originalId} not found`);
+        return this.send({ from, to: original.from, content, priority, replyTo: originalId });
+    }
+
+    /**
+     * Subscribe to live messages for an agent (callback-based)
+     */
+    subscribe(agentName, callback) {
+        if (!this._subscribers.has(agentName)) this._subscribers.set(agentName, []);
+        this._subscribers.get(agentName).push(callback);
+        return () => {
+            const subs = this._subscribers.get(agentName) || [];
+            this._subscribers.set(agentName, subs.filter(c => c !== callback));
+        };
+    }
+
+    delete(id) {
+        const before = this._store.messages.length;
+        this._store.messages = this._store.messages.filter(m => m.id !== id);
+        this._save();
+        return before !== this._store.messages.length;
+    }
+
+    clearInbox(agentName) {
+        this._store.messages = this._store.messages.filter(m => m.to !== agentName);
+        this._save();
+    }
+
+    getStats() {
+        const msgs = this._store.messages;
+        return {
+            total: msgs.length,
+            unread: msgs.filter(m => !m.read).length,
+            byAgent: [...new Set(msgs.map(m => m.to))].map(a => ({
+                agent: a,
+                unread: msgs.filter(m => m.to === a && !m.read).length,
+                total: msgs.filter(m => m.to === a).length,
+            })),
+        };
+    }
+}
+
+module.exports = { MessageBus: new MessageBus(), PRIORITY };