dev-mcp-server 0.0.2 → 1.0.0

package/src/sessions/sessionManager.js

@@ -0,0 +1,166 @@
+/**
+ * Saves full conversation history and context so sessions can be resumed later.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+
+const SESSIONS_DIR = path.join(process.cwd(), 'data', 'sessions');
+
+class SessionManager {
+    constructor() {
+        this._ensureDir();
+        this._active = new Map(); // sessionId -> { messages, meta }
+    }
+
+    _ensureDir() {
+        if (!fs.existsSync(SESSIONS_DIR)) fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    }
+
+    _sessionFile(id) {
+        return path.join(SESSIONS_DIR, `${id}.json`);
+    }
+
+    /**
+     * Create a new session
+     */
+    create(options = {}) {
+        const { name = null, context = {} } = options;
+        const id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        const session = {
+            id,
+            name: name || `Session ${new Date().toLocaleString()}`,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            messages: [],          // { role, content, mode, sources, timestamp }
+            context,               // metadata about what was ingested, etc.
+            stats: { queries: 0, totalTokens: 0, totalCostUsd: 0 },
+        };
+        this._active.set(id, session);
+        this._save(session);
+        logger.info(`[Session] Created: ${id} "${session.name}"`);
+        return session;
+    }
+
+    /**
+     * Add a message to a session
+     */
+    addMessage(sessionId, message) {
+        const session = this._getOrLoad(sessionId);
+        if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+        session.messages.push({
+            ...message,
+            timestamp: new Date().toISOString(),
+        });
+        session.stats.queries++;
+        if (message.tokens) session.stats.totalTokens += message.tokens;
+        if (message.costUsd) session.stats.totalCostUsd += message.costUsd;
+        session.updatedAt = new Date().toISOString();
+
+        this._save(session);
+        return session;
+    }
+
+    /**
+     * Get conversation history for a session (for context compaction)
+     */
+    getHistory(sessionId, limit = 20) {
+        const session = this._getOrLoad(sessionId);
+        if (!session) return [];
+        return session.messages.slice(-limit);
+    }
+
+    /**
+     * Resume a session — returns session + last N messages
+     */
+    resume(sessionId) {
+        const session = this._getOrLoad(sessionId);
+        if (!session) throw new Error(`Session not found: ${sessionId}`);
+        logger.info(`[Session] Resumed: ${sessionId}`);
+        return {
+            ...session,
+            resumedAt: new Date().toISOString(),
+        };
+    }
+
+    /**
+     * List all saved sessions
+     */
+    list() {
+        this._ensureDir();
+        const files = fs.readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.json'));
+        return files.map(f => {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), 'utf-8'));
+                return {
+                    id: data.id,
+                    name: data.name,
+                    createdAt: data.createdAt,
+                    updatedAt: data.updatedAt,
+                    messageCount: data.messages?.length || 0,
+                    stats: data.stats,
+                };
+            } catch { return null; }
+        }).filter(Boolean).sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    }
+
+    /**
+     * Delete a session
+     */
+    delete(sessionId) {
+        this._active.delete(sessionId);
+        const file = this._sessionFile(sessionId);
+        if (fs.existsSync(file)) {
+            fs.unlinkSync(file);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Export a session as markdown (for sharing)
+     */
+    exportMarkdown(sessionId) {
+        const session = this._getOrLoad(sessionId);
+        if (!session) throw new Error(`Session not found: ${sessionId}`);
+
+        const lines = [
+            `# Session: ${session.name}`,
+            `> Created: ${session.createdAt} | Queries: ${session.stats.queries}`,
+            '',
+        ];
+
+        for (const msg of session.messages) {
+            const role = msg.role === 'user' ? '**You**' : '**MCP**';
+            const mode = msg.mode ? ` _(${msg.mode})_` : '';
+            lines.push(`### ${role}${mode}`);
+            lines.push(msg.content);
+            if (msg.sources?.length) {
+                lines.push('');
+                lines.push(`*Sources: ${msg.sources.map(s => s.file).join(', ')}*`);
+            }
+            lines.push('');
+        }
+
+        return lines.join('\n');
+    }
+
+    _getOrLoad(id) {
+        if (this._active.has(id)) return this._active.get(id);
+        const file = this._sessionFile(id);
+        if (!fs.existsSync(file)) return null;
+        try {
+            const session = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            this._active.set(id, session);
+            return session;
+        } catch { return null; }
+    }
+
+    _save(session) {
+        fs.writeFileSync(this._sessionFile(session.id), JSON.stringify(session, null, 2));
+    }
+}
+
+module.exports = new SessionManager();

package/src/skills/skillsManager.js

@@ -0,0 +1,263 @@
+/**
+ * Skills are named, reusable prompt templates / workflows that users define once
+ * and reuse across queries. They can reference placeholders {target}, {context}, etc.
+ *
+ * Examples:
+ *   /skill run add-error-handling UserService.js
+ *   /skill run document-function getUserById
+ *   /skill run check-security AuthController.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const llm = require('../utils/llmClient');
+const logger = require('../utils/logger');
+const costTracker = require('../utils/costTracker');
+const { MemoryManager } = require('../memory/memoryManager');
+const indexer = require('../core/indexer');
+
+const SKILLS_FILE = path.join(process.cwd(), 'data', 'skills.json');
+
+// ── Built-in skills (ship with the system) ─────────────────────────────────────
+const BUILTIN_SKILLS = {
+    'add-error-handling': {
+        name: 'add-error-handling',
+        description: 'Add proper try/catch error handling to a function or file',
+        prompt: `Analyse {target} in the codebase and add proper error handling:
+- Wrap async operations in try/catch
+- Log errors with context (function name, input params)
+- Return/throw appropriate error types
+- Don't swallow errors silently
+Show the exact changes needed as a diff.`,
+        tags: ['code-quality', 'builtin'],
+        builtIn: true,
+    },
+    'document-function': {
+        name: 'document-function',
+        description: 'Generate JSDoc documentation for a function or module',
+        prompt: `Generate complete JSDoc documentation for {target}:
+- @description — what it does
+- @param — each parameter with type and description
+- @returns — return type and description
+- @throws — errors it can throw
+- @example — a realistic usage example
+Base everything on the actual code, not assumptions.`,
+        tags: ['documentation', 'builtin'],
+        builtIn: true,
+    },
+    'check-security': {
+        name: 'check-security',
+        description: 'Security audit of a specific file or function',
+        prompt: `Perform a targeted security audit of {target}:
+1. Input validation — are all inputs sanitized?
+2. Auth checks — are endpoints/methods properly protected?
+3. SQL/NoSQL injection — are queries parameterized?
+4. Sensitive data — are secrets/tokens handled safely?
+5. Error messages — do they leak internal details?
+Rate each finding CRITICAL / HIGH / MEDIUM / LOW. Provide exact fixes.`,
+        tags: ['security', 'builtin'],
+        builtIn: true,
+    },
+    'explain-flow': {
+        name: 'explain-flow',
+        description: 'Explain the execution flow through a function or module',
+        prompt: `Trace and explain the complete execution flow of {target}:
+1. Entry point and inputs
+2. Step-by-step what happens (include function calls, DB calls, external calls)
+3. All possible exit paths (happy path, errors, edge cases)
+4. Side effects (what state is changed, what events are emitted)
+Use numbered steps. Reference actual file/function names from the codebase.`,
+        tags: ['understanding', 'builtin'],
+        builtIn: true,
+    },
+    'find-similar': {
+        name: 'find-similar',
+        description: 'Find similar patterns or duplicated logic in the codebase',
+        prompt: `Find all code in the codebase that is similar to or duplicates {target}:
+- Functions with the same purpose implemented differently
+- Copy-pasted blocks with minor variations
+- Patterns that should be extracted into a shared utility
+List each occurrence with file name and line reference.
+Suggest how to consolidate them.`,
+        tags: ['refactoring', 'builtin'],
+        builtIn: true,
+    },
+    'write-tests': {
+        name: 'write-tests',
+        description: 'Generate unit test cases for a function',
+        prompt: `Write comprehensive unit tests for {target}:
+- Happy path test cases
+- Edge cases (null/undefined inputs, empty arrays, boundary values)
+- Error cases (what should throw or return error)
+- Mock external dependencies (DB, APIs, cache)
+Use Jest syntax. Base tests on the ACTUAL behaviour in the code, not assumptions.`,
+        tags: ['testing', 'builtin'],
+        builtIn: true,
+    },
+    'performance-audit': {
+        name: 'performance-audit',
+        description: 'Find performance issues in a specific file or function',
+        prompt: `Audit {target} for performance issues:
+- N+1 database queries (calling DB inside a loop)
+- Missing async/await (synchronous blocking operations)
+- Unnecessary data loading (fetching more than needed)
+- Missing caching opportunities
+- Inefficient algorithms or data structures
+For each issue: severity, location, and specific fix.`,
+        tags: ['performance', 'builtin'],
+        builtIn: true,
+    },
+    'migration-plan': {
+        name: 'migration-plan',
+        description: 'Plan a safe migration or refactor of a module',
+        prompt: `Create a step-by-step migration plan for changing {target}:
+1. Current state analysis
+2. All code that depends on it (imports, usages)
+3. Proposed new implementation
+4. Migration steps in safe order (least risk first)
+5. Rollback strategy
+6. How to test each step
+Be specific about which files to change and in what order.`,
+        tags: ['planning', 'builtin'],
+        builtIn: true,
+    },
+};
+
+class SkillsManager {
+    constructor() {
+        this._custom = this._load();
+    }
+
+    _load() {
+        try {
+            if (fs.existsSync(SKILLS_FILE)) return JSON.parse(fs.readFileSync(SKILLS_FILE, 'utf-8'));
+        } catch { }
+        return {};
+    }
+
+    _save() {
+        fs.writeFileSync(SKILLS_FILE, JSON.stringify(this._custom, null, 2));
+    }
+
+    /**
+     * Get a skill by name (checks custom first, then built-in)
+     */
+    get(name) {
+        return this._custom[name] || BUILTIN_SKILLS[name] || null;
+    }
+
+    /**
+     * List all skills
+     */
+    list(filter = {}) {
+        const all = { ...BUILTIN_SKILLS, ...this._custom };
+        let skills = Object.values(all);
+        if (filter.tags?.length) {
+            skills = skills.filter(s => filter.tags.some(t => s.tags?.includes(t)));
+        }
+        if (filter.search) {
+            const q = filter.search.toLowerCase();
+            skills = skills.filter(s => s.name.includes(q) || s.description.includes(q));
+        }
+        return skills;
+    }
+
+    /**
+     * Create a custom skill
+     */
+    create(name, description, prompt, tags = []) {
+        if (!name || !prompt) throw new Error('name and prompt are required');
+        if (BUILTIN_SKILLS[name]) throw new Error(`Cannot override built-in skill: ${name}`);
+
+        const skill = {
+            name: name.toLowerCase().replace(/\s+/g, '-'),
+            description,
+            prompt,
+            tags: [...tags, 'custom'],
+            builtIn: false,
+            createdAt: new Date().toISOString(),
+        };
+
+        this._custom[skill.name] = skill;
+        this._save();
+        logger.info(`[Skills] Created: ${skill.name}`);
+        return skill;
+    }
+
+    /**
+     * Delete a custom skill
+     */
+    delete(name) {
+        if (BUILTIN_SKILLS[name]) throw new Error('Cannot delete built-in skills');
+        if (!this._custom[name]) throw new Error(`Skill not found: ${name}`);
+        delete this._custom[name];
+        this._save();
+        return true;
+    }
+
+    /**
+     * Execute a skill against a target
+     * @param {string} skillName  - Skill to run
+     * @param {string} target     - What to run it on (function name, file path, etc.)
+     * @param {object} opts
+     */
+    async run(skillName, target, opts = {}) {
+        const { sessionId = 'default', extraContext = '' } = opts;
+        const skill = this.get(skillName);
+        if (!skill) throw new Error(`Unknown skill: ${skillName}. Run /skill list to see available skills.`);
+
+        logger.info(`[Skills] Running "${skillName}" on "${target}"`);
+
+        // Build the prompt by substituting {target}
+        const prompt = skill.prompt.replace(/\{target\}/g, target);
+
+        // Retrieve relevant context for the target
+        const docs = indexer.search(`${target} ${skillName}`, 8);
+        const memories = MemoryManager.getRelevant(`${skillName} ${target}`, 3);
+        const memContext = MemoryManager.formatAsContext(memories);
+
+        const contextStr = docs.length > 0
+            ? '\n\n## Codebase Context\n' + docs.map(d =>
+                `**${d.filename}** (${d.kind}):\n\`\`\`\n${d.content.slice(0, 800)}\n\`\`\``
+            ).join('\n\n---\n\n')
+            : '';
+
+        const systemPrompt = [
+            `You are an expert developer executing a specific skill: "${skill.name}".`,
+            `Be precise, code-focused, and base your answer entirely on the provided codebase context.`,
+            memContext,
+        ].filter(Boolean).join('\n\n');
+
+        const userMessage = `${prompt}${extraContext ? '\n\nAdditional context: ' + extraContext : ''}${contextStr}`;
+
+        const response = await llm.chat({
+            model: llm.model('smart'),
+            max_tokens: 2000,
+            system: systemPrompt,
+            messages: [{ role: 'user', content: userMessage }],
+        });
+
+        costTracker.record({
+            model: llm.model('smart'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: `skill-${skillName}`,
+        });
+
+        const result = response.content[0].text;
+
+        // Auto-save useful outcomes to memory
+        MemoryManager.extractFromExchange(`${skillName} on ${target}`, result, sessionId).catch(() => { });
+
+        return {
+            skill: skillName,
+            target,
+            result,
+            sourcesUsed: docs.length,
+            usage: { inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens },
+        };
+    }
+}
+
+module.exports = new SkillsManager();

package/src/storage/store.js

@@ -7,119 +7,141 @@ const INDEX_FILE = path.join(DATA_DIR, 'index.json');
 const META_FILE = path.join(DATA_DIR, 'meta.json');
 
 class Store {
-    constructor() {
-        this._ensureDataDir();
-        this.index = this._load(INDEX_FILE, []);
-        this.meta = this._load(META_FILE, {
-            totalDocs: 0,
-            totalFiles: 0,
-            lastIngested: null,
-            fileTypes: {},
-            tags: [],
-        });
+  constructor() {
+    this._ensureDataDir();
+    this.index = this._load(INDEX_FILE, []);
+    this.meta = this._load(META_FILE, {
+      totalDocs: 0,
+      totalFiles: 0,
+      lastIngested: null,
+      fileTypes: {},
+      tags: [],
+    });
+  }
+
+  _ensureDataDir() {
+    if (!fs.existsSync(DATA_DIR)) {
+      fs.mkdirSync(DATA_DIR, { recursive: true });
     }
-
-    _ensureDataDir() {
-        if (!fs.existsSync(DATA_DIR)) {
-            fs.mkdirSync(DATA_DIR, { recursive: true });
-        }
-        const logsDir = path.join(process.cwd(), 'logs');
-        if (!fs.existsSync(logsDir)) {
-            fs.mkdirSync(logsDir, { recursive: true });
-        }
-    }
-
-    _load(file, defaultVal) {
-        try {
-            if (fs.existsSync(file)) {
-                return JSON.parse(fs.readFileSync(file, 'utf-8'));
-            }
-        } catch (e) {
-            logger.warn(`Could not load ${file}: ${e.message}`);
-        }
-        return defaultVal;
-    }
-
-    _save() {
-        fs.writeFileSync(INDEX_FILE, JSON.stringify(this.index, null, 2));
-        fs.writeFileSync(META_FILE, JSON.stringify(this.meta, null, 2));
-    }
-
-    upsertDocs(docs) {
-        let added = 0;
-        let updated = 0;
-
-        for (const doc of docs) {
-            const existingIdx = this.index.findIndex(d => d.id === doc.id);
-            if (existingIdx >= 0) {
-                this.index[existingIdx] = doc;
-                updated++;
-            } else {
-                this.index.push(doc);
-                added++;
-            }
-        }
-
-        this._rebuildMeta();
-        this._save();
-        return { added, updated };
-    }
-
-    removeByPath(filePath) {
-        const before = this.index.length;
-        this.index = this.index.filter(d => d.filePath !== filePath);
-        const removed = before - this.index.length;
-        this._rebuildMeta();
-        this._save();
-        return removed;
-    }
-
-    getAll() {
-        return this.index;
-    }
-
-    getByKind(kind) {
-        return this.index.filter(d => d.kind === kind);
+    const logsDir = path.join(process.cwd(), 'logs');
+    if (!fs.existsSync(logsDir)) {
+      fs.mkdirSync(logsDir, { recursive: true });
     }
-
-    getIngestedFiles() {
-        return [...new Set(this.index.map(d => d.filePath))];
+  }
+
+  _load(file, defaultVal) {
+    try {
+      if (fs.existsSync(file)) {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+      }
+    } catch (e) {
+      logger.warn(`Could not load ${file}: ${e.message}`);
     }
-
-    clear() {
-        this.index = [];
-        this.meta = {
-            totalDocs: 0,
-            totalFiles: 0,
-            lastIngested: null,
-            fileTypes: {},
-            tags: [],
-        };
-        this._save();
+    return defaultVal;
+  }
+
+  _save() {
+    fs.writeFileSync(INDEX_FILE, JSON.stringify(this.index, null, 2));
+    fs.writeFileSync(META_FILE, JSON.stringify(this.meta, null, 2));
+  }
+
+  /**
+   * Add or update documents in the index
+   */
+  upsertDocs(docs) {
+    let added = 0;
+    let updated = 0;
+
+    for (const doc of docs) {
+      const existingIdx = this.index.findIndex(d => d.id === doc.id);
+      if (existingIdx >= 0) {
+        this.index[existingIdx] = doc;
+        updated++;
+      } else {
+        this.index.push(doc);
+        added++;
+      }
     }
 
-    getStats() {
-        return {
-            ...this.meta,
-            indexSize: this.index.length,
-        };
+    this._rebuildMeta();
+    this._save();
+    return { added, updated };
+  }
+
+  /**
+   * Remove all documents from a specific file path
+   */
+  removeByPath(filePath) {
+    const before = this.index.length;
+    this.index = this.index.filter(d => d.filePath !== filePath);
+    const removed = before - this.index.length;
+    this._rebuildMeta();
+    this._save();
+    return removed;
+  }
+
+  /**
+   * Get all documents
+   */
+  getAll() {
+    return this.index;
+  }
+
+  /**
+   * Get documents by kind
+   */
+  getByKind(kind) {
+    return this.index.filter(d => d.kind === kind);
+  }
+
+  /**
+   * Get all unique file paths that have been ingested
+   */
+  getIngestedFiles() {
+    return [...new Set(this.index.map(d => d.filePath))];
+  }
+
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.index = [];
+    this.meta = {
+      totalDocs: 0,
+      totalFiles: 0,
+      lastIngested: null,
+      fileTypes: {},
+      tags: [],
+    };
+    this._save();
+  }
+
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      ...this.meta,
+      indexSize: this.index.length,
+    };
+  }
+
+  _rebuildMeta() {
+    const files = new Set(this.index.map(d => d.filePath));
+    const fileTypes = {};
+    for (const doc of this.index) {
+      fileTypes[doc.kind] = (fileTypes[doc.kind] || 0) + 1;
     }
 
-    _rebuildMeta() {
-        const files = new Set(this.index.map(d => d.filePath));
-        const fileTypes = {};
-        for (const doc of this.index) {
-            fileTypes[doc.kind] = (fileTypes[doc.kind] || 0) + 1;
-        }
-
-        this.meta = {
-            totalDocs: this.index.length,
-            totalFiles: files.size,
-            lastIngested: new Date().toISOString(),
-            fileTypes,
-        };
-    }
+    this.meta = {
+      totalDocs: this.index.length,
+      totalFiles: files.size,
+      lastIngested: new Date().toISOString(),
+      fileTypes,
+    };
+  }
 }
 
+// Singleton
 const store = new Store();
 module.exports = store;