dev-mcp-server 0.0.2 → 1.0.0

package/src/utils/costTracker.js

@@ -0,0 +1,69 @@
+'use strict';
+/**
+ * Provider-agnostic cost tracking. Uses llmClient for price lookup.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COST_FILE = path.join(process.cwd(), 'data', 'cost-tracker.json');
+
+class CostTracker {
+    constructor() {
+        this._data = this._load();
+    }
+
+    _load() {
+        try { if (fs.existsSync(COST_FILE)) return JSON.parse(fs.readFileSync(COST_FILE, 'utf-8')); } catch { }
+        return { sessions: {}, allTime: { inputTokens: 0, outputTokens: 0, totalCostUsd: 0, calls: 0 } };
+    }
+    _save() { fs.writeFileSync(COST_FILE, JSON.stringify(this._data, null, 2)); }
+
+    record({ model, inputTokens, outputTokens, sessionId = 'default', queryType = 'general' }) {
+        // Lazy-load llmClient to avoid circular dep at startup
+        let costUsd = 0;
+        try {
+            const llm = require('./llmClient');
+            costUsd = llm.costUsd(model, inputTokens, outputTokens);
+        } catch { }
+
+        this._data.allTime.inputTokens += inputTokens;
+        this._data.allTime.outputTokens += outputTokens;
+        this._data.allTime.totalCostUsd += costUsd;
+        this._data.allTime.calls += 1;
+
+        if (!this._data.sessions[sessionId]) {
+            this._data.sessions[sessionId] = { startedAt: new Date().toISOString(), inputTokens: 0, outputTokens: 0, totalCostUsd: 0, calls: 0, byQueryType: {} };
+        }
+        const sess = this._data.sessions[sessionId];
+        sess.inputTokens += inputTokens;
+        sess.outputTokens += outputTokens;
+        sess.totalCostUsd += costUsd;
+        sess.calls += 1;
+        sess.lastUsedAt = new Date().toISOString();
+        sess.byQueryType[queryType] = (sess.byQueryType[queryType] || 0) + 1;
+
+        this._save();
+        return { costUsd, inputTokens, outputTokens };
+    }
+
+    getSession(id = 'default') { return this._data.sessions[id] || null; }
+    getAllTime() { return this._data.allTime; }
+
+    getSummary(sessionId = 'default') {
+        const sess = this.getSession(sessionId);
+        const all = this.getAllTime();
+        return {
+            session: sess ? { calls: sess.calls, inputTokens: sess.inputTokens, outputTokens: sess.outputTokens, costUsd: parseFloat(sess.totalCostUsd.toFixed(6)), startedAt: sess.startedAt } : null,
+            allTime: { calls: all.calls, inputTokens: all.inputTokens, outputTokens: all.outputTokens, costUsd: parseFloat(all.totalCostUsd.toFixed(6)) },
+        };
+    }
+
+    formatCost(usd) {
+        if (usd === 0) return '$0.0000 (local)';
+        if (usd < 0.001) return `$${(usd * 1000).toFixed(4)}m`;
+        return `$${usd.toFixed(4)}`;
+    }
+}
+
+module.exports = new CostTracker();

package/src/utils/fileParser.js

@@ -1,183 +1,206 @@
 const fs = require('fs');
 const path = require('path');
 
+// Supported file types and their "kind" labels
 const FILE_TYPE_MAP = {
-    '.js': 'code',
-    '.ts': 'code',
-    '.jsx': 'code',
-    '.tsx': 'code',
-    '.mjs': 'code',
-    '.cjs': 'code',
-    '.py': 'code',
-    '.java': 'code',
-    '.go': 'code',
-    '.rb': 'code',
-    '.php': 'code',
-    '.cs': 'code',
-    '.cpp': 'code',
-    '.c': 'code',
-    '.rs': 'code',
-    '.json': 'config',
-    '.yaml': 'config',
-    '.yml': 'config',
-    '.env': 'config',
-    '.toml': 'config',
-    '.xml': 'config',
-    '.md': 'documentation',
-    '.txt': 'documentation',
-    '.log': 'log',
-    '.sql': 'schema',
-    '.graphql': 'schema',
-    '.gql': 'schema',
-    '.sh': 'script',
-    '.bash': 'script',
+  '.js': 'code',
+  '.ts': 'code',
+  '.jsx': 'code',
+  '.tsx': 'code',
+  '.mjs': 'code',
+  '.cjs': 'code',
+  '.py': 'code',
+  '.java': 'code',
+  '.go': 'code',
+  '.rb': 'code',
+  '.php': 'code',
+  '.cs': 'code',
+  '.cpp': 'code',
+  '.c': 'code',
+  '.rs': 'code',
+  '.json': 'config',
+  '.yaml': 'config',
+  '.yml': 'config',
+  '.env': 'config',
+  '.toml': 'config',
+  '.xml': 'config',
+  '.md': 'documentation',
+  '.txt': 'documentation',
+  '.log': 'log',
+  '.sql': 'schema',
+  '.graphql': 'schema',
+  '.gql': 'schema',
+  '.sh': 'script',
+  '.bash': 'script',
 };
 
 const CHUNK_SIZE = 1500;   // characters per chunk
 const CHUNK_OVERLAP = 200; // overlap between chunks
 
+/**
+ * Parse a file and return structured chunks for indexing
+ */
 function parseFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const kind = FILE_TYPE_MAP[ext] || 'unknown';
-    const filename = path.basename(filePath);
-    const content = fs.readFileSync(filePath, 'utf-8');
-
-    if (!content.trim()) return [];
-
-    const chunks = chunkContent(content, filePath);
-
-    return chunks.map((chunk, idx) => ({
-        id: `${filePath}::chunk${idx}`,
-        filePath,
-        filename,
-        ext,
-        kind,
-        chunkIndex: idx,
-        totalChunks: chunks.length,
-        content: chunk,
-        lines: countLines(chunk),
-        ingestedAt: new Date().toISOString(),
-        metadata: extractMetadata(chunk, kind, filename),
-    }));
+  const ext = path.extname(filePath).toLowerCase();
+  const kind = FILE_TYPE_MAP[ext] || 'unknown';
+  const filename = path.basename(filePath);
+  const content = fs.readFileSync(filePath, 'utf-8');
+
+  if (!content.trim()) return [];
+
+  const chunks = chunkContent(content, filePath);
+
+  return chunks.map((chunk, idx) => ({
+    id: `${filePath}::chunk${idx}`,
+    filePath,
+    filename,
+    ext,
+    kind,
+    chunkIndex: idx,
+    totalChunks: chunks.length,
+    content: chunk,
+    lines: countLines(chunk),
+    ingestedAt: new Date().toISOString(),
+    // Extract code-specific metadata
+    metadata: extractMetadata(chunk, kind, filename),
+  }));
 }
 
+/**
+ * Split content into overlapping chunks
+ */
 function chunkContent(content, filePath) {
-    const lines = content.split('\n');
-
-    if (content.length <= CHUNK_SIZE) return [content];
-
-    const chunks = [];
-    let current = [];
-    let currentLen = 0;
-
-    for (const line of lines) {
-        current.push(line);
-        currentLen += line.length + 1;
-
-        if (currentLen >= CHUNK_SIZE) {
-            chunks.push(current.join('\n'));
-            const overlapLines = [];
-            let overlapLen = 0;
-            for (let i = current.length - 1; i >= 0 && overlapLen < CHUNK_OVERLAP; i--) {
-                overlapLines.unshift(current[i]);
-                overlapLen += current[i].length + 1;
-            }
-            current = overlapLines;
-            currentLen = overlapLen;
-        }
+  const lines = content.split('\n');
+
+  // For small files, keep as single chunk
+  if (content.length <= CHUNK_SIZE) return [content];
+
+  const chunks = [];
+  let current = [];
+  let currentLen = 0;
+
+  for (const line of lines) {
+    current.push(line);
+    currentLen += line.length + 1;
+
+    if (currentLen >= CHUNK_SIZE) {
+      chunks.push(current.join('\n'));
+      // Keep last N chars for overlap
+      const overlapLines = [];
+      let overlapLen = 0;
+      for (let i = current.length - 1; i >= 0 && overlapLen < CHUNK_OVERLAP; i--) {
+        overlapLines.unshift(current[i]);
+        overlapLen += current[i].length + 1;
+      }
+      current = overlapLines;
+      currentLen = overlapLen;
     }
+  }
 
-    if (current.length > 0) {
-        chunks.push(current.join('\n'));
-    }
+  if (current.length > 0) {
+    chunks.push(current.join('\n'));
+  }
 
-    return chunks;
+  return chunks;
 }
 
+/**
+ * Extract metadata from file content based on its type
+ */
 function extractMetadata(content, kind, filename) {
-    const meta = {};
-
-    if (kind === 'code') {
-        const functions = [];
-        const classes = [];
-        const imports = [];
-        const exports = [];
-
-        const fnMatches = content.matchAll(/(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s*)?\(|(\w+)\s*\([^)]*\)\s*{)/g);
-        for (const m of fnMatches) {
-            const name = m[1] || m[2] || m[3];
-            if (name && !['if', 'for', 'while', 'switch', 'catch'].includes(name)) {
-                functions.push(name);
-            }
-        }
-
-        const classMatches = content.matchAll(/class\s+(\w+)/g);
-        for (const m of classMatches) classes.push(m[1]);
-
-        const importMatches = content.matchAll(/(?:import|require)\s*(?:\{[^}]+\}|[\w*]+)?\s*(?:from)?\s*['"]([^'"]+)['"]/g);
-        for (const m of importMatches) imports.push(m[1]);
-
-        const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:function|class|const|let|var)?\s*(\w+)/g);
-        for (const m of exportMatches) exports.push(m[1]);
-
-        const errors = [];
-        const errorMatches = content.matchAll(/(?:catch|throw|Error|Exception)\s*[(\s]*([A-Z]\w+(?:Error|Exception))/g);
-        for (const m of errorMatches) errors.push(m[1]);
-
-        meta.functions = [...new Set(functions)].slice(0, 20);
-        meta.classes = [...new Set(classes)].slice(0, 10);
-        meta.imports = [...new Set(imports)].slice(0, 20);
-        meta.exports = [...new Set(exports)].slice(0, 10);
-        meta.errors = [...new Set(errors)].slice(0, 10);
-
-        const apiPatterns = [];
-        if (/express|router\.(get|post|put|delete|patch)/i.test(content)) apiPatterns.push('REST API');
-        if (/graphql|resolver|schema/i.test(content)) apiPatterns.push('GraphQL');
-        if (/mongoose|sequelize|prisma|typeorm/i.test(content)) apiPatterns.push('ORM');
-        if (/redis|ioredis|bull/i.test(content)) apiPatterns.push('Cache/Queue');
-        if (/jwt|passport|bcrypt/i.test(content)) apiPatterns.push('Auth');
-        meta.patterns = apiPatterns;
-
-    } else if (kind === 'log') {
-        const errorLines = content
-            .split('\n')
-            .filter(l => /error|exception|warn|fail|crash/i.test(l))
-            .slice(0, 10);
-        meta.errors = errorLines;
-
-        const hasTimestamps = /\d{4}-\d{2}-\d{2}|\d{2}\/\d{2}\/\d{4}/.test(content);
-        meta.hasTimestamps = hasTimestamps;
-
-    } else if (kind === 'schema') {
-        const tables = [];
-        const tableMatches = content.matchAll(/(?:CREATE\s+TABLE|model\s+|type\s+)["'`]?(\w+)["'`]?/gi);
-        for (const m of tableMatches) tables.push(m[1]);
-        meta.tables = [...new Set(tables)].slice(0, 20);
+  const meta = {};
+
+  if (kind === 'code') {
+    // Extract function/class names
+    const functions = [];
+    const classes = [];
+    const imports = [];
+    const exports = [];
+
+    const fnMatches = content.matchAll(/(?:function\s+(\w+)|const\s+(\w+)\s*=\s*(?:async\s*)?\(|(\w+)\s*\([^)]*\)\s*{)/g);
+    for (const m of fnMatches) {
+      const name = m[1] || m[2] || m[3];
+      if (name && !['if', 'for', 'while', 'switch', 'catch'].includes(name)) {
+        functions.push(name);
+      }
     }
 
-    meta.isBugFix = /fix|bug|patch|resolve|hotfix|issue/i.test(filename) ||
-        /TODO|FIXME|HACK|BUG|XXX/.test(content);
-
-    return meta;
+    const classMatches = content.matchAll(/class\s+(\w+)/g);
+    for (const m of classMatches) classes.push(m[1]);
+
+    const importMatches = content.matchAll(/(?:import|require)\s*(?:\{[^}]+\}|[\w*]+)?\s*(?:from)?\s*['"]([^'"]+)['"]/g);
+    for (const m of importMatches) imports.push(m[1]);
+
+    const exportMatches = content.matchAll(/export\s+(?:default\s+)?(?:function|class|const|let|var)?\s*(\w+)/g);
+    for (const m of exportMatches) exports.push(m[1]);
+
+    // Extract error types mentioned
+    const errors = [];
+    const errorMatches = content.matchAll(/(?:catch|throw|Error|Exception)\s*[(\s]*([A-Z]\w+(?:Error|Exception))/g);
+    for (const m of errorMatches) errors.push(m[1]);
+
+    meta.functions = [...new Set(functions)].slice(0, 20);
+    meta.classes = [...new Set(classes)].slice(0, 10);
+    meta.imports = [...new Set(imports)].slice(0, 20);
+    meta.exports = [...new Set(exports)].slice(0, 10);
+    meta.errors = [...new Set(errors)].slice(0, 10);
+
+    // Detect API patterns
+    const apiPatterns = [];
+    if (/express|router\.(get|post|put|delete|patch)/i.test(content)) apiPatterns.push('REST API');
+    if (/graphql|resolver|schema/i.test(content)) apiPatterns.push('GraphQL');
+    if (/mongoose|sequelize|prisma|typeorm/i.test(content)) apiPatterns.push('ORM');
+    if (/redis|ioredis|bull/i.test(content)) apiPatterns.push('Cache/Queue');
+    if (/jwt|passport|bcrypt/i.test(content)) apiPatterns.push('Auth');
+    meta.patterns = apiPatterns;
+
+  } else if (kind === 'log') {
+    // Extract error/warning lines
+    const errorLines = content
+      .split('\n')
+      .filter(l => /error|exception|warn|fail|crash/i.test(l))
+      .slice(0, 10);
+    meta.errors = errorLines;
+
+    // Extract timestamps if present
+    const hasTimestamps = /\d{4}-\d{2}-\d{2}|\d{2}\/\d{2}\/\d{4}/.test(content);
+    meta.hasTimestamps = hasTimestamps;
+
+  } else if (kind === 'schema') {
+    // Extract table/model names
+    const tables = [];
+    const tableMatches = content.matchAll(/(?:CREATE\s+TABLE|model\s+|type\s+)["'`]?(\w+)["'`]?/gi);
+    for (const m of tableMatches) tables.push(m[1]);
+    meta.tables = [...new Set(tables)].slice(0, 20);
+  }
+
+  // Detect if this looks like a bug fix / patch
+  meta.isBugFix = /fix|bug|patch|resolve|hotfix|issue/i.test(filename) ||
+    /TODO|FIXME|HACK|BUG|XXX/.test(content);
+
+  return meta;
 }
 
 function countLines(text) {
-    return text.split('\n').length;
+  return text.split('\n').length;
 }
 
+/**
+ * Check if a file should be skipped
+ */
 function shouldSkip(filePath) {
-    const skipPatterns = [
-        /node_modules/,
-        /\.git\//,
-        /dist\//,
-        /build\//,
-        /coverage\//,
-        /\.min\.(js|css)$/,
-        /package-lock\.json$/,
-        /yarn\.lock$/,
-        /\.map$/,
-    ];
-    return skipPatterns.some(p => p.test(filePath));
+  const skipPatterns = [
+    /node_modules/,
+    /\.git\//,
+    /dist\//,
+    /build\//,
+    /coverage\//,
+    /\.min\.(js|css)$/,
+    /package-lock\.json$/,
+    /yarn\.lock$/,
+    /\.map$/,
+  ];
+  return skipPatterns.some(p => p.test(filePath));
 }
 
 module.exports = { parseFile, shouldSkip, FILE_TYPE_MAP };