@vibecheckai/cli 3.5.1 → 3.5.2

package/mcp-server/deprecation-middleware.js

@@ -0,0 +1,282 @@
+/**
+ * Tool Deprecation Middleware
+ * 
+ * Resolves deprecated tool names to their new equivalents while emitting warnings.
+ * Old names work for one version cycle, then are removed.
+ * 
+ * Warning format: { code: "DEPRECATED_TOOL", message: "use vibecheck.ctx" }
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load registry
+let registry = null;
+
+function loadRegistry() {
+  if (registry) return registry;
+  
+  const registryPath = path.join(__dirname, '..', 'registry', 'tools.json');
+  try {
+    registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+    return registry;
+  } catch (err) {
+    console.error(`[deprecation-middleware] Failed to load registry: ${err.message}`);
+    return null;
+  }
+}
+
+// Build deprecation map from registry
+function buildDeprecationMap() {
+  const reg = loadRegistry();
+  if (!reg?.deprecated?.tools) return new Map();
+  
+  const map = new Map();
+  for (const entry of reg.deprecated.tools) {
+    map.set(entry.oldName, {
+      newName: entry.newName,
+      deprecatedIn: entry.deprecatedIn,
+      removedIn: entry.removedIn,
+      message: entry.message,
+    });
+  }
+  return map;
+}
+
+// Lazily build the map
+let deprecationMap = null;
+
+function getDeprecationMap() {
+  if (!deprecationMap) {
+    deprecationMap = buildDeprecationMap();
+  }
+  return deprecationMap;
+}
+
+// Warning codes
+const WARNING_CODES = {
+  DEPRECATED_TOOL: 'DEPRECATED_TOOL',
+  TOOL_REMOVED: 'TOOL_REMOVED',
+  UNKNOWN_TOOL: 'UNKNOWN_TOOL',
+};
+
+/**
+ * Create a deprecation warning object
+ */
+function createWarning(code, message, meta = {}) {
+  return {
+    code,
+    message,
+    ...meta,
+  };
+}
+
+/**
+ * Resolve a tool name, handling deprecation
+ * 
+ * @param {string} toolName - The requested tool name
+ * @param {string} [currentVersion] - Current version for removal checking
+ * @returns {{ resolvedName: string, warnings: Array<{code: string, message: string}>, isBlocked: boolean }}
+ */
+function resolveToolName(toolName, currentVersion = '4.0.0') {
+  const warnings = [];
+  const map = getDeprecationMap();
+  
+  // Check if this is a deprecated tool
+  const deprecation = map.get(toolName);
+  
+  if (deprecation) {
+    // Check if it's been removed
+    if (currentVersion >= deprecation.removedIn) {
+      warnings.push(createWarning(
+        WARNING_CODES.TOOL_REMOVED,
+        `Tool '${toolName}' was removed in v${deprecation.removedIn}. ${deprecation.message}`,
+        {
+          oldName: toolName,
+          newName: deprecation.newName,
+          removedIn: deprecation.removedIn,
+        }
+      ));
+      return {
+        resolvedName: null,
+        warnings,
+        isBlocked: true,
+      };
+    }
+    
+    // Emit deprecation warning
+    warnings.push(createWarning(
+      WARNING_CODES.DEPRECATED_TOOL,
+      `Tool '${toolName}' is deprecated. ${deprecation.message}`,
+      {
+        oldName: toolName,
+        newName: deprecation.newName,
+        deprecatedIn: deprecation.deprecatedIn,
+        removedIn: deprecation.removedIn,
+      }
+    ));
+    
+    return {
+      resolvedName: deprecation.newName,
+      warnings,
+      isBlocked: false,
+    };
+  }
+  
+  // Not deprecated, return as-is
+  return {
+    resolvedName: toolName,
+    warnings,
+    isBlocked: false,
+  };
+}
+
+/**
+ * Transform arguments for deprecated tool migrations
+ * Some tools need argument transformation when migrating
+ */
+function transformArgs(oldName, newName, args) {
+  const transformations = {
+    // conductor tools consolidation
+    'vibecheck_conductor_register': (a) => ({ ...a, operation: 'register' }),
+    'vibecheck_conductor_acquire_lock': (a) => ({ ...a, operation: 'acquire_lock' }),
+    'vibecheck_conductor_release_lock': (a) => ({ ...a, operation: 'release_lock' }),
+    'vibecheck_conductor_propose': (a) => ({ ...a, operation: 'propose' }),
+    'vibecheck_conductor_terminate': (a) => ({ ...a, operation: 'terminate' }),
+    
+    // set_strictness to firewall
+    'set_strictness': (a) => ({ 
+      action: 'config',
+      strictness: a.level,
+      projectPath: a.projectPath,
+    }),
+    
+    // ai_test to reality with agent mode
+    'vibecheck.ai_test': (a) => ({
+      url: a.url,
+      agentMode: true,
+      goal: a.goal,
+      maxPages: a.maxActions || 50,
+    }),
+  };
+  
+  const transform = transformations[oldName];
+  if (transform) {
+    return transform(args);
+  }
+  
+  return args;
+}
+
+/**
+ * Middleware wrapper for tool handlers
+ * Intercepts calls, resolves deprecation, transforms args, and injects warnings
+ * 
+ * @param {Function} handler - The original tool handler
+ * @param {Object} options - Middleware options
+ * @returns {Function} - Wrapped handler
+ */
+function withDeprecationMiddleware(handler, options = {}) {
+  const { currentVersion = '4.0.0' } = options;
+  
+  return async function deprecationMiddlewareHandler(toolName, args, context = {}) {
+    // Resolve the tool name
+    const { resolvedName, warnings, isBlocked } = resolveToolName(toolName, currentVersion);
+    
+    // If blocked (removed), return error with warnings
+    if (isBlocked) {
+      return {
+        isError: true,
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            error: `Tool '${toolName}' has been removed`,
+            warnings,
+            migration: warnings[0]?.newName 
+              ? `Use '${warnings[0].newName}' instead` 
+              : 'See documentation for migration guide',
+          }, null, 2),
+        }],
+        warnings,
+      };
+    }
+    
+    // Transform args if needed
+    const transformedArgs = transformArgs(toolName, resolvedName, args);
+    
+    // Call the actual handler
+    const result = await handler(resolvedName, transformedArgs, context);
+    
+    // Inject warnings into result if any
+    if (warnings.length > 0) {
+      return {
+        ...result,
+        warnings,
+      };
+    }
+    
+    return result;
+  };
+}
+
+/**
+ * Get all deprecated tools info for documentation
+ */
+function getDeprecationInfo() {
+  const reg = loadRegistry();
+  if (!reg?.deprecated?.tools) return [];
+  
+  return reg.deprecated.tools.map(entry => ({
+    oldName: entry.oldName,
+    newName: entry.newName,
+    deprecatedIn: entry.deprecatedIn,
+    removedIn: entry.removedIn,
+    message: entry.message,
+    status: entry.removedIn <= '4.0.0' ? 'removed' : 'deprecated',
+  }));
+}
+
+/**
+ * Check if a tool name is deprecated
+ */
+function isDeprecated(toolName) {
+  const map = getDeprecationMap();
+  return map.has(toolName);
+}
+
+/**
+ * Get the canonical tool name (resolves aliases and deprecations)
+ */
+function getCanonicalName(toolName) {
+  const { resolvedName } = resolveToolName(toolName);
+  return resolvedName;
+}
+
+// ES Module exports
+export {
+  resolveToolName,
+  transformArgs,
+  withDeprecationMiddleware,
+  getDeprecationInfo,
+  isDeprecated,
+  getCanonicalName,
+  WARNING_CODES,
+  // For testing
+  buildDeprecationMap,
+  createWarning,
+  getDeprecationMap,
+};
+
+export default {
+  resolveToolName,
+  transformArgs,
+  withDeprecationMiddleware,
+  getDeprecationInfo,
+  isDeprecated,
+  getCanonicalName,
+  WARNING_CODES,
+};

package/mcp-server/handlers/index.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Handlers Exports
+ */
+
+export {
+  handleToolRequest,
+  getAllTools,
+  getToolByName,
+  listToolNames,
+  getToolsByTier,
+  getToolsByCategory,
+  validateRegistry,
+} from "./tool-handler";
+
+export { default as ToolHandler } from "./tool-handler";