dev-mcp-server 0.0.3 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dev-mcp-server",
-    "version": "0.0.3",
+    "version": "1.0.0",
     "description": "Model Context Platform — AI that understands YOUR codebase",
     "main": "src/api/server.js",
     "type": "commonjs",
@@ -31,7 +31,7 @@
         "glob": "^10.4.1",
         "morgan": "^1.10.0",
         "natural": "^8.0.1",
-        "openai": "^4.52.0",
+        "openai": "^6.33.0",
         "ora": "^5.4.1",
         "winston": "^3.13.0"
     },

package/src/agents/BaseAgent.js

@@ -0,0 +1,113 @@
+
+'use strict';
+/**
+ * Foundation for all agents — tool-use loop, memory injection, cost tracking.
+ * Provider-agnostic: uses llmClient which routes to Anthropic / Azure / Ollama.
+ */
+
+const llm = require('../utils/llmClient');
+const toolRegistry = require('../tools/registry');
+const contextEngineer = require('../context/contextEngineer');
+const { MemoryManager } = require('../memory/memoryManager');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+
+class BaseAgent {
+    constructor(cfg = {}) {
+        this.name = cfg.name || 'Agent';
+        this.role = cfg.role || 'General assistant';
+        this.model = cfg.model || 'smart';   // alias: fast | default | smart
+        this.toolNames = cfg.toolNames || [];
+        this.maxTokens = cfg.maxTokens || 2000;
+        this.maxLoops = cfg.maxLoops || 8;
+        this.sessionId = cfg.sessionId || `agent_${this.name.toLowerCase()}`;
+
+        this._history = [];
+        this._callCount = 0;
+        this._tokenCount = 0;
+    }
+
+    async run(task, opts = {}) {
+        const { context = [], extraSystem = '' } = opts;
+
+        const engineered = contextEngineer.engineer(context, task, opts.mode || 'general');
+        const memories = MemoryManager.getRelevant(task, 4);
+        const memContext = MemoryManager.formatAsContext(memories);
+        const systemPrompt = this._buildSystem(memContext, extraSystem);
+        const userMessage = this._buildUserMessage(task, engineered.chunks);
+
+        const history = [];
+        history.push({ role: 'user', content: userMessage });
+
+        logger.info(`[${this.name}] task="${task.slice(0, 60)}" tools=${this.toolNames.length} ctx=${engineered.chunks.length} provider=${llm.provider}`);
+
+        const toolSchemas = llm.supportsTools() && this.toolNames.length
+            ? toolRegistry.schemas(this.toolNames)
+            : [];
+
+        const toolResults = [];
+        let loops = 0;
+        let response;
+
+        while (loops < this.maxLoops) {
+            loops++;
+
+            response = await llm.chat({
+                model: this.model,
+                system: systemPrompt,
+                messages: history,
+                max_tokens: this.maxTokens,
+                tools: toolSchemas.length ? toolSchemas : undefined,
+            });
+
+            this._callCount++;
+            this._tokenCount += (response.usage.input_tokens + response.usage.output_tokens);
+            costTracker.record({
+                model: llm.model(this.model),
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+                sessionId: opts.sessionId || this.sessionId,
+                queryType: `agent_${this.name.toLowerCase()}`,
+            });
+
+            if (response.stop_reason !== 'tool_use') break;
+
+            const toolUseBlocks = response.content.filter(b => b.type === 'tool_use');
+            if (!toolUseBlocks.length) break;
+
+            history.push({ role: 'assistant', content: response.content });
+
+            const toolResultContent = [];
+            for (const tu of toolUseBlocks) {
+                logger.info(`[${this.name}] → tool: ${tu.name}(${JSON.stringify(tu.input).slice(0, 80)})`);
+                const output = await toolRegistry.execute(tu.name, tu.input);
+                toolResults.push({ tool: tu.name, input: tu.input, output: output.slice(0, 500) });
+                toolResultContent.push({ type: 'tool_result', tool_use_id: tu.id, content: output });
+            }
+            history.push({ role: 'user', content: toolResultContent });
+        }
+
+        const answer = (response?.content || [])
+            .filter(b => b.type === 'text').map(b => b.text).join('\n').trim();
+
+        MemoryManager.extractFromExchange(task, answer, opts.sessionId || this.sessionId).catch(() => { });
+
+        return { agent: this.name, answer, toolResults, loops, contextChunks: engineered.chunks.length, memoriesUsed: memories.length };
+    }
+
+    reset() { this._history = []; }
+    getStats() { return { name: this.name, calls: this._callCount, tokens: this._tokenCount, historyLen: this._history.length }; }
+
+    _buildSystem(memContext, extra) {
+        return [`You are ${this.name}. ${this.role}`, `Ground every statement in evidence from tools or provided context.`, extra || '', memContext || ''].filter(Boolean).join('\n\n');
+    }
+
+    _buildUserMessage(task, chunks) {
+        const ctx = chunks.length
+            ? '\n\n## Codebase Context\n' + chunks.map((c, i) => `[${i + 1}] **${c.filename}** (${c.kind})\n\`\`\`\n${c.content.slice(0, 700)}\n\`\`\``).join('\n\n')
+            : '';
+        return `## Task\n${task}${ctx}`;
+    }
+}
+
+module.exports = BaseAgent;

package/src/agents/dreamer.js

@@ -0,0 +1,165 @@
+'use strict';
+/**
+ * Background cognitive agent. Runs on a timer.
+ * Five phases per dream cycle:
+ *   1. Consolidate memories (merge duplicates, resolve contradictions)
+ *   2. Pattern discovery (scan codebase for architectural patterns)
+ *   3. Proactive suggestions (surface improvements nobody asked for)
+ *   4. Knowledge graph building (connect related facts)
+ *   5. Pruning (remove stale/low-quality memories)
+ */
+
+const llm = require('../utils/llmClient');
+const fs = require('fs');
+const path = require('path');
+const { MemoryManager, MEMORY_TYPES } = require('../memory/memoryManager');
+const store = require('../storage/store');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+
+const LOG_FILE = path.join(process.cwd(), 'data', 'dream-log.json');
+
+class Dreamer {
+    constructor() {
+        this._running = false;
+        this._handle = null;
+        this._count = 0;
+        this._log = this._loadLog();
+    }
+
+    _loadLog() {
+        try { if (fs.existsSync(LOG_FILE)) return JSON.parse(fs.readFileSync(LOG_FILE, 'utf-8')); } catch { }
+        return { dreams: [], lastDream: null };
+    }
+    _saveLog() { fs.writeFileSync(LOG_FILE, JSON.stringify(this._log, null, 2)); }
+
+    start(intervalMinutes = 30) {
+        if (this._running) return;
+        this._running = true;
+        logger.info(`[Dreamer] 💤 Started (every ${intervalMinutes}min)`);
+        setTimeout(() => this.dream(), 15000);
+        this._handle = setInterval(() => this.dream(), intervalMinutes * 60000);
+    }
+
+    stop() {
+        if (this._handle) clearInterval(this._handle);
+        this._running = false;
+    }
+
+    async dream() {
+        const t0 = Date.now();
+        this._count++;
+        logger.info(`[Dreamer] 💭 Dream #${this._count} starting...`);
+
+        const phases = {};
+        try { phases.consolidate = await this._consolidate(); } catch (e) { logger.warn(`[Dreamer] consolidate: ${e.message}`); }
+        try { phases.patterns = await this._discoverPatterns(); } catch (e) { logger.warn(`[Dreamer] patterns: ${e.message}`); }
+        try { phases.suggestions = await this._proactiveSuggestions(); } catch (e) { logger.warn(`[Dreamer] suggestions: ${e.message}`); }
+        try { phases.graph = await this._buildKnowledgeGraph(); } catch (e) { logger.warn(`[Dreamer] graph: ${e.message}`); }
+        phases.pruned = this._prune();
+
+        const record = {
+            id: this._count, ts: new Date().toISOString(),
+            ms: Date.now() - t0,
+            insights: (phases.patterns?.length || 0) + (phases.suggestions?.length || 0) + (phases.consolidate?.length || 0),
+            pruned: phases.pruned, phases: Object.keys(phases),
+        };
+        this._log.dreams.push(record);
+        this._log.lastDream = record.ts;
+        if (this._log.dreams.length > 50) this._log.dreams = this._log.dreams.slice(-50);
+        this._saveLog();
+        logger.info(`[Dreamer] ✨ Dream #${this._count} done: ${record.insights} insights, ${record.pruned} pruned in ${record.ms}ms`);
+        return record;
+    }
+
+    // Phase 1 — consolidate duplicate / contradicting memories
+    async _consolidate() {
+        const mems = MemoryManager.list();
+        if (mems.length < 6) return [];
+        const byType = {};
+        for (const m of mems) (byType[m.type] = byType[m.type] || []).push(m);
+        const merged = [];
+        for (const [type, group] of Object.entries(byType)) {
+            if (group.length < 3) continue;
+            const snippet = group.slice(0, 8).map((m, i) => `[${i}] ${m.content}`).join('\n');
+            const r = await this._ask(`These are "${type}" memories. Find duplicates or contradictions worth merging/removing.\nReturn JSON: [{"action":"merge|remove","indices":[0,1],"merged":"new text if merging"}]. Return [] if nothing to do.\n${snippet}`);
+            const actions = this._parseJSON(r, []);
+            for (const a of actions) {
+                if (a.action === 'merge' && a.merged) {
+                    for (const i of a.indices) { if (group[i]) MemoryManager.delete(group[i].id); }
+                    merged.push(MemoryManager.add(a.merged, type, ['dream-consolidated']));
+                } else if (a.action === 'remove') {
+                    for (const i of a.indices) { if (group[i]) MemoryManager.delete(group[i].id); }
+                }
+            }
+        }
+        return merged;
+    }
+
+    // Phase 2 — discover architectural / code patterns
+    async _discoverPatterns() {
+        const docs = store.getAll().filter(d => d.kind === 'code').slice(0, 20);
+        if (docs.length < 3) return [];
+        const sample = docs.map(d => `// ${d.filename}\n${d.content.slice(0, 250)}`).join('\n\n---\n\n');
+        const r = await this._ask(`Analyse these code samples. Find 2-3 important patterns (conventions, risks, anti-patterns).\nReturn JSON: [{"pattern":"...","type":"pattern|fact|decision","importance":"high|med|low"}]\nReturn [] if nothing notable.\n${sample}`);
+        const patterns = this._parseJSON(r, []);
+        const added = [];
+        for (const p of patterns.filter(p => p.pattern && p.importance !== 'low')) {
+            const exists = MemoryManager.getRelevant(p.pattern, 1);
+            if (!exists.length) added.push(MemoryManager.add(p.pattern, p.type || 'pattern', ['dream-pattern']));
+        }
+        return added;
+    }
+
+    // Phase 3 — proactive suggestions nobody asked for
+    async _proactiveSuggestions() {
+        const recent = MemoryManager.list().filter(m => !m.tags?.includes('dream-')).sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)).slice(0, 12);
+        if (recent.length < 4) return [];
+        const summary = recent.map(m => m.content.slice(0, 80)).join('\n');
+        const r = await this._ask(`Based on recent developer activity, generate 1-2 proactive improvements NOT yet mentioned.\nReturn JSON: [{"suggestion":"...","rationale":"...","priority":"high|med"}]\nReturn [] if nothing to add.\nRecent activity:\n${summary}`);
+        const sug = this._parseJSON(r, []);
+        return sug.filter(s => s.suggestion && s.priority !== 'low')
+            .map(s => MemoryManager.add(`[Proactive] ${s.suggestion} — ${s.rationale}`, MEMORY_TYPES.DECISION, ['dream-suggestion', s.priority]));
+    }
+
+    // Phase 4 — build connections between related memories
+    async _buildKnowledgeGraph() {
+        const mems = MemoryManager.list().slice(0, 20);
+        if (mems.length < 5) return [];
+        const list = mems.map((m, i) => `[${i}] (${m.type}) ${m.content.slice(0, 70)}`).join('\n');
+        const r = await this._ask(`Find 2-3 non-obvious connections between these facts that would help a developer.\nReturn JSON: [{"connection":"...","indices":[0,1]}]\nReturn [].\n${list}`);
+        const links = this._parseJSON(r, []);
+        return links.filter(l => l.connection)
+            .map(l => MemoryManager.add(`[Connection] ${l.connection}`, MEMORY_TYPES.PATTERN, ['dream-graph']));
+    }
+
+    // Phase 5 — prune stale/low-quality memories
+    _prune() {
+        const mems = MemoryManager.list();
+        let pruned = 0;
+        for (const m of mems) {
+            const ageDays = (Date.now() - new Date(m.createdAt).getTime()) / 86400000;
+            const stale = ageDays > 30 && m.useCount === 0;
+            const short = m.content.length < 12;
+            const oldAuto = m.tags?.includes('dream-') && ageDays > 14 && m.useCount === 0;
+            if (stale || short || oldAuto) { MemoryManager.delete(m.id); pruned++; }
+        }
+        if (pruned) logger.info(`[Dreamer] Pruned ${pruned} stale memories`);
+        return pruned;
+    }
+
+    async _ask(prompt) {
+        const r = await llm.chat({ model: llm.model('fast'), max_tokens: 400, messages: [{ role: 'user', content: prompt }] });
+        costTracker.record({ model: llm.model('fast'), inputTokens: r.usage.input_tokens, outputTokens: r.usage.output_tokens, sessionId: 'dreamer', queryType: 'dream' });
+        return r.content[0].text;
+    }
+
+    _parseJSON(text, fallback) {
+        try { return JSON.parse(text.replace(/```json\n?|\n?```/g, '').trim()); } catch { return fallback; }
+    }
+
+    async dreamNow() { return this.dream(); }
+    getStatus() { return { running: this._running, count: this._count, lastDream: this._log.lastDream, recent: this._log.dreams.slice(-5) }; }
+}
+
+module.exports = new Dreamer();

package/src/agents/improver.js

@@ -0,0 +1,175 @@
+/**
+ * Continuous improvement without explicit prompts.
+ * Tracks which answers were helpful, learns from patterns in queries,
+ * and adapts retrieval weights over time.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+const { MemoryManager } = require('../memory/memoryManager');
+
+const FEEDBACK_FILE = path.join(process.cwd(), 'data', 'feedback.json');
+const QUERY_STATS_FILE = path.join(process.cwd(), 'data', 'query-stats.json');
+
+class Improver {
+    constructor() {
+        this._feedback = this._load(FEEDBACK_FILE, { entries: [], stats: {} });
+        this._queryStats = this._load(QUERY_STATS_FILE, {
+            totalQueries: 0,
+            byMode: {},
+            commonTerms: {},
+            sourceEffectiveness: {}, // filePath → helpfulness score
+            retrieval: { avgChunks: 0, avgScore: 0 },
+        });
+    }
+
+    _load(file, def) {
+        try { if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf-8')); } catch { }
+        return def;
+    }
+    _save(file, data) { fs.writeFileSync(file, JSON.stringify(data, null, 2)); }
+
+    /**
+     * Record feedback on an answer (thumbs up/down + optional text)
+     */
+    recordFeedback(queryId, rating, comment = '') {
+        const entry = {
+            queryId,
+            rating,        // 1 = helpful, -1 = not helpful, 0 = neutral
+            comment,
+            timestamp: new Date().toISOString(),
+        };
+        this._feedback.entries.push(entry);
+
+        // Update stats
+        this._feedback.stats.total = (this._feedback.stats.total || 0) + 1;
+        this._feedback.stats.positive = (this._feedback.stats.positive || 0) + (rating > 0 ? 1 : 0);
+        this._feedback.stats.negative = (this._feedback.stats.negative || 0) + (rating < 0 ? 1 : 0);
+
+        this._save(FEEDBACK_FILE, this._feedback);
+        logger.info(`[Improver] Feedback recorded: ${rating > 0 ? '👍' : rating < 0 ? '👎' : '😐'} for ${queryId}`);
+
+        // Trigger learning if we have enough feedback
+        if (this._feedback.entries.length % 10 === 0) {
+            this._learnFromFeedback().catch(() => { });
+        }
+
+        return entry;
+    }
+
+    /**
+     * Record a query event for pattern learning
+     */
+    recordQuery({ queryId, question, mode, sources, answer, durationMs }) {
+        this._queryStats.totalQueries++;
+
+        // Track mode frequency
+        this._queryStats.byMode[mode] = (this._queryStats.byMode[mode] || 0) + 1;
+
+        // Track term frequency (for improving retrieval)
+        const terms = question.toLowerCase().split(/\W+/).filter(t => t.length > 3);
+        for (const term of terms) {
+            this._queryStats.commonTerms[term] = (this._queryStats.commonTerms[term] || 0) + 1;
+        }
+
+        // Track which sources are frequently retrieved (= probably important files)
+        if (sources) {
+            for (const src of sources) {
+                if (!this._queryStats.sourceEffectiveness[src.path]) {
+                    this._queryStats.sourceEffectiveness[src.path] = { retrievals: 0, helpfulCount: 0 };
+                }
+                this._queryStats.sourceEffectiveness[src.path].retrievals++;
+            }
+        }
+
+        // Running average for chunk stats
+        const n = this._queryStats.totalQueries;
+        const srcCount = sources?.length || 0;
+        this._queryStats.retrieval.avgChunks =
+            ((this._queryStats.retrieval.avgChunks * (n - 1)) + srcCount) / n;
+
+        this._save(QUERY_STATS_FILE, this._queryStats);
+    }
+
+    /**
+     * Get the most frequently retrieved (therefore most important) files
+     * Used to boost their ingestion priority
+     */
+    getHotFiles(limit = 10) {
+        return Object.entries(this._queryStats.sourceEffectiveness)
+            .sort(([, a], [, b]) => b.retrievals - a.retrievals)
+            .slice(0, limit)
+            .map(([path, stats]) => ({ path, ...stats }));
+    }
+
+    /**
+     * Get the most common query terms — useful for seeing what devs struggle with
+     */
+    getTopTerms(limit = 20) {
+        return Object.entries(this._queryStats.commonTerms)
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, limit)
+            .map(([term, count]) => ({ term, count }));
+    }
+
+    /**
+     * Learn from accumulated feedback — update memory weights and system config
+     */
+    async _learnFromFeedback() {
+        const recent = this._feedback.entries.slice(-20);
+        const negatives = recent.filter(e => e.rating < 0);
+
+        if (negatives.length < 3) return;
+
+        logger.info(`[Improver] Learning from ${negatives.length} negative feedbacks`);
+
+        // Add a memory about what kinds of answers aren't working
+        if (negatives.length >= 3) {
+            const comments = negatives
+                .filter(e => e.comment)
+                .map(e => e.comment)
+                .join('; ');
+
+            if (comments) {
+                MemoryManager.add(
+                    `Improvement needed: users found answers unhelpful in these areas: ${comments}`,
+                    'preference',
+                    ['improver-feedback']
+                );
+            }
+        }
+    }
+
+    /**
+     * Get a dashboard summary of system health & improvement metrics
+     */
+    getSummary() {
+        const total = this._feedback.stats.total || 0;
+        const positive = this._feedback.stats.positive || 0;
+        const negative = this._feedback.stats.negative || 0;
+        const satisfactionRate = total > 0 ? ((positive / total) * 100).toFixed(1) : 'N/A';
+
+        return {
+            queries: {
+                total: this._queryStats.totalQueries,
+                byMode: this._queryStats.byMode,
+                avgContextChunks: this._queryStats.retrieval.avgChunks.toFixed(1),
+            },
+            feedback: {
+                total,
+                positive,
+                negative,
+                satisfactionRate: total > 0 ? `${satisfactionRate}%` : 'No feedback yet',
+            },
+            topTerms: this.getTopTerms(10),
+            hotFiles: this.getHotFiles(5),
+        };
+    }
+
+    getFeedbackStats() {
+        return this._feedback.stats;
+    }
+}
+
+module.exports = new Improver();

package/src/agents/specialists.js

@@ -0,0 +1,202 @@
+'use strict';
+/**
+ * 10 specialist agents, each with a curated toolset and domain-expert system prompt.
+ * Built on BaseAgent's real Anthropic tool-use loop.
+ */
+
+const BaseAgent = require('./BaseAgent');
+
+// ─────────────────────────────────────────────────────────────────────────────
+class DebugAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'DebugAgent',
+            role: 'Expert debugger. Finds exact root causes, traces execution flows, provides verified fixes.',
+            toolNames: ['bash', 'file_read', 'grep', 'kb_search', 'memory_search', 'git_diff', 'log_analyze', 'symbol_navigate', 'think', 'token_count'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are DebugAgent, a world-class debugger.`,
+            `PROCESS: 1) think() first 2) kb_search + grep to find relevant code 3) trace the exact flow 4) pinpoint root cause 5) provide fix with code`,
+            `Never guess. Cite exact file:line. Format: Root Cause → Affected Flow → Fix → Verify`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class ArchitectureAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'ArchitectureAgent',
+            role: 'System design expert. Analyses module relationships, coupling, and recommends structural improvements.',
+            toolNames: ['file_read', 'dir_list', 'grep', 'kb_search', 'find_files', 'symbol_navigate', 'generate_diagram', 'code_complexity', 'dependency_analysis', 'think'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are ArchitectureAgent, a senior system architect.`,
+            `Analyse: module coupling, separation of concerns, scalability, testability, maintainability.`,
+            `Use generate_diagram to produce Mermaid diagrams. Use dependency_analysis for deps.`,
+            `Format: ## Current Structure → ## Coupling Issues → ## Diagram → ## Recommendations → ## Migration Path`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class SecurityAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'SecurityAgent',
+            role: 'Security auditor. Finds vulnerabilities, injection risks, auth flaws, and insecure patterns.',
+            toolNames: ['bash', 'file_read', 'grep', 'kb_search', 'api_test', 'env_read', 'regex_test', 'log_analyze', 'think', 'memory_search'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are SecurityAgent, an OWASP-certified security auditor.`,
+            `Scan for: SQLi, NoSQLi, XSS, CSRF, IDOR, path traversal, hardcoded secrets, weak auth, insecure deserialization, RCE vectors.`,
+            `Use grep to find patterns. Use env_read to check secret handling.`,
+            `For each finding: CRITICAL/HIGH/MEDIUM/LOW | File:Line | Exploit scenario | Fix code`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class DocumentationAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'DocumentationAgent',
+            role: 'Technical writer. Generates accurate JSDoc, READMEs, API docs, and architecture diagrams.',
+            toolNames: ['file_read', 'kb_search', 'symbol_navigate', 'grep', 'generate_diagram', 'generate_changelog', 'find_files', 'memory_search', 'think'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are DocumentationAgent, a technical writer.`,
+            `Generate documentation that is: accurate (from real code), concise (no padding), developer-first.`,
+            `For functions: JSDoc @param @returns @throws @example. For APIs: method/endpoint/schema/errors/curl.`,
+            `Use generate_diagram for architecture diagrams. Only document what you can verify in code.`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class RefactorAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'RefactorAgent',
+            role: 'Code quality engineer. Eliminates duplication, improves readability, applies modern patterns.',
+            toolNames: ['file_read', 'file_edit', 'grep', 'kb_search', 'code_complexity', 'lint', 'format_code', 'symbol_navigate', 'think', 'text_diff'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are RefactorAgent, a code quality expert.`,
+            `Use code_complexity + lint to find issues. Use grep to find duplication.`,
+            `Show before/after diffs. Explain WHY each change improves the code.`,
+            `Never change behaviour — only structure, readability, maintainability.`,
+            `Format: ## Issues Found → ## Refactored Code → ## What Changed & Why`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class PerformanceAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'PerformanceAgent',
+            role: 'Performance engineer. Finds N+1 queries, memory leaks, blocking I/O, and bottlenecks.',
+            toolNames: ['file_read', 'grep', 'kb_search', 'code_complexity', 'log_analyze', 'system_info', 'run_tests', 'bash', 'think', 'memory_search'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are PerformanceAgent, a performance engineering specialist.`,
+            `Hunt for: N+1 DB queries, sync ops that should be async, unnecessary data loading, memory leaks, blocking I/O.`,
+            `Use log_analyze to find slow queries. Use system_info for runtime metrics.`,
+            `For each issue: impact (HIGH/MED/LOW) | root cause | specific fix with code | expected gain`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class TestAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'TestAgent',
+            role: 'QA engineer. Writes tests, runs test suites, analyses coverage, finds untested code paths.',
+            toolNames: ['file_read', 'file_write', 'run_tests', 'grep', 'kb_search', 'mock_generate', 'code_complexity', 'find_files', 'symbol_navigate', 'think'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are TestAgent, an expert QA engineer.`,
+            `Use run_tests to check current state. Use grep to find untested code. Use mock_generate for fixtures.`,
+            `Write tests that are: deterministic, isolated, fast, readable.`,
+            `Generate Jest tests. Cover: happy path, edge cases (null/empty/boundary), error cases, mocked deps.`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class DevOpsAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'DevOpsAgent',
+            role: 'DevOps engineer. Manages CI/CD, Docker, deployments, infrastructure, and environment config.',
+            toolNames: ['bash', 'docker', 'system_info', 'process_info', 'network_check', 'env_read', 'npm_info', 'log_analyze', 'file_read', 'git_status'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are DevOpsAgent, a DevOps/SRE engineer.`,
+            `Use docker for container management. Use system_info for resource monitoring.`,
+            `Diagnose infrastructure issues. Suggest CI/CD improvements. Review Dockerfiles and config.`,
+            `Format: ## Current State → ## Issues → ## Fixes → ## Prevention`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class DataAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'DataAgent',
+            role: 'Data engineer. Analyses data structures, queries, schemas, and data pipelines.',
+            toolNames: ['file_read', 'json_query', 'json_transform', 'schema_validate', 'grep', 'kb_search', 'regex_test', 'crypto_hash', 'mock_generate', 'think'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are DataAgent, a data engineering specialist.`,
+            `Analyse: data models, JSON structures, API payloads, DB schemas, transformations.`,
+            `Use json_query + json_transform to explore data. Use schema_validate to check contracts.`,
+            `Spot: missing validation, unsafe transformations, data inconsistencies, schema drift.`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+class PlannerAgent extends BaseAgent {
+    constructor() {
+        super({
+            name: 'PlannerAgent',
+            role: 'Project planner. Breaks down complex tasks, estimates effort, identifies risks and dependencies.',
+            toolNames: ['kb_search', 'memory_search', 'task_manage', 'git_log', 'grep', 'symbol_navigate', 'generate_diagram', 'think', 'token_count', 'dependency_analysis'],
+        });
+    }
+    _buildSystem(m, e) {
+        return [`You are PlannerAgent, an expert project planner.`,
+            `Use task_manage to track action items. Use kb_search to understand the codebase before planning.`,
+            `Produce: numbered steps, effort estimate, dependencies, risk rating, rollback strategy.`,
+            `Format: ## Understanding → ## Plan (numbered) → ## Dependencies → ## Risks → ## Rollback`,
+            m, e].filter(Boolean).join('\n\n');
+    }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+module.exports = {
+    DebugAgent: new DebugAgent(),
+    ArchitectureAgent: new ArchitectureAgent(),
+    SecurityAgent: new SecurityAgent(),
+    DocumentationAgent: new DocumentationAgent(),
+    RefactorAgent: new RefactorAgent(),
+    PerformanceAgent: new PerformanceAgent(),
+    TestAgent: new TestAgent(),
+    DevOpsAgent: new DevOpsAgent(),
+    DataAgent: new DataAgent(),
+    PlannerAgent: new PlannerAgent(),
+};