smart-context-mcp 1.0.4 → 1.2.0

package/src/diff-analysis.js

@@ -0,0 +1,291 @@
+/**
+ * Diff-aware context analysis for intelligent change-based retrieval.
+ * 
+ * Analyzes git diffs to understand change impact and expand context intelligently.
+ */
+
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const execFile = promisify(execFileCallback);
+
+/**
+ * Get detailed diff statistics for changed files.
+ * 
+ * @param {string} ref - Git reference (e.g., 'HEAD', 'main')
+ * @param {string} root - Project root
+ * @returns {Promise<Array>} Array of { file, additions, deletions, changeType }
+ */
+export const getDetailedDiff = async (ref, root) => {
+  try {
+    const { stdout } = await execFile('git', ['diff', '--numstat', ref], {
+      cwd: root,
+      timeout: 10000,
+    });
+
+    const changes = [];
+    for (const line of stdout.split('\n')) {
+      if (!line.trim()) continue;
+
+      const parts = line.split('\t');
+      if (parts.length < 3) continue;
+
+      const [additions, deletions, file] = parts;
+      
+      const adds = additions === '-' ? 0 : parseInt(additions, 10);
+      const dels = deletions === '-' ? 0 : parseInt(deletions, 10);
+
+      changes.push({
+        file,
+        additions: adds,
+        deletions: dels,
+        totalChanges: adds + dels,
+        changeType: classifyChange(adds, dels),
+      });
+    }
+
+    return changes;
+  } catch (err) {
+    return [];
+  }
+};
+
+/**
+ * Classify the type of change based on additions/deletions ratio.
+ */
+const classifyChange = (additions, deletions) => {
+  const total = additions + deletions;
+  if (total === 0) return 'unchanged';
+  
+  const ratio = additions / total;
+  
+  if (ratio > 0.9) return 'addition';
+  if (ratio < 0.1) return 'deletion';
+  if (Math.abs(ratio - 0.5) < 0.2) return 'refactor';
+  return 'modification';
+};
+
+/**
+ * Analyze change impact and prioritize files.
+ * 
+ * @param {Array} changes - Array from getDetailedDiff
+ * @param {object} index - Symbol index
+ * @returns {Array} Prioritized changes with impact scores
+ */
+export const analyzeChangeImpact = (changes, index) => {
+  return changes.map(change => {
+    const impactScore = calculateImpactScore(change, index);
+    
+    return {
+      ...change,
+      impactScore,
+      priority: categorizePriority(impactScore, change),
+    };
+  }).sort((a, b) => b.impactScore - a.impactScore);
+};
+
+/**
+ * Calculate impact score for a changed file.
+ */
+const calculateImpactScore = (change, index) => {
+  let score = 0;
+
+  score += Math.min(change.totalChanges, 100);
+
+  if (isImplementationFile(change.file)) {
+    score += 50;
+  }
+
+  if (index?.graph?.edges) {
+    const dependents = index.graph.edges.filter(e => e.to === change.file && e.kind === 'import');
+    score += dependents.length * 10;
+  }
+
+  if (isTestFile(change.file)) {
+    score -= 20;
+  }
+
+  if (isConfigFile(change.file) && change.totalChanges < 10) {
+    score -= 30;
+  }
+
+  return Math.max(0, score);
+};
+
+const isImplementationFile = (filePath) => {
+  const ext = path.extname(filePath);
+  return ['.js', '.jsx', '.ts', '.tsx', '.py', '.go', '.rs', '.java'].includes(ext) 
+    && !isTestFile(filePath);
+};
+
+const isTestFile = (filePath) => {
+  const patterns = ['.test.', '.spec.', '__tests__', '__mocks__', '/tests/', '/test/'];
+  return patterns.some(p => filePath.includes(p));
+};
+
+const isConfigFile = (filePath) => {
+  const ext = path.extname(filePath);
+  const configExts = ['.json', '.yaml', '.yml', '.toml', '.config.js', '.config.ts'];
+  return configExts.some(e => filePath.endsWith(e)) || 
+         ['Dockerfile', 'docker-compose', '.env', '.gitignore'].some(n => filePath.includes(n));
+};
+
+const categorizePriority = (score, change) => {
+  if (score >= 100) return 'critical';
+  if (score >= 50) return 'high';
+  if (score >= 20) return 'medium';
+  return 'low';
+};
+
+/**
+ * Expand changed files to include their context.
+ * 
+ * @param {Array<string>} changedFiles - Changed file paths
+ * @param {object} index - Symbol index
+ * @param {number} maxExpansion - Max files to add
+ * @returns {Set<string>} Expanded file set
+ */
+export const expandChangedContext = (changedFiles, index, maxExpansion = 10) => {
+  const expanded = new Set(changedFiles);
+  const candidates = new Map();
+
+  if (!index?.graph?.edges) return expanded;
+
+  for (const changed of changedFiles) {
+    const importers = index.graph.edges
+      .filter(e => e.to === changed && e.kind === 'import')
+      .map(e => e.from);
+
+    for (const importer of importers) {
+      if (!expanded.has(importer)) {
+        const currentScore = candidates.get(importer) || 0;
+        candidates.set(importer, currentScore + 10);
+      }
+    }
+
+    const imports = index.graph.edges
+      .filter(e => e.from === changed && e.kind === 'import')
+      .map(e => e.to);
+
+    for (const imported of imports) {
+      if (!expanded.has(imported)) {
+        const currentScore = candidates.get(imported) || 0;
+        candidates.set(imported, currentScore + 5);
+      }
+    }
+
+    const tests = index.graph.edges
+      .filter(e => e.from !== changed && e.to === changed && e.kind === 'testOf')
+      .map(e => e.from);
+
+    for (const test of tests) {
+      if (!expanded.has(test)) {
+        const currentScore = candidates.get(test) || 0;
+        candidates.set(test, currentScore + 8);
+      }
+    }
+  }
+
+  const sorted = Array.from(candidates.entries())
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, maxExpansion);
+
+  for (const [file] of sorted) {
+    expanded.add(file);
+  }
+
+  return expanded;
+};
+
+/**
+ * Generate a human-readable diff summary.
+ * 
+ * @param {Array} changes - Prioritized changes from analyzeChangeImpact
+ * @returns {string} Summary text
+ */
+export const generateDiffSummary = (changes) => {
+  if (changes.length === 0) return 'No changes detected';
+
+  const byType = {
+    addition: [],
+    deletion: [],
+    modification: [],
+    refactor: [],
+  };
+
+  for (const change of changes) {
+    byType[change.changeType]?.push(change);
+  }
+
+  const lines = [];
+  
+  const total = changes.reduce((sum, c) => sum + c.totalChanges, 0);
+  lines.push(`${changes.length} files changed, ${total} lines modified`);
+
+  if (byType.addition.length > 0) {
+    lines.push(`  ${byType.addition.length} new files (+${byType.addition.reduce((s, c) => s + c.additions, 0)} lines)`);
+  }
+  if (byType.deletion.length > 0) {
+    lines.push(`  ${byType.deletion.length} deletions (-${byType.deletion.reduce((s, c) => s + c.deletions, 0)} lines)`);
+  }
+  if (byType.modification.length > 0) {
+    lines.push(`  ${byType.modification.length} modifications`);
+  }
+  if (byType.refactor.length > 0) {
+    lines.push(`  ${byType.refactor.length} refactorings`);
+  }
+
+  const critical = changes.filter(c => c.priority === 'critical');
+  if (critical.length > 0) {
+    lines.push(`\nHigh-impact files (${critical.length}):`);
+    for (const change of critical.slice(0, 5)) {
+      lines.push(`  - ${change.file} (+${change.additions}/-${change.deletions})`);
+    }
+  }
+
+  return lines.join('\n');
+};
+
+/**
+ * Extract changed function/class names from diff.
+ * 
+ * @param {string} ref - Git reference
+ * @param {string} file - File path
+ * @param {string} root - Project root
+ * @returns {Promise<Array<string>>} Changed symbol names
+ */
+export const getChangedSymbols = async (ref, file, root) => {
+  try {
+    const { stdout } = await execFile('git', ['diff', '-U0', ref, '--', file], {
+      cwd: root,
+      timeout: 5000,
+    });
+
+    const symbols = new Set();
+    const lines = stdout.split('\n');
+
+    for (const line of lines) {
+      if (!line.startsWith('+')) continue;
+
+      const functionMatch = line.match(/\b(function|const|let|var)\s+(\w+)/);
+      const classMatch = line.match(/\bclass\s+(\w+)/);
+      const arrowMatch = line.match(/\b(\w+)\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/);
+
+      if (functionMatch) symbols.add(functionMatch[2]);
+      if (classMatch) symbols.add(classMatch[1]);
+      if (arrowMatch) symbols.add(arrowMatch[1]);
+
+      const pyDefMatch = line.match(/\bdef\s+(\w+)/);
+      const pyClassMatch = line.match(/\bclass\s+(\w+)/);
+      
+      if (pyDefMatch) symbols.add(pyDefMatch[1]);
+      if (pyClassMatch) symbols.add(pyClassMatch[1]);
+    }
+
+    return Array.from(symbols);
+  } catch {
+    return [];
+  }
+};

package/src/git-blame.js

@@ -0,0 +1,324 @@
+/**
+ * Symbol-level git blame for fine-grained code attribution.
+ * 
+ * Provides author information at function/class level instead of just file level.
+ */
+
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { loadIndex } from './index.js';
+import { projectRoot } from './utils/paths.js';
+
+const execFile = promisify(execFileCallback);
+
+/**
+ * Get git blame data for a file with line-level attribution.
+ * 
+ * @param {string} filePath - Relative path from project root
+ * @param {string} root - Project root
+ * @returns {Promise<Array>} Array of { line, author, email, date, commit, content }
+ */
+export const getFileBlame = async (filePath, root = projectRoot) => {
+  try {
+    const { stdout } = await execFile('git', [
+      'blame',
+      '--line-porcelain',
+      '--',
+      filePath
+    ], {
+      cwd: root,
+      timeout: 10000,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+
+    const lines = stdout.split('\n');
+    const blameData = [];
+    let currentCommit = null;
+    let currentAuthor = null;
+    let currentEmail = null;
+    let currentDate = null;
+    let lineNumber = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.match(/^[0-9a-f]{40}/)) {
+        const parts = line.split(' ');
+        currentCommit = parts[0];
+        lineNumber = parseInt(parts[2], 10);
+      } else if (line.startsWith('author ')) {
+        currentAuthor = line.substring(7);
+      } else if (line.startsWith('author-mail ')) {
+        currentEmail = line.substring(12).replace(/[<>]/g, '');
+      } else if (line.startsWith('author-time ')) {
+        const timestamp = parseInt(line.substring(12), 10);
+        currentDate = new Date(timestamp * 1000).toISOString();
+      } else if (line.startsWith('\t')) {
+        const content = line.substring(1);
+        blameData.push({
+          line: lineNumber,
+          author: currentAuthor,
+          email: currentEmail,
+          date: currentDate,
+          commit: currentCommit,
+          content,
+        });
+      }
+    }
+
+    return blameData;
+  } catch (err) {
+    if (err.code === 'ENOENT' || err.stderr?.includes('no such path')) {
+      return [];
+    }
+    throw err;
+  }
+};
+
+/**
+ * Get symbol-level blame information for a file.
+ * 
+ * @param {string} filePath - Relative path from project root
+ * @param {string} root - Project root
+ * @returns {Promise<Array>} Array of { symbol, kind, author, email, date, commit, lineStart, lineEnd }
+ */
+export const getSymbolBlame = async (filePath, root = projectRoot) => {
+  const index = loadIndex(root);
+  if (!index?.files?.[filePath]) {
+    return [];
+  }
+
+  const fileInfo = index.files[filePath];
+  if (!fileInfo.symbols || fileInfo.symbols.length === 0) {
+    return [];
+  }
+
+  const blameData = await getFileBlame(filePath, root);
+  if (blameData.length === 0) {
+    return [];
+  }
+
+  const symbolBlame = [];
+
+  for (const symbol of fileInfo.symbols) {
+    const lineStart = symbol.line;
+    const lineEnd = symbol.lineEnd || lineStart;
+
+    const relevantLines = blameData.filter(
+      b => b.line >= lineStart && b.line <= lineEnd
+    );
+
+    if (relevantLines.length === 0) continue;
+
+    const authorCounts = {};
+    for (const line of relevantLines) {
+      const key = `${line.author}|${line.email}`;
+      if (!authorCounts[key]) {
+        authorCounts[key] = {
+          author: line.author,
+          email: line.email,
+          commit: line.commit,
+          date: line.date,
+          count: 0,
+        };
+      }
+      authorCounts[key].count++;
+    }
+
+    const sortedAuthors = Object.values(authorCounts).sort((a, b) => b.count - a.count);
+    const primaryAuthor = sortedAuthors[0];
+
+    const contributorCount = sortedAuthors.length;
+    const primaryPercentage = Math.round((primaryAuthor.count / relevantLines.length) * 100);
+
+    symbolBlame.push({
+      symbol: symbol.name,
+      kind: symbol.kind,
+      author: primaryAuthor.author,
+      email: primaryAuthor.email,
+      date: primaryAuthor.date,
+      commit: primaryAuthor.commit,
+      lineStart,
+      lineEnd,
+      linesAuthored: primaryAuthor.count,
+      totalLines: relevantLines.length,
+      authorshipPercentage: primaryPercentage,
+      contributors: contributorCount,
+      ...(contributorCount > 1 ? { allContributors: sortedAuthors } : {}),
+    });
+  }
+
+  return symbolBlame;
+};
+
+/**
+ * Get aggregated authorship statistics for a file.
+ * 
+ * @param {string} filePath - Relative path from project root
+ * @param {string} root - Project root
+ * @returns {Promise<object>} Aggregated stats
+ */
+export const getFileAuthorshipStats = async (filePath, root = projectRoot) => {
+  const blameData = await getFileBlame(filePath, root);
+  if (blameData.length === 0) {
+    return {
+      totalLines: 0,
+      authors: [],
+      lastModified: null,
+      oldestLine: null,
+    };
+  }
+
+  const authorStats = {};
+  let mostRecentDate = null;
+  let oldestDate = null;
+
+  for (const line of blameData) {
+    const key = line.email;
+    if (!authorStats[key]) {
+      authorStats[key] = {
+        author: line.author,
+        email: line.email,
+        lines: 0,
+        commits: new Set(),
+        firstContribution: line.date,
+        lastContribution: line.date,
+      };
+    }
+
+    authorStats[key].lines++;
+    authorStats[key].commits.add(line.commit);
+
+    if (!mostRecentDate || line.date > mostRecentDate) {
+      mostRecentDate = line.date;
+    }
+    if (!oldestDate || line.date < oldestDate) {
+      oldestDate = line.date;
+    }
+
+    if (line.date < authorStats[key].firstContribution) {
+      authorStats[key].firstContribution = line.date;
+    }
+    if (line.date > authorStats[key].lastContribution) {
+      authorStats[key].lastContribution = line.date;
+    }
+  }
+
+  const authors = Object.values(authorStats)
+    .map(a => ({
+      author: a.author,
+      email: a.email,
+      lines: a.lines,
+      percentage: Math.round((a.lines / blameData.length) * 100),
+      commits: a.commits.size,
+      firstContribution: a.firstContribution,
+      lastContribution: a.lastContribution,
+    }))
+    .sort((a, b) => b.lines - a.lines);
+
+  return {
+    totalLines: blameData.length,
+    authors,
+    lastModified: mostRecentDate,
+    oldestLine: oldestDate,
+  };
+};
+
+/**
+ * Find symbols authored by a specific person.
+ * 
+ * @param {string} authorQuery - Author name or email (partial match)
+ * @param {string} root - Project root
+ * @param {number} limit - Max results
+ * @returns {Promise<Array>} Array of { file, symbol, kind, author, email, percentage }
+ */
+export const findSymbolsByAuthor = async (authorQuery, root = projectRoot, limit = 50) => {
+  const index = loadIndex(root);
+  if (!index?.files) return [];
+
+  const normalizedQuery = authorQuery.toLowerCase();
+  const results = [];
+
+  const files = Object.keys(index.files).slice(0, 100);
+
+  for (const filePath of files) {
+    try {
+      const symbolBlame = await getSymbolBlame(filePath, root);
+
+      for (const sb of symbolBlame) {
+        const authorMatch = sb.author.toLowerCase().includes(normalizedQuery);
+        const emailMatch = sb.email.toLowerCase().includes(normalizedQuery);
+
+        if (authorMatch || emailMatch) {
+          results.push({
+            file: filePath,
+            symbol: sb.symbol,
+            kind: sb.kind,
+            author: sb.author,
+            email: sb.email,
+            authorshipPercentage: sb.authorshipPercentage,
+            lineStart: sb.lineStart,
+            lineEnd: sb.lineEnd,
+          });
+
+          if (results.length >= limit) {
+            return results;
+          }
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Get recently modified symbols across the project.
+ * 
+ * @param {string} root - Project root
+ * @param {number} limit - Max results
+ * @param {number} daysBack - How many days to look back
+ * @returns {Promise<Array>} Array of { file, symbol, kind, author, date, daysAgo }
+ */
+export const getRecentlyModifiedSymbols = async (root = projectRoot, limit = 20, daysBack = 30) => {
+  const index = loadIndex(root);
+  if (!index?.files) return [];
+
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysBack);
+  const cutoffISO = cutoffDate.toISOString();
+
+  const results = [];
+  const files = Object.keys(index.files).slice(0, 50);
+
+  for (const filePath of files) {
+    try {
+      const symbolBlame = await getSymbolBlame(filePath, root);
+
+      for (const sb of symbolBlame) {
+        if (sb.date >= cutoffISO) {
+          const daysAgo = Math.floor((Date.now() - new Date(sb.date).getTime()) / (1000 * 60 * 60 * 24));
+
+          results.push({
+            file: filePath,
+            symbol: sb.symbol,
+            kind: sb.kind,
+            author: sb.author,
+            email: sb.email,
+            date: sb.date,
+            daysAgo,
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return results
+    .sort((a, b) => new Date(b.date) - new Date(a.date))
+    .slice(0, limit);
+};

package/src/index.js

@@ -658,11 +658,18 @@ const walkForIndex = (dir, files = []) => {
 // Build index
 // ---------------------------------------------------------------------------
 
-export const buildIndex = (root) => {
+export const buildIndex = (root, progress = null) => {
   const files = walkForIndex(root);
   const fileEntries = {};
   const invertedIndex = {};
   const rawImports = {};
+  const total = files.length;
+  let processed = 0;
+  let lastReportAt = 0;
+
+  if (progress) {
+    progress.report({ phase: 'scanning', total });
+  }
 
   for (const fullPath of files) {
     try {
@@ -696,6 +703,26 @@ export const buildIndex = (root) => {
     } catch {
       // skip unreadable files
     }
+
+    processed++;
+    
+    // Report progress every 50 files or 5% of total
+    if (progress && (processed - lastReportAt >= 50 || processed - lastReportAt >= total * 0.05)) {
+      const percentage = Math.floor((processed / total) * 100);
+      progress.report({ 
+        phase: 'indexing', 
+        processed, 
+        total, 
+        percentage,
+        files: Object.keys(fileEntries).length,
+        symbols: Object.keys(invertedIndex).length,
+      });
+      lastReportAt = processed;
+    }
+  }
+
+  if (progress) {
+    progress.report({ phase: 'resolving', total: Object.keys(rawImports).length });
   }
 
   const knownRelPaths = new Set(Object.keys(fileEntries));
@@ -873,10 +900,13 @@ export const removeFileFromIndex = (index, relPath) => {
   delete index.files[relPath];
 };
 
-export const buildIndexIncremental = (root) => {
+export const buildIndexIncremental = (root, progress = null) => {
   const existing = loadIndex(root);
   if (!existing) {
-    const index = buildIndex(root);
+    if (progress) {
+      progress.report({ phase: 'full_rebuild', reason: 'no_existing_index' });
+    }
+    const index = buildIndex(root, progress);
     const total = Object.keys(index.files).length;
     return { index, stats: { total, reindexed: total, removed: 0, unchanged: 0, fullRebuild: true } };
   }
@@ -885,6 +915,12 @@ export const buildIndexIncremental = (root) => {
   const diskRelPaths = new Set();
   const reindexedPaths = [];
   let unchanged = 0;
+  const total = diskFiles.length;
+  let processed = 0;
+
+  if (progress) {
+    progress.report({ phase: 'scanning', total });
+  }
 
   for (const fullPath of diskFiles) {
     try {
@@ -900,6 +936,19 @@ export const buildIndexIncremental = (root) => {
         unchanged++;
       }
     } catch { /* skip unreadable */ }
+
+    processed++;
+    if (progress && processed % 100 === 0) {
+      const percentage = Math.floor((processed / total) * 100);
+      progress.report({ 
+        phase: 'checking', 
+        processed, 
+        total, 
+        percentage,
+        stale: reindexedPaths.length,
+        unchanged,
+      });
+    }
   }
 
   const indexedPaths = Object.keys(existing.files);
@@ -945,8 +994,8 @@ export const buildIndexIncremental = (root) => {
 
   existing.generatedAt = new Date().toISOString();
 
-  const total = Object.keys(existing.files).length;
-  return { index: existing, stats: { total, reindexed: reindexedPaths.length, removed, unchanged, fullRebuild: false } };
+  const finalTotal = Object.keys(existing.files).length;
+  return { index: existing, stats: { total: finalTotal, reindexed: reindexedPaths.length, removed, unchanged, fullRebuild: false } };
 };
 
 // ---------------------------------------------------------------------------