smart-context-mcp 1.0.4 → 1.2.0

package/src/cache-warming.js

@@ -0,0 +1,131 @@
+/**
+ * Cache warming for intelligent index preloading.
+ * 
+ * Analyzes usage patterns and preloads frequently accessed files into memory
+ * to reduce cold-start latency on first queries.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadIndex } from './index.js';
+import { withStateDb, getStateDbPath } from './storage/sqlite.js';
+import { projectRoot } from './utils/paths.js';
+
+const isCacheWarmingEnabled = () => process.env.DEVCTX_CACHE_WARMING !== 'false';
+const WARM_TOP_N_FILES = parseInt(process.env.DEVCTX_WARM_FILES || '50', 10);
+const MIN_ACCESS_COUNT = 3;
+
+export const getFrequentlyAccessedFiles = async (root = projectRoot, limit = WARM_TOP_N_FILES) => {
+  if (!isCacheWarmingEnabled()) return [];
+
+  try {
+    const dbPath = getStateDbPath(root);
+    if (!fs.existsSync(dbPath)) return [];
+
+    const files = await withStateDb(async (db) => {
+      const rows = db.prepare(`
+        SELECT file_path, COUNT(*) as access_count
+        FROM context_access
+        WHERE timestamp > datetime('now', '-30 days')
+        GROUP BY file_path
+        HAVING access_count >= ?
+        ORDER BY access_count DESC, MAX(timestamp) DESC
+        LIMIT ?
+      `).all(MIN_ACCESS_COUNT, limit);
+
+      return rows.map(r => r.file_path);
+    }, { filePath: dbPath });
+
+    return files;
+  } catch {
+    return [];
+  }
+};
+
+export const warmCache = async (root = projectRoot, progress = null) => {
+  if (!isCacheWarmingEnabled()) {
+    return { warmed: 0, skipped: 0, reason: 'disabled' };
+  }
+
+  const index = loadIndex(root);
+  if (!index) {
+    return { warmed: 0, skipped: 0, reason: 'no_index' };
+  }
+
+  const frequentFiles = await getFrequentlyAccessedFiles(root);
+  if (frequentFiles.length === 0) {
+    return { warmed: 0, skipped: 0, reason: 'no_frequent_files' };
+  }
+
+  let warmed = 0;
+  let skipped = 0;
+
+  for (let i = 0; i < frequentFiles.length; i++) {
+    const relPath = frequentFiles[i];
+    const absPath = path.join(root, relPath);
+
+    if (progress && i % 10 === 0) {
+      progress.report({
+        phase: 'warming',
+        processed: i,
+        total: frequentFiles.length,
+        percentage: Math.round((i / frequentFiles.length) * 100),
+      });
+    }
+
+    try {
+      if (!fs.existsSync(absPath)) {
+        skipped++;
+        continue;
+      }
+
+      const stats = fs.statSync(absPath);
+      if (stats.size > 1024 * 1024) {
+        skipped++;
+        continue;
+      }
+
+      fs.readFileSync(absPath, 'utf8');
+      warmed++;
+    } catch {
+      skipped++;
+    }
+  }
+
+  if (progress) {
+    progress.report({
+      phase: 'warming',
+      processed: frequentFiles.length,
+      total: frequentFiles.length,
+      percentage: 100,
+    });
+  }
+
+  return { warmed, skipped, totalCandidates: frequentFiles.length };
+};
+
+export const shouldWarmCache = async (root = projectRoot) => {
+  if (!isCacheWarmingEnabled()) return false;
+
+  const index = loadIndex(root);
+  if (!index) return false;
+
+  const frequentFiles = await getFrequentlyAccessedFiles(root, 10);
+  return frequentFiles.length >= 5;
+};
+
+export const getCacheStats = async (root = projectRoot) => {
+  const frequentFiles = await getFrequentlyAccessedFiles(root, 100);
+  
+  const byExtension = {};
+  for (const file of frequentFiles) {
+    const ext = path.extname(file) || 'no-ext';
+    byExtension[ext] = (byExtension[ext] || 0) + 1;
+  }
+
+  return {
+    totalFrequentFiles: frequentFiles.length,
+    byExtension,
+    topFiles: frequentFiles.slice(0, 10),
+  };
+};

package/src/context-patterns.js

@@ -0,0 +1,192 @@
+import { withStateDb, withStateDbSnapshot } from './storage/sqlite.js';
+
+const PATTERN_CONFIDENCE_THRESHOLD = 0.6;
+const MIN_PATTERN_OCCURRENCES = 3;
+const MAX_PREDICTED_FILES = 8;
+const PATTERN_DECAY_DAYS = 30;
+
+const initPatternTables = (db) => {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS context_patterns (
+      pattern_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_signature TEXT NOT NULL,
+      intent TEXT,
+      occurrences INTEGER DEFAULT 1,
+      last_seen_at TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(task_signature, intent)
+    );
+
+    CREATE TABLE IF NOT EXISTS pattern_files (
+      pattern_id INTEGER NOT NULL,
+      file_path TEXT NOT NULL,
+      access_order INTEGER NOT NULL,
+      access_count INTEGER DEFAULT 1,
+      avg_relevance REAL DEFAULT 1.0,
+      last_accessed_at TEXT NOT NULL,
+      FOREIGN KEY(pattern_id) REFERENCES context_patterns(pattern_id) ON DELETE CASCADE,
+      PRIMARY KEY(pattern_id, file_path)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_pattern_signature ON context_patterns(task_signature);
+    CREATE INDEX IF NOT EXISTS idx_pattern_files_lookup ON pattern_files(pattern_id, avg_relevance DESC);
+  `);
+};
+
+const normalizeTaskSignature = (task) => {
+  return task
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .split(' ')
+    .filter(word => word.length > 2)
+    .slice(0, 8)
+    .join(' ');
+};
+
+const computeTaskSimilarity = (task1, task2) => {
+  const words1 = new Set(task1.split(' '));
+  const words2 = new Set(task2.split(' '));
+  const intersection = [...words1].filter(w => words2.has(w)).length;
+  const union = new Set([...words1, ...words2]).size;
+  return union > 0 ? intersection / union : 0;
+};
+
+export const recordContextAccess = async ({ task, intent, files }) => {
+  if (!task || !Array.isArray(files) || files.length === 0) return;
+
+  const signature = normalizeTaskSignature(task);
+  if (!signature) return;
+
+  return withStateDb((db) => {
+    initPatternTables(db);
+    
+    const now = new Date().toISOString();
+    
+    db.exec('BEGIN');
+    try {
+      const existing = db.prepare(
+        'SELECT pattern_id, occurrences FROM context_patterns WHERE task_signature = ? AND intent = ?'
+      ).get(signature, intent || 'explore');
+
+      let patternId;
+      if (existing) {
+        db.prepare(
+          'UPDATE context_patterns SET occurrences = occurrences + 1, last_seen_at = ? WHERE pattern_id = ?'
+        ).run(now, existing.pattern_id);
+        patternId = existing.pattern_id;
+      } else {
+        const result = db.prepare(
+          'INSERT INTO context_patterns (task_signature, intent, last_seen_at, created_at) VALUES (?, ?, ?, ?)'
+        ).run(signature, intent || 'explore', now, now);
+        patternId = result.lastInsertRowid;
+      }
+
+      for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const existingFile = db.prepare(
+          'SELECT access_count, avg_relevance FROM pattern_files WHERE pattern_id = ? AND file_path = ?'
+        ).get(patternId, file.path);
+
+        if (existingFile) {
+          const newCount = existingFile.access_count + 1;
+          const newRelevance = (existingFile.avg_relevance * existingFile.access_count + (file.relevance || 1.0)) / newCount;
+          
+          db.prepare(
+            'UPDATE pattern_files SET access_count = ?, avg_relevance = ?, last_accessed_at = ? WHERE pattern_id = ? AND file_path = ?'
+          ).run(newCount, newRelevance, now, patternId, file.path);
+        } else {
+          db.prepare(
+            'INSERT INTO pattern_files (pattern_id, file_path, access_order, avg_relevance, last_accessed_at) VALUES (?, ?, ?, ?, ?)'
+          ).run(patternId, file.path, i, file.relevance || 1.0, now);
+        }
+      }
+
+      db.exec('COMMIT');
+    } catch (error) {
+      db.exec('ROLLBACK');
+      throw error;
+    }
+  });
+};
+
+export const predictContextFiles = async ({ task, intent, maxFiles = MAX_PREDICTED_FILES }) => {
+  const signature = normalizeTaskSignature(task);
+  if (!signature) return { predicted: [], confidence: 0, matchedPattern: null };
+
+  return withStateDbSnapshot((db) => {
+    initPatternTables(db);
+
+    const cutoffDate = new Date(Date.now() - PATTERN_DECAY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    
+    const patterns = db.prepare(`
+      SELECT pattern_id, task_signature, intent, occurrences, last_seen_at
+      FROM context_patterns
+      WHERE last_seen_at > ?
+      ORDER BY occurrences DESC
+      LIMIT 20
+    `).all(cutoffDate);
+
+    let bestMatch = null;
+    let bestScore = 0;
+
+    for (const pattern of patterns) {
+      if (intent && pattern.intent !== intent) continue;
+      
+      const similarity = computeTaskSimilarity(signature, pattern.task_signature);
+      const recencyBonus = pattern.occurrences >= MIN_PATTERN_OCCURRENCES ? 0.1 : 0;
+      const score = similarity + recencyBonus;
+
+      if (score > bestScore && score >= PATTERN_CONFIDENCE_THRESHOLD) {
+        bestScore = score;
+        bestMatch = pattern;
+      }
+    }
+
+    if (!bestMatch) {
+      return { predicted: [], confidence: 0, matchedPattern: null };
+    }
+
+    const files = db.prepare(`
+      SELECT file_path, access_order, access_count, avg_relevance
+      FROM pattern_files
+      WHERE pattern_id = ?
+      ORDER BY avg_relevance DESC, access_count DESC, access_order ASC
+      LIMIT ?
+    `).all(bestMatch.pattern_id, maxFiles);
+
+    return {
+      predicted: files.map(f => ({
+        path: f.file_path,
+        confidence: f.avg_relevance,
+        accessCount: f.access_count,
+        order: f.access_order
+      })),
+      confidence: bestScore,
+      matchedPattern: {
+        signature: bestMatch.task_signature,
+        intent: bestMatch.intent,
+        occurrences: bestMatch.occurrences
+      }
+    };
+  }, {});
+};
+
+export const cleanupStalePatterns = async ({ retentionDays = PATTERN_DECAY_DAYS } = {}) => {
+  return withStateDb((db) => {
+    initPatternTables(db);
+    
+    const cutoffDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
+    
+    const result = db.prepare(
+      'DELETE FROM context_patterns WHERE last_seen_at < ?'
+    ).run(cutoffDate);
+
+    return {
+      action: 'cleanup_patterns',
+      deletedPatterns: result.changes,
+      retentionDays
+    };
+  });
+};

package/src/cross-project.js

@@ -0,0 +1,343 @@
+/**
+ * Cross-project context for monorepos and related projects.
+ * 
+ * Enables context sharing across multiple related codebases.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadIndex } from './index.js';
+import { smartSearch } from './tools/smart-search.js';
+import { smartRead } from './tools/smart-read.js';
+import { projectRoot, setProjectRoot } from './utils/paths.js';
+
+const CROSS_PROJECT_CONFIG_FILE = '.devctx-projects.json';
+
+/**
+ * Load cross-project configuration.
+ * 
+ * @param {string} root - Project root
+ * @returns {object|null} Configuration or null if not found
+ */
+export const loadCrossProjectConfig = (root = projectRoot) => {
+  const configPath = path.join(root, CROSS_PROJECT_CONFIG_FILE);
+  
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Discover related projects from config.
+ * 
+ * @param {string} root - Project root
+ * @returns {Array<object>} Array of { name, path, type, description }
+ */
+export const discoverRelatedProjects = (root = projectRoot) => {
+  const config = loadCrossProjectConfig(root);
+  if (!config?.projects) return [];
+
+  const projects = [];
+
+  for (const project of config.projects) {
+    const projectPath = path.isAbsolute(project.path)
+      ? project.path
+      : path.resolve(root, project.path);
+
+    if (!fs.existsSync(projectPath)) continue;
+
+    const indexPath = path.join(projectPath, '.devctx/index.json');
+    const hasIndex = fs.existsSync(indexPath);
+
+    projects.push({
+      name: project.name,
+      path: projectPath,
+      type: project.type || 'related',
+      description: project.description || '',
+      hasIndex,
+    });
+  }
+
+  return projects;
+};
+
+/**
+ * Search across multiple related projects.
+ * 
+ * @param {string} query - Search query
+ * @param {object} options - Search options
+ * @returns {Promise<Array>} Results from all projects
+ */
+export const searchAcrossProjects = async (query, options = {}) => {
+  const {
+    root = projectRoot,
+    intent = 'implementation',
+    maxResultsPerProject = 5,
+    includeProjects = null,
+    excludeProjects = null,
+  } = options;
+
+  const relatedProjects = discoverRelatedProjects(root);
+  
+  const projectsToSearch = relatedProjects.filter(p => {
+    if (!p.hasIndex) return false;
+    if (includeProjects && !includeProjects.includes(p.name)) return false;
+    if (excludeProjects && excludeProjects.includes(p.name)) return false;
+    return true;
+  });
+
+  const results = [];
+
+  for (const project of projectsToSearch) {
+    try {
+      const searchResult = await smartSearch({
+        query,
+        cwd: project.path,
+        intent,
+        maxResults: maxResultsPerProject,
+      });
+
+      if (searchResult.results && searchResult.results.length > 0) {
+        results.push({
+          project: project.name,
+          projectPath: project.path,
+          projectType: project.type,
+          matches: searchResult.results.length,
+          results: searchResult.results.map(r => ({
+            ...r,
+            projectName: project.name,
+            absolutePath: path.join(project.path, r.file),
+          })),
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Read files from multiple projects.
+ * 
+ * @param {Array<object>} fileRefs - Array of { project, file, mode }
+ * @param {string} root - Project root
+ * @returns {Promise<Array>} Read results
+ */
+export const readAcrossProjects = async (fileRefs, root = projectRoot) => {
+  const relatedProjects = discoverRelatedProjects(root);
+  const projectMap = new Map(relatedProjects.map(p => [p.name, p]));
+
+  const originalRoot = projectRoot;
+  const results = [];
+
+  for (const ref of fileRefs) {
+    const project = projectMap.get(ref.project);
+    if (!project) {
+      results.push({
+        project: ref.project,
+        file: ref.file,
+        error: 'Project not found',
+      });
+      continue;
+    }
+
+    try {
+      setProjectRoot(project.path);
+
+      const readResult = await smartRead({
+        filePath: ref.file,
+        mode: ref.mode || 'outline',
+      });
+
+      results.push({
+        project: ref.project,
+        projectPath: project.path,
+        file: ref.file,
+        mode: readResult.mode,
+        content: readResult.content,
+        parser: readResult.parser,
+      });
+    } catch (err) {
+      results.push({
+        project: ref.project,
+        file: ref.file,
+        error: err.message,
+      });
+    }
+  }
+
+  setProjectRoot(originalRoot);
+  return results;
+};
+
+/**
+ * Find symbol definitions across projects.
+ * 
+ * @param {string} symbolName - Symbol to find
+ * @param {string} root - Project root
+ * @returns {Promise<Array>} Symbol locations across projects
+ */
+export const findSymbolAcrossProjects = async (symbolName, root = projectRoot) => {
+  const relatedProjects = discoverRelatedProjects(root).filter(p => p.hasIndex);
+  const results = [];
+
+  for (const project of relatedProjects) {
+    try {
+      const index = loadIndex(project.path);
+      if (!index?.files) continue;
+
+      for (const [filePath, fileInfo] of Object.entries(index.files)) {
+        if (!fileInfo.symbols) continue;
+
+        const matchingSymbols = fileInfo.symbols.filter(s => 
+          s.name === symbolName || s.name.includes(symbolName)
+        );
+
+        for (const symbol of matchingSymbols) {
+          results.push({
+            project: project.name,
+            projectPath: project.path,
+            projectType: project.type,
+            file: filePath,
+            symbol: symbol.name,
+            kind: symbol.kind,
+            line: symbol.line,
+            signature: symbol.signature,
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return results;
+};
+
+/**
+ * Get dependency graph across projects.
+ * 
+ * @param {string} root - Project root
+ * @returns {object} Cross-project dependency graph
+ */
+export const getCrossProjectDependencies = (root = projectRoot) => {
+  const relatedProjects = discoverRelatedProjects(root).filter(p => p.hasIndex);
+  const dependencies = {
+    projects: [],
+    edges: [],
+  };
+
+  for (const project of relatedProjects) {
+    dependencies.projects.push({
+      name: project.name,
+      path: project.path,
+      type: project.type,
+    });
+
+    try {
+      const index = loadIndex(project.path);
+      if (!index?.graph?.edges) continue;
+
+      for (const edge of index.graph.edges) {
+        if (edge.kind !== 'import') continue;
+
+        const fromAbs = path.join(project.path, edge.from);
+        const toAbs = path.join(project.path, edge.to);
+
+        const toProject = relatedProjects.find(p => 
+          toAbs.startsWith(p.path) && p.path !== project.path
+        );
+
+        if (toProject) {
+          const toRel = path.relative(toProject.path, toAbs);
+          dependencies.edges.push({
+            from: project.name,
+            fromFile: edge.from,
+            to: toProject.name,
+            toFile: toRel,
+            kind: 'cross-project-import',
+          });
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return dependencies;
+};
+
+/**
+ * Get statistics about cross-project usage.
+ * 
+ * @param {string} root - Project root
+ * @returns {object} Usage statistics
+ */
+export const getCrossProjectStats = (root = projectRoot) => {
+  const relatedProjects = discoverRelatedProjects(root);
+  const deps = getCrossProjectDependencies(root);
+
+  const stats = {
+    totalProjects: relatedProjects.length,
+    indexedProjects: relatedProjects.filter(p => p.hasIndex).length,
+    projectTypes: {},
+    crossProjectImports: deps.edges.length,
+    importsByProject: {},
+  };
+
+  for (const project of relatedProjects) {
+    const type = project.type || 'related';
+    stats.projectTypes[type] = (stats.projectTypes[type] || 0) + 1;
+  }
+
+  for (const edge of deps.edges) {
+    stats.importsByProject[edge.from] = (stats.importsByProject[edge.from] || 0) + 1;
+  }
+
+  return stats;
+};
+
+/**
+ * Create a sample cross-project configuration.
+ * 
+ * @param {string} root - Project root
+ * @returns {object} Sample configuration
+ */
+export const createSampleConfig = (root = projectRoot) => {
+  return {
+    version: '1.0',
+    projects: [
+      {
+        name: 'main-app',
+        path: '.',
+        type: 'main',
+        description: 'Main application',
+      },
+      {
+        name: 'shared-lib',
+        path: '../shared-lib',
+        type: 'library',
+        description: 'Shared utilities library',
+      },
+      {
+        name: 'api-service',
+        path: '../api-service',
+        type: 'service',
+        description: 'Backend API service',
+      },
+    ],
+    searchDefaults: {
+      maxResultsPerProject: 5,
+      includeTypes: ['main', 'library', 'service'],
+    },
+  };
+};