smart-context-mcp 1.0.4 → 1.2.0

package/src/tools/smart-metrics.js

@@ -14,6 +14,7 @@ import {
   readMetricsEntries,
   resolveMetricsInput,
 } from '../metrics.js';
+import { analyzeAdoption } from '../analytics/adoption.js';
 
 const WINDOW_MS = {
   '24h': 24 * 60 * 60 * 1000,
@@ -197,6 +198,8 @@ export const smartMetrics = async ({
       .filter((entry) => (tool ? entry.tool === tool : true))
       .filter((entry) => (resolvedSessionId ? entry.sessionId === resolvedSessionId : true));
 
+    const adoption = analyzeAdoption(filteredEntries);
+    
     return {
       filePath: resolved.storagePath,
       storagePath: resolved.storagePath,
@@ -212,6 +215,7 @@ export const smartMetrics = async ({
       },
       invalidLines,
       summary: aggregateMetrics(filteredEntries),
+      adoption,
       latestEntries: buildLatestEntries(filteredEntries, latest),
     };
   }
@@ -229,6 +233,8 @@ export const smartMetrics = async ({
     window,
   });
 
+  const adoption = analyzeAdoption(entries);
+  
   return {
     filePath: resolved.storagePath,
     storagePath: resolved.storagePath,
@@ -244,6 +250,7 @@ export const smartMetrics = async ({
     },
     invalidLines,
     summary: aggregateMetrics(entries),
+    adoption,
     latestEntries: buildLatestEntries(entries, latest),
   };
 };

package/src/tools/smart-read-batch.js

@@ -18,6 +18,15 @@ export const smartReadBatch = async ({ files, maxTokens }) => {
         maxTokens: item.maxTokens,
       });
 
+      if (readResult.error) {
+        results.push({
+          filePath: item.path,
+          mode: item.mode ?? 'outline',
+          error: readResult.error,
+        });
+        continue;
+      }
+
       const itemTokens = countTokens(readResult.content);
 
       if (maxTokens && totalTokens + itemTokens > maxTokens && results.length > 0) {

package/src/tools/smart-read.js

@@ -363,7 +363,27 @@ const formatContextSections = (sections) => {
 };
 
 export const smartRead = async ({ filePath, mode = 'outline', startLine, endLine, symbol, maxTokens, context: includeContext }) => {
-  const { fullPath, content } = readTextFile(filePath);
+  let fullPath, content;
+  
+  try {
+    const result = readTextFile(filePath);
+    fullPath = result.fullPath;
+    content = result.content;
+  } catch (error) {
+    const errorMessage = error.message || String(error);
+    return {
+      error: errorMessage,
+      filePath,
+      mode,
+      metrics: buildMetrics({
+        tool: 'smart_read',
+        target: filePath,
+        rawText: '',
+        compressedText: errorMessage,
+      }),
+    };
+  }
+
   const extension = path.extname(fullPath).toLowerCase();
   const mtime = getFileMtime(fullPath);
 

package/src/tools/smart-shell.js

@@ -6,11 +6,21 @@ import { projectRoot } from '../utils/paths.js';
 import { pickRelevantLines, truncate, uniqueLines } from '../utils/text.js';
 
 const execFile = promisify(execFileCallback);
-const blockedPattern = /[|&;<>`\n\r]/;
+const isShellDisabled = () => process.env.DEVCTX_SHELL_DISABLED === 'true';
+const blockedPattern = /[|&;<>`\n\r$()]/;
 const allowedCommands = new Set(['pwd', 'ls', 'find', 'rg', 'git', 'npm', 'pnpm', 'yarn', 'bun']);
-const allowedGitSubcommands = new Set(['status', 'diff', 'show', 'log', 'branch', 'rev-parse']);
+const allowedGitSubcommands = new Set(['status', 'diff', 'show', 'log', 'branch', 'rev-parse', 'blame']);
 const allowedPackageManagerSubcommands = new Set(['test', 'run', 'lint', 'build', 'typecheck', 'check']);
-const safeRunScriptPattern = /^(test|lint|build|typecheck|check|smoke|verify)(:|$)/;
+const safeRunScriptPattern = /^(test|lint|build|typecheck|check|smoke|verify|eval)(:|$)/;
+const dangerousPatterns = [
+  /rm\s+-rf/i,
+  /sudo/i,
+  /curl.*\|/i,
+  /wget.*\|/i,
+  /eval/i,
+  /exec/i,
+];
+const MAX_COMMAND_LENGTH = 500;
 
 const tokenize = (command) => {
   const tokens = [];
@@ -67,12 +77,26 @@ const tokenize = (command) => {
 };
 
 const validateCommand = (command, tokens) => {
+  if (isShellDisabled()) {
+    return 'Shell execution is disabled (DEVCTX_SHELL_DISABLED=true)';
+  }
+
   if (!command.trim()) {
     return 'Command is empty';
   }
 
-  if (blockedPattern.test(command) || command.includes('$(')) {
-    return 'Shell operators are not allowed';
+  if (command.length > MAX_COMMAND_LENGTH) {
+    return `Command too long (max ${MAX_COMMAND_LENGTH} chars)`;
+  }
+
+  if (blockedPattern.test(command)) {
+    return 'Shell operators are not allowed (|, &, ;, <, >, `, $, (, ))';
+  }
+
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(command)) {
+      return `Dangerous pattern detected: ${pattern.source}`;
+    }
   }
 
   if (tokens.length === 0) {
@@ -82,11 +106,11 @@ const validateCommand = (command, tokens) => {
   const [baseCommand, subcommand, thirdToken] = tokens;
 
   if (!allowedCommands.has(baseCommand)) {
-    return `Command not allowed: ${baseCommand}`;
+    return `Command not allowed: ${baseCommand}. Allowed: ${[...allowedCommands].join(', ')}`;
   }
 
   if (baseCommand === 'git' && !allowedGitSubcommands.has(subcommand)) {
-    return `Git subcommand not allowed: ${subcommand ?? '(missing)'}`;
+    return `Git subcommand not allowed: ${subcommand ?? '(missing)'}. Allowed: ${[...allowedGitSubcommands].join(', ')}`;
   }
 
   if (baseCommand === 'find') {
@@ -99,11 +123,11 @@ const validateCommand = (command, tokens) => {
 
   if (['npm', 'pnpm', 'yarn', 'bun'].includes(baseCommand)) {
     if (!subcommand || !allowedPackageManagerSubcommands.has(subcommand)) {
-      return `Package manager subcommand not allowed: ${subcommand ?? '(missing)'}`;
+      return `Package manager subcommand not allowed: ${subcommand ?? '(missing)'}. Allowed: ${[...allowedPackageManagerSubcommands].join(', ')}`;
     }
 
     if (subcommand === 'run' && (!thirdToken || !safeRunScriptPattern.test(thirdToken))) {
-      return `Package manager script not allowed: ${thirdToken ?? '(missing)'}`;
+      return `Package manager script not allowed: ${thirdToken ?? '(missing)'}. Allowed pattern: ${safeRunScriptPattern.source}`;
     }
   }
 

package/src/tools/smart-turn.js

@@ -205,6 +205,7 @@ const startTurn = async ({
       })
     : null;
 
+
   return {
     phase: 'start',
     promptPreview: truncate(prompt, MAX_PROMPT_PREVIEW),

package/src/workflow-tracker-stub.js

@@ -0,0 +1,53 @@
+// Stub for workflow tracking (to be implemented in future version)
+// This avoids SQLite issues in tests while keeping the API available
+
+export const detectWorkflowType = () => null;
+export const getWorkflowBaseline = () => 0;
+export const startWorkflow = () => null;
+export const endWorkflow = () => null;
+export const getWorkflowMetrics = () => [];
+export const getWorkflowSummaryByType = () => [];
+export const autoTrackWorkflow = () => null;
+
+export const WORKFLOW_DEFINITIONS = {
+  debugging: {
+    name: 'Debugging',
+    description: 'Error-first, symbol-focused debugging workflow',
+    typicalTools: ['smart_turn', 'smart_search', 'smart_read', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 150000,
+    pattern: /debug|error|bug|fix|fail/i,
+  },
+  'code-review': {
+    name: 'Code Review',
+    description: 'Diff-aware, API-focused code review workflow',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_read', 'git_blame', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 200000,
+    pattern: /review|pr|pull.?request|approve/i,
+  },
+  refactoring: {
+    name: 'Refactoring',
+    description: 'Graph-aware, test-verified refactoring workflow',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_read', 'git_blame', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 180000,
+    pattern: /refactor|extract|rename|move|restructure/i,
+  },
+  testing: {
+    name: 'Testing',
+    description: 'Coverage-aware, TDD-friendly testing workflow',
+    typicalTools: ['smart_turn', 'smart_search', 'smart_read', 'smart_context', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 120000,
+    pattern: /test|spec|coverage|tdd/i,
+  },
+  architecture: {
+    name: 'Architecture Exploration',
+    description: 'Index-first, minimal-detail architecture exploration',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_search', 'smart_read', 'cross_project'],
+    minTools: 3,
+    baselineTokens: 300000,
+    pattern: /architect|explore|understand|structure|design/i,
+  },
+};

package/src/workflow-tracker.js

@@ -0,0 +1,410 @@
+import { withStateDb } from './storage/sqlite.js';
+
+const isWorkflowTrackingAvailable = () => {
+  try {
+    return withStateDb((db) => workflowTableExists(db));
+  } catch {
+    return false;
+  }
+};
+
+// Workflow definitions with typical tool sequences and baselines
+const WORKFLOW_DEFINITIONS = {
+  debugging: {
+    name: 'Debugging',
+    description: 'Error-first, symbol-focused debugging workflow',
+    typicalTools: ['smart_turn', 'smart_search', 'smart_read', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 150000, // Typical: read 10 full files, grep output, test logs
+    pattern: /debug|error|bug|fix|fail/i,
+  },
+  'code-review': {
+    name: 'Code Review',
+    description: 'Diff-aware, API-focused code review workflow',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_read', 'git_blame', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 200000, // Typical: read 15 full files, diff output, test logs
+    pattern: /review|pr|pull.?request|approve/i,
+  },
+  refactoring: {
+    name: 'Refactoring',
+    description: 'Graph-aware, test-verified refactoring workflow',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_read', 'git_blame', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 180000, // Typical: read 12 full files, dependency graph, test logs
+    pattern: /refactor|extract|rename|move|restructure/i,
+  },
+  testing: {
+    name: 'Testing',
+    description: 'Coverage-aware, TDD-friendly testing workflow',
+    typicalTools: ['smart_turn', 'smart_search', 'smart_read', 'smart_context', 'smart_shell'],
+    minTools: 3,
+    baselineTokens: 120000, // Typical: read 8 full files, test patterns, test logs
+    pattern: /test|spec|coverage|tdd/i,
+  },
+  architecture: {
+    name: 'Architecture Exploration',
+    description: 'Index-first, minimal-detail architecture exploration',
+    typicalTools: ['smart_turn', 'smart_context', 'smart_search', 'smart_read', 'cross_project'],
+    minTools: 3,
+    baselineTokens: 300000, // Typical: read 20 full files, explore structure
+    pattern: /architect|explore|understand|structure|design/i,
+  },
+};
+
+/**
+ * Detect workflow type based on session goal, tools used, and patterns
+ */
+export const detectWorkflowType = (sessionGoal, toolsUsed) => {
+  if (!sessionGoal && toolsUsed.length === 0) {
+    return null;
+  }
+
+  // Try to match based on session goal
+  if (sessionGoal) {
+    for (const [type, def] of Object.entries(WORKFLOW_DEFINITIONS)) {
+      if (def.pattern.test(sessionGoal)) {
+        return type;
+      }
+    }
+  }
+
+  // Try to match based on tools used
+  for (const [type, def] of Object.entries(WORKFLOW_DEFINITIONS)) {
+    const matchingTools = toolsUsed.filter((tool) => def.typicalTools.includes(tool));
+    if (matchingTools.length >= def.minTools) {
+      return type;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Calculate baseline tokens for a workflow type
+ */
+export const getWorkflowBaseline = (workflowType) => {
+  const def = WORKFLOW_DEFINITIONS[workflowType];
+  return def ? def.baselineTokens : 0;
+};
+
+/**
+ * Start tracking a workflow
+ */
+export const startWorkflow = (workflowType, sessionId, metadata = {}) => {
+  try {
+    return withStateDb((db) => {
+      if (!workflowTableExists(db)) {
+        return null;
+      }
+
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+      INSERT INTO workflow_metrics (
+        workflow_type,
+        session_id,
+        start_time,
+        baseline_tokens,
+        metadata_json,
+        created_at
+      ) VALUES (?, ?, ?, ?, ?, ?)
+    `);
+
+    const result = stmt.run(
+      workflowType,
+      sessionId,
+      now,
+      getWorkflowBaseline(workflowType),
+      JSON.stringify(metadata),
+      now,
+    );
+
+      return result.lastInsertRowid;
+    });
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * End tracking a workflow and calculate metrics
+ */
+export const endWorkflow = (workflowId) => {
+  try {
+    return withStateDb((db) => {
+      if (!workflowTableExists(db)) {
+        return null;
+      }
+
+    // Get workflow start time and session
+    const workflow = db
+      .prepare(
+        `
+      SELECT workflow_type, session_id, start_time, baseline_tokens
+      FROM workflow_metrics
+      WHERE workflow_id = ?
+    `,
+      )
+      .get(workflowId);
+
+    if (!workflow) {
+      throw new Error(`Workflow ${workflowId} not found`);
+    }
+
+    const now = new Date().toISOString();
+    const startTime = new Date(workflow.start_time);
+    const endTime = new Date(now);
+    const durationMs = endTime - startTime;
+
+    // Get all metrics for this session since workflow start
+    const metrics = db
+      .prepare(
+        `
+      SELECT tool, raw_tokens, compressed_tokens, saved_tokens
+      FROM metrics_events
+      WHERE session_id = ? AND created_at >= ?
+      ORDER BY created_at ASC
+    `,
+      )
+      .all(workflow.session_id, workflow.start_time);
+
+    // Calculate totals
+    const rawTokens = metrics.reduce((sum, m) => sum + (m.raw_tokens || 0), 0);
+    const compressedTokens = metrics.reduce((sum, m) => sum + (m.compressed_tokens || 0), 0);
+    const savedTokens = metrics.reduce((sum, m) => sum + (m.saved_tokens || 0), 0);
+    const savingsPct = rawTokens > 0 ? ((savedTokens / rawTokens) * 100).toFixed(2) : 0;
+
+    // Calculate vs baseline
+    const baselineTokens = workflow.baseline_tokens || 0;
+    const vsBaselinePct = baselineTokens > 0 ? (((baselineTokens - compressedTokens) / baselineTokens) * 100).toFixed(2) : 0;
+
+    // Get unique tools used
+    const toolsUsed = [...new Set(metrics.map((m) => m.tool))];
+
+    // Update workflow
+    const stmt = db.prepare(`
+      UPDATE workflow_metrics
+      SET end_time = ?,
+          duration_ms = ?,
+          tools_used_json = ?,
+          steps_count = ?,
+          raw_tokens = ?,
+          compressed_tokens = ?,
+          saved_tokens = ?,
+          savings_pct = ?,
+          vs_baseline_pct = ?
+      WHERE workflow_id = ?
+    `);
+
+    stmt.run(now, durationMs, JSON.stringify(toolsUsed), metrics.length, rawTokens, compressedTokens, savedTokens, savingsPct, vsBaselinePct, workflowId);
+
+      return {
+        workflowId,
+        workflowType: workflow.workflow_type,
+        durationMs,
+        toolsUsed,
+        stepsCount: metrics.length,
+        rawTokens,
+        compressedTokens,
+        savedTokens,
+        savingsPct: Number(savingsPct),
+        baselineTokens,
+        vsBaselinePct: Number(vsBaselinePct),
+      };
+    });
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Get workflow metrics summary
+ */
+export const getWorkflowMetrics = (options = {}) => {
+  try {
+    return withStateDb((db) => {
+      if (!workflowTableExists(db)) {
+        return [];
+      }
+    let query = `
+      SELECT 
+        workflow_id,
+        workflow_type,
+        session_id,
+        start_time,
+        end_time,
+        duration_ms,
+        tools_used_json,
+        steps_count,
+        raw_tokens,
+        compressed_tokens,
+        saved_tokens,
+        savings_pct,
+        baseline_tokens,
+        vs_baseline_pct,
+        metadata_json,
+        created_at
+      FROM workflow_metrics
+      WHERE 1=1
+    `;
+
+    const params = [];
+
+    if (options.workflowType) {
+      query += ' AND workflow_type = ?';
+      params.push(options.workflowType);
+    }
+
+    if (options.sessionId) {
+      query += ' AND session_id = ?';
+      params.push(options.sessionId);
+    }
+
+    if (options.completed !== undefined) {
+      if (options.completed) {
+        query += ' AND end_time IS NOT NULL';
+      } else {
+        query += ' AND end_time IS NULL';
+      }
+    }
+
+    query += ' ORDER BY created_at DESC';
+
+    if (options.limit) {
+      query += ' LIMIT ?';
+      params.push(options.limit);
+    }
+
+    const workflows = db.prepare(query).all(...params);
+
+      return workflows.map((w) => ({
+        ...w,
+        toolsUsed: JSON.parse(w.tools_used_json || '[]'),
+        metadata: JSON.parse(w.metadata_json || '{}'),
+      }));
+    });
+  } catch {
+    return [];
+  }
+};
+
+/**
+ * Get workflow summary by type
+ */
+export const getWorkflowSummaryByType = () => {
+  try {
+    return withStateDb((db) => {
+      if (!workflowTableExists(db)) {
+        return [];
+      }
+      const summary = db
+      .prepare(
+        `
+      SELECT 
+        workflow_type,
+        COUNT(*) as count,
+        SUM(raw_tokens) as total_raw_tokens,
+        SUM(compressed_tokens) as total_compressed_tokens,
+        SUM(saved_tokens) as total_saved_tokens,
+        AVG(savings_pct) as avg_savings_pct,
+        SUM(baseline_tokens) as total_baseline_tokens,
+        AVG(vs_baseline_pct) as avg_vs_baseline_pct,
+        AVG(duration_ms) as avg_duration_ms,
+        AVG(steps_count) as avg_steps_count
+      FROM workflow_metrics
+      WHERE end_time IS NOT NULL
+      GROUP BY workflow_type
+      ORDER BY count DESC
+    `,
+      )
+      .all();
+
+      return summary.map((s) => ({
+        ...s,
+        avgSavingsPct: Number(s.avg_savings_pct?.toFixed(2) || 0),
+        avgVsBaselinePct: Number(s.avg_vs_baseline_pct?.toFixed(2) || 0),
+        avgDurationMs: Math.round(s.avg_duration_ms || 0),
+        avgStepsCount: Math.round(s.avg_steps_count || 0),
+      }));
+    });
+  } catch {
+    return [];
+  }
+};
+
+/**
+ * Check if workflow_metrics table exists
+ */
+const workflowTableExists = (db) => {
+  try {
+    const result = db
+      .prepare(
+        `
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name='workflow_metrics'
+    `,
+      )
+      .get();
+    return Boolean(result);
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Auto-detect and track workflow from session
+ */
+export const autoTrackWorkflow = (sessionId, sessionGoal) => {
+  try {
+    return withStateDb((db) => {
+      // Check if table exists (migration v5)
+      if (!workflowTableExists(db)) {
+        return null;
+      }
+
+    // Check if workflow already tracked for this session
+    const existing = db
+      .prepare(
+        `
+      SELECT workflow_id
+      FROM workflow_metrics
+      WHERE session_id = ? AND end_time IS NULL
+      ORDER BY created_at DESC
+      LIMIT 1
+    `,
+      )
+      .get(sessionId);
+
+    if (existing) {
+      return existing.workflow_id;
+    }
+
+    // Get tools used so far in this session
+    const metrics = db
+      .prepare(
+        `
+      SELECT DISTINCT tool
+      FROM metrics_events
+      WHERE session_id = ?
+    `,
+      )
+      .all(sessionId);
+
+    const toolsUsed = metrics.map((m) => m.tool);
+
+    // Detect workflow type
+    const workflowType = detectWorkflowType(sessionGoal, toolsUsed);
+
+    if (!workflowType) {
+      return null;
+    }
+
+      // Start tracking
+      return startWorkflow(workflowType, sessionId, { autoDetected: true, goal: sessionGoal });
+    });
+  } catch {
+    return null;
+  }
+};
+
+export { WORKFLOW_DEFINITIONS };