smart-context-mcp 1.7.4 → 1.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-context-mcp",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "description": "MCP server that reduces agent token usage by 90% with intelligent context compression, task checkpoint persistence, and workflow-aware agent guidance.",
   "author": "Francisco Caballero Portero <fcp1978@hotmail.com>",
   "type": "module",

package/src/index-manager.js

@@ -0,0 +1,133 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile as execFileCallback } from 'node:child_process';
+import { promisify } from 'node:util';
+import { projectRoot } from './utils/paths.js';
+import { loadIndex, buildIndex as buildIndexCore } from './index.js';
+
+const execFile = promisify(execFileCallback);
+
+const INDEX_FRESHNESS_MS = 24 * 60 * 60 * 1000;
+const INDEX_BUILD_TIMEOUT_MS = 60000;
+
+const resolveMetadataPath = (root = projectRoot) => {
+  return path.join(root, '.devctx', 'index-meta.json');
+};
+
+const loadIndexMetadata = (root = projectRoot) => {
+  try {
+    const metaPath = resolveMetadataPath(root);
+    const raw = fs.readFileSync(metaPath, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+const saveIndexMetadata = (meta, root = projectRoot) => {
+  try {
+    const metaPath = resolveMetadataPath(root);
+    const dir = path.dirname(metaPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf8');
+  } catch (error) {
+    console.warn('Failed to save index metadata:', error.message);
+  }
+};
+
+const getGitHead = (root = projectRoot) => {
+  try {
+    const gitHeadPath = path.join(root, '.git', 'HEAD');
+    if (!fs.existsSync(gitHeadPath)) return null;
+    return fs.readFileSync(gitHeadPath, 'utf8').trim();
+  } catch {
+    return null;
+  }
+};
+
+const isIndexFresh = (meta, root = projectRoot) => {
+  if (!meta || !meta.builtAt) return false;
+  
+  const age = Date.now() - meta.builtAt;
+  if (age < INDEX_FRESHNESS_MS) return true;
+  
+  const currentHead = getGitHead(root);
+  if (currentHead && currentHead === meta.gitHead) return true;
+  
+  return false;
+};
+
+const timeout = (ms, message) => {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(message)), ms);
+  });
+};
+
+const isTestEnvironment = () => {
+  return process.env.NODE_ENV === 'test' || 
+         typeof process.env.NODE_TEST_CONTEXT !== 'undefined' ||
+         process.argv.some(arg => arg.includes('--test'));
+};
+
+export const ensureIndexReady = async (options = {}) => {
+  const { force = false, timeoutMs = INDEX_BUILD_TIMEOUT_MS, root = projectRoot, silent = isTestEnvironment() } = options;
+  
+  if (!force) {
+    const existingIndex = loadIndex(root);
+    if (existingIndex) {
+      const meta = loadIndexMetadata(root);
+      if (isIndexFresh(meta, root)) {
+        return { status: 'ready', cached: true };
+      }
+    }
+  }
+  
+  if (!silent) {
+    console.log('📦 Building search index (this may take 30-60s)...');
+  }
+  
+  try {
+    const buildPromise = buildIndexCore({ root, incremental: true });
+    const result = await Promise.race([
+      buildPromise,
+      timeout(timeoutMs, 'Index build timeout')
+    ]);
+    
+    saveIndexMetadata({
+      builtAt: Date.now(),
+      gitHead: getGitHead(root),
+      fileCount: result?.files?.length || 0,
+      version: result?.version
+    }, root);
+    
+    if (!silent) {
+      console.log('✅ Index ready');
+    }
+    return { status: 'built', cached: false, fileCount: result?.files?.length || 0 };
+  } catch (error) {
+    if (!silent) {
+      console.warn('⚠️ Index build failed, search will use fallback mode');
+    }
+    return { status: 'fallback', error: error.message };
+  }
+};
+
+export const getIndexStatus = (root = projectRoot) => {
+  const index = loadIndex(root);
+  if (!index) {
+    return { available: false, fresh: false, reason: 'not_built' };
+  }
+  
+  const meta = loadIndexMetadata(root);
+  const fresh = isIndexFresh(meta, root);
+  
+  return {
+    available: true,
+    fresh,
+    builtAt: meta?.builtAt,
+    fileCount: meta?.fileCount,
+    age: meta?.builtAt ? Date.now() - meta.builtAt : null
+  };
+};

package/src/tools/smart-context.js

@@ -6,6 +6,7 @@ import { smartSearch, VALID_INTENTS } from './smart-search.js';
 import { smartRead } from './smart-read.js';
 import { smartReadBatch } from './smart-read-batch.js';
 import { loadIndex, queryRelated, getGraphCoverage } from '../index.js';
+import { ensureIndexReady } from '../index-manager.js';
 import { projectRoot } from '../utils/paths.js';
 import { resolveSafePath } from '../utils/fs.js';
 import { countTokens } from '../tokenCounter.js';
@@ -409,6 +410,8 @@ export const smartContext = async ({
   if (diff) {
     const changed = await getChangedFiles(diff, root);
     
+    await ensureIndexReady({ root });
+    
     // Get detailed diff stats
     const detailedChanges = await getDetailedDiff(changed.ref, root);
     const index = loadIndex(root);
@@ -555,6 +558,8 @@ export const smartContext = async ({
     } catch { /* invalid path — skip */ }
   }
 
+  await ensureIndexReady({ root });
+  
   const index = loadIndex(root);
 
   if (prefetch && !diff) {

package/src/tools/smart-search.js

@@ -14,6 +14,7 @@ import { recordDevctxOperation } from '../missed-opportunities.js';
 import { IGNORED_DIRS, IGNORED_FILE_NAMES } from '../config/ignored-paths.js';
 import { buildMetricsDisplay } from '../utils/metrics-display.js';
 import { createProgressReporter } from '../streaming.js';
+import { ensureIndexReady } from '../index-manager.js';
 
 const execFile = promisify(execFileCallback);
 const supportedGlobs = [
@@ -354,6 +355,8 @@ export const smartSearch = async ({ query, cwd = '.', intent, _testForceWalk = f
     progress.report({ phase: 'ranking', rawMatches: rawMatches.length });
   }
   
+  await ensureIndexReady({ root: indexRoot });
+  
   try {
     loadedIndex = loadIndex(indexRoot);
     if (loadedIndex) {