smart-context-mcp 1.3.0 → 1.4.0

package/src/tools/smart-edit.js

@@ -0,0 +1,105 @@
+import { readTextFile, writeTextFile } from '../utils/fs.js';
+import { recordToolUsage } from '../usage-feedback.js';
+import { recordDecision, DECISION_REASONS, EXPECTED_BENEFITS } from '../decision-explainer.js';
+import { recordDevctxOperation } from '../missed-opportunities.js';
+import { countTokens } from '../tokenCounter.js';
+import { persistMetrics } from '../metrics.js';
+
+export const smartEdit = ({ pattern, replacement, files, mode = 'literal', dryRun = false }) => {
+  const startTime = Date.now();
+  
+  recordDecision({
+    tool: 'smart_edit',
+    reason: DECISION_REASONS.BATCH_OPERATION,
+    benefit: EXPECTED_BENEFITS.EFFICIENCY,
+  });
+
+  recordDevctxOperation('smart_edit');
+
+  const results = [];
+  let totalMatches = 0;
+  let totalReplacements = 0;
+  
+  for (const filePath of files) {
+    try {
+      const { content } = readTextFile(filePath);
+      let newContent;
+      let matches = 0;
+
+      if (mode === 'regex') {
+        const regex = new RegExp(pattern, 'gm');
+        const matchesArray = content.match(regex);
+        matches = matchesArray ? matchesArray.length : 0;
+        newContent = content.replace(regex, replacement);
+      } else {
+        const parts = content.split(pattern);
+        matches = parts.length - 1;
+        newContent = parts.join(replacement);
+      }
+
+      if (matches > 0) {
+        if (!dryRun) {
+          writeTextFile(filePath, newContent);
+        }
+        
+        results.push({
+          file: filePath,
+          matches,
+          replaced: !dryRun,
+          preview: dryRun ? {
+            before: content.substring(0, 200),
+            after: newContent.substring(0, 200),
+          } : undefined,
+        });
+        
+        totalMatches += matches;
+        if (!dryRun) totalReplacements += matches;
+      } else {
+        results.push({
+          file: filePath,
+          matches: 0,
+          replaced: false,
+        });
+      }
+    } catch (error) {
+      results.push({
+        file: filePath,
+        error: error.message,
+      });
+    }
+  }
+
+  const response = {
+    success: true,
+    mode,
+    pattern,
+    dryRun,
+    totalFiles: files.length,
+    filesModified: results.filter(r => r.matches > 0).length,
+    totalMatches,
+    totalReplacements,
+    results,
+  };
+
+  const outputStr = JSON.stringify(response);
+  const tokens = countTokens(outputStr);
+
+  persistMetrics({
+    tool: 'smart_edit',
+    rawTokens: 0,
+    compressedTokens: tokens,
+    savedTokens: 0,
+    savingsPct: 0,
+    latencyMs: Date.now() - startTime,
+  });
+
+  recordToolUsage({
+    tool: 'smart_edit',
+    rawTokens: 0,
+    compressedTokens: tokens,
+    savedTokens: 0,
+    savingsPct: 0,
+  });
+
+  return response;
+};

package/src/tools/smart-read.js

@@ -70,11 +70,11 @@ const extractRange = (content, startLine, endLine) => {
   return truncate(numbered.join('\n'), 12000);
 };
 
-const lookupIndexLine = (fullPath, symbolName) => {
+const lookupIndexLine = (fullPath, symbolName, root = projectRoot) => {
   try {
-    const index = loadIndex(projectRoot);
+    const index = loadIndex(root);
     if (!index) return { line: undefined, used: false };
-    const relPath = path.relative(projectRoot, fullPath).replace(/\\/g, '/');
+    const relPath = path.relative(root, fullPath).replace(/\\/g, '/');
     const hits = queryIndex(index, symbolName);
     const match = hits.find((h) => h.path === relPath);
     return { line: match?.line, used: !!match };
@@ -255,6 +255,45 @@ export const grepSymbolInFile = async (absPath, symbol) => {
   }
 };
 
+export const grepMultipleSymbolsInFile = async (absPath, symbols) => {
+  if (symbols.length === 0) return {};
+  if (symbols.length === 1) {
+    const matches = await grepSymbolInFile(absPath, symbols[0]);
+    return { [symbols[0]]: matches };
+  }
+
+  try {
+    const args = ['--line-number', '--no-heading', '--fixed-strings', '--max-count', '5'];
+    for (const sym of symbols) {
+      args.push('-e', sym);
+    }
+    args.push(absPath);
+
+    const { stdout } = await execFile(rgPath, args, { timeout: 3000 });
+    const result = {};
+    for (const sym of symbols) result[sym] = [];
+
+    for (const line of stdout.split('\n').filter(Boolean)) {
+      const sep = line.indexOf(':');
+      if (sep === -1) continue;
+      const formatted = `${line.substring(0, sep)}|${line.substring(sep + 1)}`;
+      const content = line.substring(sep + 1);
+      
+      for (const sym of symbols) {
+        if (content.includes(sym)) {
+          result[sym].push(formatted);
+        }
+      }
+    }
+
+    return result;
+  } catch {
+    const result = {};
+    for (const sym of symbols) result[sym] = [];
+    return result;
+  }
+};
+
 const TYPE_REF_RE = /:\s*([A-Z][A-Za-z0-9_]+)|<([A-Z][A-Za-z0-9_]+)>|(?:extends|implements)\s+([A-Z][A-Za-z0-9_]+)/g;
 
 export const extractTypeReferences = (definitionText, index, relPath) => {
@@ -292,8 +331,10 @@ export const buildSymbolContext = async (fullPath, symbolNames, root) => {
   for (const caller of related.importedBy.slice(0, 5)) {
     const callerAbs = path.join(root, caller);
     if (!fs.existsSync(callerAbs)) continue;
+    
+    const matchesBySymbol = await grepMultipleSymbolsInFile(callerAbs, symbolNames);
     for (const sym of symbolNames) {
-      const matches = await grepSymbolInFile(callerAbs, sym);
+      const matches = matchesBySymbol[sym] || [];
       if (matches.length > 0) {
         sections.callers.push({ file: caller, symbol: sym, lines: matches.slice(0, 3) });
       }
@@ -303,8 +344,10 @@ export const buildSymbolContext = async (fullPath, symbolNames, root) => {
   for (const testFile of related.tests.slice(0, 3)) {
     const testAbs = path.join(root, testFile);
     if (!fs.existsSync(testAbs)) continue;
+    
+    const matchesBySymbol = await grepMultipleSymbolsInFile(testAbs, symbolNames);
     for (const sym of symbolNames) {
-      const matches = await grepSymbolInFile(testAbs, sym);
+      const matches = matchesBySymbol[sym] || [];
       if (matches.length > 0) {
         sections.tests.push({ file: testFile, symbol: sym, lines: matches.slice(0, 3) });
       }
@@ -365,11 +408,12 @@ const formatContextSections = (sections) => {
   return parts.length > 0 ? '\n' + parts.join('\n') : '';
 };
 
-export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine, symbol, maxTokens, context: includeContext }) => {
+export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine, symbol, maxTokens, context: includeContext, cwd }) => {
   let fullPath, content;
+  const effectiveRoot = cwd || projectRoot;
   
   try {
-    const result = readTextFile(filePath);
+    const result = readTextFile(filePath, effectiveRoot);
     fullPath = result.fullPath;
     content = result.content;
   } catch (error) {
@@ -400,6 +444,15 @@ export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine
     const r = cachedRange(content, startLine, endLine, fullPath, mtime);
     compressedText = r.text;
     cacheHit = r.cached;
+  } else if (mode === 'outline' && (startLine || endLine)) {
+    const lines = content.split('\n');
+    const start = Math.max(0, (startLine ?? 1) - 1);
+    const end = endLine ?? lines.length;
+    const rangeContent = lines.slice(start, end).join('\n');
+    const g = cachedGenerate(fullPath, extension, rangeContent, 'outline', mtime);
+    compressedText = g.text;
+    cacheHit = g.cached;
+    effectiveMode = 'outline';
   } else if (mode === 'symbol') {
     const sym = cachedSymbol(fullPath, content, symbol, mtime);
     compressedText = sym.text;
@@ -430,7 +483,7 @@ export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine
 
   if (mode === 'symbol' && includeContext && symbol) {
     const symbolNames = Array.isArray(symbol) ? symbol : [symbol];
-    const { sections, hints } = await buildSymbolContext(fullPath, symbolNames, projectRoot);
+    const { sections, hints } = await buildSymbolContext(fullPath, symbolNames, effectiveRoot);
     const contextText = formatContextSections(sections);
     if (contextText) compressedText += contextText;
     contextResult = {
@@ -461,7 +514,7 @@ export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine
   recordToolUsage({
     tool: 'smart_read',
     savedTokens: metrics.savedTokens,
-    target: path.relative(projectRoot, fullPath),
+    target: path.relative(effectiveRoot, fullPath),
   });
   
   // Record devctx operation for missed opportunity detection
@@ -482,7 +535,7 @@ export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine
   
   recordDecision({
     tool: 'smart_read',
-    action: `read ${path.relative(projectRoot, fullPath)} (${effectiveMode} mode)`,
+    action: `read ${path.relative(effectiveRoot, fullPath)} (${effectiveMode} mode)`,
     reason,
     alternative: 'Read (full file)',
     expectedBenefit,

package/src/tools/smart-search.js

@@ -11,6 +11,7 @@ import { truncate } from '../utils/text.js';
 import { recordToolUsage } from '../usage-feedback.js';
 import { recordDecision, DECISION_REASONS, EXPECTED_BENEFITS } from '../decision-explainer.js';
 import { recordDevctxOperation } from '../missed-opportunities.js';
+import { IGNORED_DIRS, IGNORED_FILE_NAMES } from '../config/ignored-paths.js';
 
 const execFile = promisify(execFileCallback);
 const supportedGlobs = [
@@ -19,8 +20,8 @@ const supportedGlobs = [
   '*.go', '*.rs', '*.java', '*.sh', '*.bash', '*.zsh', '*.tf', '*.tfvars', '*.hcl',
   'Dockerfile', 'Dockerfile.*',
 ];
-const ignoredDirs = ['node_modules', '.git', '.next', 'dist', 'build', 'coverage', '.venv', 'venv', '__pycache__', '.terraform'];
-const ignoredFileNames = new Set(['pnpm-lock.yaml', 'package-lock.json', 'yarn.lock', 'bun.lockb', 'npm-shrinkwrap.json']);
+const ignoredDirs = IGNORED_DIRS;
+const ignoredFileNames = new Set(IGNORED_FILE_NAMES);
 const fallbackExtensions = new Set(['.js', '.jsx', '.ts', '.tsx', '.json', '.mjs', '.cjs', '.py', '.toml', '.yaml', '.yml', '.md', '.graphql', '.gql', '.sql', '.go', '.rs', '.java', '.sh', '.bash', '.zsh', '.tf', '.tfvars', '.hcl']);
 const likelySourceExtensions = new Set(['.js', '.jsx', '.ts', '.tsx', '.py', '.graphql', '.gql', '.sql', '.go', '.rs', '.java', '.sh', '.bash', '.zsh']);
 const likelyConfigExtensions = new Set(['.json', '.toml', '.yaml', '.yml', '.tf', '.tfvars', '.hcl']);
@@ -127,6 +128,7 @@ const searchWithRipgrep = async (root, query) => {
       .filter((match) => !shouldIgnoreFile(match.file));
   } catch (error) {
     if (error.code === 1) return [];
+    console.error('[smart-search] ripgrep failed:', error.message, { code: error.code, signal: error.signal });
     return null;
   }
 };

package/src/tools/smart-status.js

@@ -0,0 +1,201 @@
+import { withStateDb } from '../storage/sqlite.js';
+import { recordToolUsage } from '../usage-feedback.js';
+import { recordDecision, DECISION_REASONS, EXPECTED_BENEFITS } from '../decision-explainer.js';
+import { recordDevctxOperation } from '../missed-opportunities.js';
+import { countTokens } from '../tokenCounter.js';
+
+const ACTIVE_SESSION_SCOPE = 'active';
+
+const getActiveSession = async () => {
+  return withStateDb((db) => {
+    let activeSessionId = db.prepare(`
+      SELECT session_id
+      FROM active_session
+      WHERE scope = ?
+    `).get(ACTIVE_SESSION_SCOPE)?.session_id;
+
+    if (!activeSessionId) {
+      const mostRecent = db.prepare(`
+        SELECT session_id
+        FROM sessions
+        ORDER BY updated_at DESC
+        LIMIT 1
+      `).get();
+      
+      if (!mostRecent) return null;
+      activeSessionId = mostRecent.session_id;
+    }
+
+    const row = db.prepare(`
+      SELECT session_id, goal, status, next_step, current_focus, why_blocked,
+             snapshot_json, completed_count, decisions_count, touched_files_count, updated_at
+      FROM sessions
+      WHERE session_id = ?
+    `).get(activeSessionId);
+
+    if (!row) return null;
+
+    const parseJsonField = (field) => {
+      if (!field) return [];
+      try {
+        return JSON.parse(field);
+      } catch {
+        return [];
+      }
+    };
+
+    const snapshot = parseJsonField(row.snapshot_json);
+
+    return {
+      sessionId: row.session_id,
+      goal: row.goal || 'Untitled session',
+      status: row.status || 'in_progress',
+      nextStep: row.next_step,
+      currentFocus: row.current_focus,
+      whyBlocked: row.why_blocked,
+      pinnedContext: snapshot.pinnedContext || [],
+      unresolvedQuestions: snapshot.unresolvedQuestions || [],
+      completed: snapshot.completed || [],
+      decisions: snapshot.decisions || [],
+      touchedFiles: snapshot.touchedFiles || [],
+      completedCount: row.completed_count || 0,
+      decisionsCount: row.decisions_count || 0,
+      touchedFilesCount: row.touched_files_count || 0,
+      updatedAt: row.updated_at,
+    };
+  });
+};
+
+const formatContextItem = (item, index, total) => {
+  const prefix = index === total - 1 ? '└─' : '├─';
+  return `${prefix} ${item}`;
+};
+
+const formatSection = (title, items, emptyMessage = 'None') => {
+  if (!items || items.length === 0) {
+    return `${title}:\n  ${emptyMessage}`;
+  }
+  
+  const formatted = items.map((item, i) => formatContextItem(item, i, items.length)).join('\n  ');
+  return `${title} (${items.length}):\n  ${formatted}`;
+};
+
+const compactPath = (filePath) => {
+  if (!filePath) return filePath;
+  const parts = filePath.split('/');
+  if (parts.length <= 3) return filePath;
+  return `.../${parts.slice(-3).join('/')}`;
+};
+
+export const smartStatus = async ({ format = 'detailed', maxItems = 10 } = {}) => {
+  const startTime = Date.now();
+
+  recordDecision({
+    tool: 'smart_status',
+    reason: DECISION_REASONS.CONTEXT_VISIBILITY,
+    benefit: EXPECTED_BENEFITS.TRANSPARENCY,
+  });
+
+  recordDevctxOperation('smart_status');
+
+  const session = await getActiveSession();
+
+  if (!session) {
+    const response = {
+      success: false,
+      message: 'No active session found',
+      hint: 'Use smart_summary with action=update to create a session',
+    };
+
+    recordToolUsage({
+      tool: 'smart_status',
+      rawTokens: 0,
+      compressedTokens: countTokens(JSON.stringify(response)),
+      savedTokens: 0,
+      savingsPct: 0,
+    });
+
+    return response;
+  }
+
+  const recentCompleted = session.completed.slice(-maxItems);
+  const recentDecisions = session.decisions.slice(-maxItems);
+  const recentFiles = session.touchedFiles.slice(-maxItems).map(compactPath);
+
+  let output;
+  
+  if (format === 'compact') {
+    output = {
+      sessionId: session.sessionId,
+      status: session.status,
+      nextStep: session.nextStep,
+      stats: {
+        completed: session.completedCount,
+        decisions: session.decisionsCount,
+        files: session.touchedFilesCount,
+      },
+      recentFiles: recentFiles.slice(-3),
+      updatedAt: session.updatedAt,
+    };
+  } else {
+    const sections = [
+      `📋 Session: ${session.sessionId}`,
+      `🎯 Goal: ${session.goal}`,
+      `📊 Status: ${session.status}`,
+      session.nextStep ? `⏭️  Next: ${session.nextStep}` : null,
+      session.currentFocus ? `🔍 Focus: ${session.currentFocus}` : null,
+      session.whyBlocked ? `🚫 Blocked: ${session.whyBlocked}` : null,
+      '',
+      formatSection('✅ Completed', recentCompleted, 'No tasks completed yet'),
+      '',
+      formatSection('💡 Key Decisions', recentDecisions, 'No decisions recorded yet'),
+      '',
+      formatSection('📁 Touched Files', recentFiles, 'No files modified yet'),
+      '',
+      session.pinnedContext.length > 0 ? formatSection('📌 Pinned Context', session.pinnedContext) : null,
+      session.unresolvedQuestions.length > 0 ? formatSection('❓ Unresolved Questions', session.unresolvedQuestions) : null,
+      '',
+      `📈 Totals: ${session.completedCount} completed, ${session.decisionsCount} decisions, ${session.touchedFilesCount} files`,
+      `🕐 Updated: ${new Date(session.updatedAt).toLocaleString()}`,
+    ].filter(Boolean).join('\n');
+
+    output = {
+      success: true,
+      sessionId: session.sessionId,
+      status: session.status,
+      summary: sections,
+      context: {
+        goal: session.goal,
+        nextStep: session.nextStep,
+        currentFocus: session.currentFocus,
+        whyBlocked: session.whyBlocked,
+        stats: {
+          completed: session.completedCount,
+          decisions: session.decisionsCount,
+          files: session.touchedFilesCount,
+        },
+        recent: {
+          completed: recentCompleted,
+          decisions: recentDecisions,
+          files: recentFiles,
+        },
+        pinned: session.pinnedContext,
+        questions: session.unresolvedQuestions,
+      },
+      updatedAt: session.updatedAt,
+    };
+  }
+
+  const outputStr = JSON.stringify(output);
+  const tokens = countTokens(outputStr);
+
+  recordToolUsage({
+    tool: 'smart_status',
+    rawTokens: 0,
+    compressedTokens: tokens,
+    savedTokens: 0,
+    savingsPct: 0,
+  });
+
+  return output;
+};

package/src/tools/smart-summary.js

@@ -1106,8 +1106,37 @@ export const smartSummary = async ({
   keepLatestMetrics,
   vacuum,
   apply,
+  goal,
+  status,
+  nextStep,
+  currentFocus,
+  whyBlocked,
+  pinnedContext,
+  unresolvedQuestions,
+  blockers,
+  completed,
+  decisions,
+  touchedFiles,
 } = {}) => {
   const startTime = Date.now();
+  
+  if (!update && (goal || status || nextStep || currentFocus || whyBlocked || 
+      pinnedContext || unresolvedQuestions || blockers || completed || decisions || touchedFiles)) {
+    update = {
+      goal,
+      status,
+      nextStep,
+      currentFocus,
+      whyBlocked,
+      pinnedContext,
+      unresolvedQuestions,
+      blockers,
+      completed,
+      decisions,
+      touchedFiles,
+    };
+  }
+  
   const mutationSafety = getMutationSafetyPolicy();
   const shouldBlockWrites = SUMMARY_WRITE_ACTIONS.has(action) && mutationSafety.shouldBlock;
   const allowReadSideEffects = !mutationSafety.shouldBlock;

package/src/usage-feedback.js

@@ -1,67 +1,28 @@
-/**
- * Usage feedback system - tracks devctx tool usage in current session
- * and provides visible feedback to users about what tools were used and tokens saved.
- * 
- * Enable with environment variable: DEVCTX_SHOW_USAGE=true
- * 
- * Auto-enabled for first 10 tool calls (onboarding mode), then auto-disables.
- * User can explicitly enable/disable at any time.
- */
-
 const sessionUsage = {
-  tools: new Map(), // toolName -> { count, savedTokens }
+  tools: new Map(),
   totalSavedTokens: 0,
-  enabled: false,
+  enabled: true,
   totalToolCalls: 0,
-  onboardingMode: true,
-  ONBOARDING_THRESHOLD: 10, // Auto-disable after 10 tool calls
 };
 
-/**
- * Check if usage feedback is enabled
- * 
- * Priority:
- * 1. Explicit env var (DEVCTX_SHOW_USAGE=true/false)
- * 2. Onboarding mode (first 10 tool calls)
- * 3. Default: disabled
- */
 export const isFeedbackEnabled = () => {
   const envValue = process.env.DEVCTX_SHOW_USAGE?.toLowerCase();
   
-  // Explicit enable
   if (envValue === 'true' || envValue === '1' || envValue === 'yes') {
     sessionUsage.enabled = true;
-    sessionUsage.onboardingMode = false;
     return true;
   }
   
-  // Explicit disable
   if (envValue === 'false' || envValue === '0' || envValue === 'no') {
     sessionUsage.enabled = false;
-    sessionUsage.onboardingMode = false;
     return false;
   }
   
-  // Onboarding mode: auto-enable for first N tool calls
-  if (sessionUsage.onboardingMode && sessionUsage.totalToolCalls < sessionUsage.ONBOARDING_THRESHOLD) {
-    sessionUsage.enabled = true;
-    return true;
-  }
-  
-  // After onboarding threshold, auto-disable
-  if (sessionUsage.onboardingMode && sessionUsage.totalToolCalls >= sessionUsage.ONBOARDING_THRESHOLD) {
-    sessionUsage.enabled = false;
-    sessionUsage.onboardingMode = false;
-  }
-  
-  return sessionUsage.enabled;
+  sessionUsage.enabled = true;
+  return true;
 };
 
-/**
- * Record tool usage for feedback
- */
 export const recordToolUsage = ({ tool, savedTokens = 0, target = null }) => {
-  // Increment total tool calls (for onboarding mode)
   sessionUsage.totalToolCalls += 1;
   
   if (!isFeedbackEnabled()) return;
@@ -75,24 +36,18 @@ export const recordToolUsage = ({ tool, savedTokens = 0, target = null }) => {
   sessionUsage.totalSavedTokens += savedTokens;
 };
 
-/**
- * Get current session usage stats
- */
 export const getSessionUsage = () => {
   return {
     tools: Array.from(sessionUsage.tools.entries()).map(([tool, stats]) => ({
       tool,
       count: stats.count,
       savedTokens: stats.savedTokens,
-      targets: stats.targets.slice(-3), // Last 3 targets only
+      targets: stats.targets.slice(-3),
     })),
     totalSavedTokens: sessionUsage.totalSavedTokens,
   };
 };
 
-/**
- * Format usage feedback as markdown
- */
 export const formatUsageFeedback = () => {
   if (!isFeedbackEnabled()) return '';
   
@@ -128,31 +83,18 @@ export const formatUsageFeedback = () => {
   }
   
   lines.push('');
-  
-  // Show onboarding message if in onboarding mode
-  if (sessionUsage.onboardingMode && sessionUsage.totalToolCalls < sessionUsage.ONBOARDING_THRESHOLD) {
-    const remaining = sessionUsage.ONBOARDING_THRESHOLD - sessionUsage.totalToolCalls;
-    lines.push(`*Onboarding mode: showing for ${remaining} more tool calls. To keep: \`export DEVCTX_SHOW_USAGE=true\`*`);
-  } else {
-    lines.push('*To disable this message: `export DEVCTX_SHOW_USAGE=false`*');
-  }
+  lines.push('*To disable this message: `export DEVCTX_SHOW_USAGE=false`*');
   
   return lines.join('\n');
 };
 
-/**
- * Reset session usage (for testing or manual reset)
- */
 export const resetSessionUsage = () => {
   sessionUsage.tools.clear();
   sessionUsage.totalSavedTokens = 0;
   sessionUsage.totalToolCalls = 0;
-  sessionUsage.onboardingMode = true;
+  sessionUsage.enabled = true;
 };
 
-/**
- * Format token count for display
- */
 const formatTokens = (tokens) => {
   if (tokens >= 1000000) {
     return `${(tokens / 1000000).toFixed(1)}M tokens`;
@@ -163,9 +105,6 @@ const formatTokens = (tokens) => {
   return `${tokens} tokens`;
 };
 
-/**
- * Truncate target path for display
- */
 const truncateTarget = (target) => {
   if (!target) return '';
   if (target.length <= 40) return target;