sfcc-dev-mcp 1.0.15 → 1.0.19

package/tests/mcp/node/search-isml-elements.programmatic.test.js

@@ -0,0 +1,325 @@
+/**
+ * Programmatic tests for the MCP tool: search_isml_elements
+ * Mirrors YAML tests but adds deeper JSON parsing & resilience checks.
+ *
+ * Validates:
+ * 1. Tool is registered
+ * 2. Successful search with various queries (loop, format, cache, condition)
+ * 3. Search result structure (element, relevance, matchedSections, preview)
+ * 4. Category filtering
+ * 5. Result limit enforcement
+ * 6. Relevance scoring
+ * 7. Empty result handling
+ * 8. Error handling for missing parameters
+ * 9. Preview quality and content
+ */
+
+import { test, describe, before, after, beforeEach } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { connect } from 'mcp-aegis';
+
+describe('search_isml_elements (programmatic)', () => {
+  let client;
+  const CONFIG = './aegis.config.docs-only.json';
+
+  before(async () => {
+    client = await connect(CONFIG);
+  });
+
+  after(async () => {
+    if (client?.connected) {
+      await client.disconnect();
+    }
+  });
+
+  beforeEach(() => {
+    client.clearAllBuffers();
+  });
+
+  const TOOL_NAME = 'search_isml_elements';
+  const RESULT_KEYS = ['document', 'relevance', 'matchedSections', 'preview'];
+  const ELEMENT_KEYS = ['name', 'title', 'description', 'category', 'filename'];
+
+  test('tool should be registered', async () => {
+    const tools = await client.listTools();
+    const names = tools.map(t => t.name);
+    assert.ok(names.includes(TOOL_NAME), 'Tool not found in listTools');
+  });
+
+  async function invoke(query, options = {}) {
+    const result = await client.callTool(TOOL_NAME, { query, ...options });
+    return { result, raw: result.content[0]?.text };
+  }
+
+  function safeParseResults(raw) {
+    let results;
+    try {
+      results = JSON.parse(raw);
+    } catch (err) {
+      assert.fail(`Failed to parse response as JSON: ${err.message}\nRaw: ${raw.substring(0, 500)}`);
+    }
+    assert.ok(Array.isArray(results), 'Parsed results should be array');
+    return results;
+  }
+
+  test('search for loop-related elements', async () => {
+    const { result, raw } = await invoke('loop');
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should find loop-related elements');
+    
+    // Check if isloop is in results
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('isloop'), 'Should include isloop element');
+  });
+
+  test('search for formatting elements', async () => {
+    const { result, raw } = await invoke('format');
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should find formatting-related elements');
+    
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('isprint'), 'Should include isprint element');
+  });
+
+  test('search for cache elements', async () => {
+    const { result, raw } = await invoke('cache');
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should find cache-related elements');
+    
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('iscache'), 'Should include iscache element');
+  });
+
+  test('search for conditional elements', async () => {
+    const { result, raw } = await invoke('condition');
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should find conditional-related elements');
+    
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('isif'), 'Should include isif element');
+  });
+
+  test('search result structure validation', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    for (const searchResult of results.slice(0, 5)) {
+      // Check top-level keys
+      for (const key of RESULT_KEYS) {
+        assert.ok(Object.prototype.hasOwnProperty.call(searchResult, key), `Result should have ${key}`);
+      }
+      
+      // Check document structure
+      for (const key of ELEMENT_KEYS) {
+        assert.ok(Object.prototype.hasOwnProperty.call(searchResult.document, key), `Document should have ${key}`);
+      }
+      
+      // Check types
+      assert.ok(typeof searchResult.relevance === 'number', 'Relevance should be number');
+      assert.ok(Array.isArray(searchResult.matchedSections), 'matchedSections should be array');
+      assert.ok(typeof searchResult.preview === 'string', 'Preview should be string');
+    }
+  });
+
+  test('relevance scoring is present and positive', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    for (const result of results) {
+      assert.ok(result.relevance > 0, `Relevance should be positive, got ${result.relevance}`);
+    }
+  });
+
+  test('results sorted by relevance (descending)', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    if (results.length > 1) {
+      const relevances = results.map(r => r.relevance);
+      for (let i = 0; i < relevances.length - 1; i++) {
+        assert.ok(relevances[i] >= relevances[i + 1], `Results should be sorted by relevance descending`);
+      }
+    }
+  });
+
+  test('filter search by category', async () => {
+    const { result, raw } = await invoke('condition', { category: 'control-flow' });
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should find elements in control-flow category');
+    
+    // All results should be control-flow category
+    for (const searchResult of results) {
+      assert.equal(searchResult.document.category, 'control-flow', 'All results should be control-flow category');
+    }
+  });
+
+  test('respect limit parameter', async () => {
+    const { result, raw } = await invoke('element', { limit: 5 });
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    assert.ok(results.length <= 5, `Should respect limit of 5, got ${results.length}`);
+  });
+
+  test('preview snippets are present and reasonable', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    for (const searchResult of results.slice(0, 5)) {
+      assert.ok(searchResult.preview.length >= 50, `Preview should be at least 50 chars, got ${searchResult.preview.length}`);
+      assert.ok(searchResult.preview.length <= 300, `Preview should be at most 300 chars, got ${searchResult.preview.length}`);
+    }
+  });
+
+  test('matchedSections array structure', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    for (const searchResult of results) {
+      assert.ok(Array.isArray(searchResult.matchedSections), 'matchedSections should be array');
+      // Array may be empty or contain strings
+      if (searchResult.matchedSections.length > 0) {
+        assert.ok(searchResult.matchedSections.every(s => typeof s === 'string'), 'All matchedSections should be strings');
+      }
+    }
+  });
+
+  test('return empty array for no matches', async () => {
+    const { result, raw } = await invoke('zzznothingfound');
+    assert.equal(result.isError, false, 'Should not be error for no matches');
+    
+    const results = safeParseResults(raw);
+    assert.equal(results.length, 0, 'Should return empty array for no matches');
+  });
+
+  test('error for missing query parameter', async () => {
+    const result = await client.callTool(TOOL_NAME, {});
+    assert.equal(result.isError, true, 'Should be error for missing query');
+    assert.match(result.content[0].text, /query/i, 'Error should mention query');
+  });
+
+  test('case insensitive search', async () => {
+    const lowerResults = safeParseResults((await invoke('loop')).raw);
+    const upperResults = safeParseResults((await invoke('LOOP')).raw);
+    
+    assert.equal(upperResults.length, lowerResults.length, 'Case should not affect result count');
+  });
+
+  test('partial word matching', async () => {
+    const { raw } = await invoke('scri');
+    const results = safeParseResults(raw);
+    
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('isscript'), 'Should find isscript with partial match');
+  });
+
+  test('search for scripting elements', async () => {
+    const { result, raw } = await invoke('script');
+    assert.equal(result.isError, false, 'Should not be error');
+    
+    const results = safeParseResults(raw);
+    const elementNames = results.map(r => r.document.name);
+    assert.ok(elementNames.includes('isscript'), 'Should include isscript');
+  });
+
+  test('multiple category filtering combinations', async () => {
+    const categories = ['control-flow', 'output', 'scripting'];
+    
+    for (const category of categories) {
+      const { result, raw } = await invoke('element', { category });
+      assert.equal(result.isError, false, `Should search in ${category} category`);
+      
+      const results = safeParseResults(raw);
+      if (results.length > 0) {
+        for (const searchResult of results) {
+          assert.equal(searchResult.document.category, category, `All results should be ${category} category`);
+        }
+      }
+    }
+  });
+
+  test('filename pattern in results', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    
+    for (const searchResult of results.slice(0, 5)) {
+      assert.match(searchResult.document.filename, /^[a-z0-9-]+\.md$/, 'Filename should be kebab-case .md');
+    }
+  });
+
+  test('round-trip JSON parse reproducibility', async () => {
+    const { raw } = await invoke('loop');
+    const results = safeParseResults(raw);
+    const roundTrip = JSON.parse(JSON.stringify(results));
+    assert.deepEqual(roundTrip, results, 'Round trip serialization must preserve results');
+  });
+
+  test('negative path: invalid method should return JSON-RPC error', async () => {
+    const response = await client.sendMessage({
+      jsonrpc: '2.0',
+      id: 'bad-method-1',
+      method: 'tools/call_WRONG',
+      params: { name: TOOL_NAME, arguments: { query: 'loop' } }
+    });
+    assert.ok(response.error, 'Expected JSON-RPC error object');
+    assert.match(response.error.message || '', /method/i, 'Error message should mention method');
+  });
+
+  test('performance: response time under 1500ms', async () => {
+    const start = Date.now();
+    await invoke('loop');
+    const duration = Date.now() - start;
+    assert.ok(duration < 1500, `Response should be under 1500ms, got ${duration}ms`);
+  });
+
+  test('extraneous parameters are ignored', async () => {
+    const { result, raw } = await invoke('loop', { unused: 'value', extra: 123 });
+    assert.equal(result.isError, false, 'Should ignore extraneous params');
+    const results = safeParseResults(raw);
+    assert.ok(results.length > 0, 'Should still return results');
+  });
+
+  test('default limit behavior (should have reasonable max)', async () => {
+    const { raw } = await invoke('element');
+    const results = safeParseResults(raw);
+    
+    // Default limit should be reasonable (not thousands of results)
+    assert.ok(results.length <= 50, `Default limit should be reasonable, got ${results.length} results`);
+  });
+
+  test('query with special characters', async () => {
+    const { result } = await invoke('loop-test');
+    assert.equal(result.isError, false, 'Should handle special characters in query');
+  });
+
+  test('very short query (1 char)', async () => {
+    const { result } = await invoke('l');
+    assert.equal(result.isError, false, 'Should handle very short query');
+  });
+
+  test('very long query', async () => {
+    const longQuery = 'loop iteration control flow template rendering scripting';
+    const { result, raw } = await invoke(longQuery);
+    assert.equal(result.isError, false, 'Should handle long query');
+    const results = safeParseResults(raw);
+    assert.ok(results.length >= 0, 'Should return results for long query');
+  });
+
+  test('search result consistency across invocations', async () => {
+    const first = safeParseResults((await invoke('loop')).raw);
+    const second = safeParseResults((await invoke('loop')).raw);
+    
+    assert.equal(second.length, first.length, 'Result count should be consistent');
+    assert.deepEqual(second.map(r => r.document.name), first.map(r => r.document.name), 'Result order should be consistent');
+  });
+});

package/tests/mcp/node/search-sfcc-classes.docs-only.programmatic.test.js

@@ -72,9 +72,7 @@ describe('search_sfcc_classes Programmatic Tests', () => {
         // SFCC includes multiple namespaces
         assert.ok(
           className.startsWith('dw.') || 
-          className.startsWith('TopLevel.') || 
-          className.startsWith('best-practices.') || 
-          className.startsWith('sfra.'),
+          className.startsWith('TopLevel.'),
           `Class name "${className}" should start with recognized namespace`
         );
         assert.ok(className.includes('catalog'), 'Results should be relevant to query');
@@ -158,13 +156,11 @@ describe('search_sfcc_classes Programmatic Tests', () => {
         // All results should be valid class names
         classArray.forEach(className => {
           assert.equal(typeof className, 'string', 'Should be string');
-          // SFCC includes dw.*, TopLevel.*, best-practices.*, and sfra.* classes
+          // SFCC class names should only include SFCC namespaces
           assert.ok(
             className.startsWith('dw.') || 
-            className.startsWith('TopLevel.') || 
-            className.startsWith('best-practices.') || 
-            className.startsWith('sfra.'),
-            `Class name "${className}" should start with dw., TopLevel., best-practices., or sfra.`
+            className.startsWith('TopLevel.'),
+            `Class name "${className}" should start with dw. or TopLevel.`
           );
         });
       });
@@ -275,7 +271,7 @@ describe('search_sfcc_classes Programmatic Tests', () => {
       
       classArray.forEach(className => {
         // Validate class name format - updated for all SFCC namespaces
-        assert.match(className, /^(dw\.|TopLevel\.|best-practices\.|sfra\.)[a-zA-Z0-9_./-]+$/, 
+        assert.match(className, /^(dw\.|TopLevel\.)[a-zA-Z0-9_./-]+$/, 
           `Class name "${className}" should follow valid pattern`);
         
         // Should not contain spaces or invalid characters

package/tests/mcp/node/search-sfcc-methods.docs-only.programmatic.test.js

@@ -236,9 +236,7 @@ describe('search_sfcc_methods Programmatic Tests', () => {
         methodArray.forEach(methodData => {
           assert.ok(
             methodData.className.startsWith('dw_') || 
-            methodData.className.startsWith('TopLevel.') || 
-            methodData.className.startsWith('best-practices.') || 
-            methodData.className.startsWith('sfra.'),
+            methodData.className.startsWith('TopLevel.'),
             `Class name "${methodData.className}" should start with recognized namespace`
           );
         });
@@ -383,11 +381,11 @@ describe('search_sfcc_methods Programmatic Tests', () => {
   describe('Consistency and Reliability', () => {
     test('should return consistent results across multiple calls', async () => {
       const methodName = 'getValue';
-      const results = await Promise.all([
-        client.callTool('search_sfcc_methods', { methodName }),
-        client.callTool('search_sfcc_methods', { methodName }),
-        client.callTool('search_sfcc_methods', { methodName })
-      ]);
+
+      const results = [];
+      for (let i = 0; i < 3; i++) {
+        results.push(await client.callTool('search_sfcc_methods', { methodName }));
+      }
       
       // All results should be successful
       results.forEach(result => {
@@ -417,7 +415,7 @@ describe('search_sfcc_methods Programmatic Tests', () => {
           `Class name "${methodData.className}" should not be excessively long`);
         
         // Validate class name format
-        assert.match(methodData.className, /^(dw_|TopLevel\.|best-practices\.|sfra\.)[a-zA-Z0-9_./-]+$/, 
+        assert.match(methodData.className, /^(dw_|TopLevel\.)[a-zA-Z0-9_./-]+$/, 
           `Class name "${methodData.className}" should follow valid pattern`);
         
         // Validate method name format

package/tests/mcp/node/tools.docs-only.programmatic.test.js

@@ -40,12 +40,9 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
     assert.ok(toolNames.includes('search_sfcc_methods'), 'Should have SFCC method search tool');
     assert.ok(toolNames.includes('list_sfcc_classes'), 'Should have SFCC class list tool');
     assert.ok(toolNames.includes('get_sfcc_class_documentation'), 'Should have SFCC class documentation tool');
-    
-    // Best Practices Tools
-    assert.ok(toolNames.includes('get_available_best_practice_guides'), 'Should have best practices list tool');
-    assert.ok(toolNames.includes('get_best_practice_guide'), 'Should have best practice guide tool');
-    assert.ok(toolNames.includes('search_best_practices'), 'Should have best practices search tool');
-    assert.ok(toolNames.includes('get_hook_reference'), 'Should have hook reference tool');
+
+    // Agent Instructions Tool
+    assert.ok(toolNames.includes('sync_agent_instructions'), 'Should have agent instructions sync tool');
     
     // SFRA Documentation Tools
     assert.ok(toolNames.includes('get_available_sfra_documents'), 'Should have SFRA documents list tool');
@@ -114,24 +111,6 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
     assert.ok(result.content[0].text.includes('classes found') || result.content[0].text.includes('Product'), 'Should contain search results');
   });
 
-  test('should execute get_available_best_practice_guides successfully', async () => {
-    const result = await client.callTool('get_available_best_practice_guides', {});
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('cartridge_creation'), 'Should contain guide names like cartridge_creation');
-  });
-
-  test('should execute get_best_practice_guide successfully', async () => {
-    const result = await client.callTool('get_best_practice_guide', { 
-      guideName: 'cartridge_creation'
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('cartridge'), 'Should contain cartridge creation guide');
-  });
-
   test('should execute get_available_sfra_documents successfully', async () => {
     const result = await client.callTool('get_available_sfra_documents', {});
     
@@ -188,16 +167,18 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
   });
 
   // Advanced Node.js-specific test scenarios
-  test('should handle concurrent tool calls efficiently', async () => {
-    const concurrentCalls = [
-      client.callTool('get_sfcc_class_info', { className: 'Catalog' }),
-      client.callTool('get_sfcc_class_info', { className: 'Product' }),
-      client.callTool('search_sfcc_classes', { query: 'catalog' }),
-      client.callTool('search_sfcc_classes', { query: 'order' }),
-      client.callTool('get_available_best_practice_guides', {})
+  test('should handle multiple tool calls efficiently', async () => {
+    const calls = [
+      { toolName: 'get_sfcc_class_info', args: { className: 'Catalog' } },
+      { toolName: 'get_sfcc_class_info', args: { className: 'Product' } },
+      { toolName: 'search_sfcc_classes', args: { query: 'catalog' } },
+      { toolName: 'search_sfcc_classes', args: { query: 'order' } },
     ];
 
-    const results = await Promise.all(concurrentCalls);
+    const results = [];
+    for (const { toolName, args } of calls) {
+      results.push(await client.callTool(toolName, args));
+    }
     
     for (const result of results) {
       assert.ok(result.content, 'Each concurrent call should return content');
@@ -270,24 +251,11 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
     assert.ok(longQueryResult.content, 'Should handle long queries gracefully');
   });
 
-  test('should validate best practice guide content structure', async () => {
-    const guideName = 'cartridge_creation'; // Test just one to keep test focused
-    
-    const result = await client.callTool('get_best_practice_guide', { guideName });
-    assert.ok(result.content, `Should return content for ${guideName} guide`);
-    assert.ok(!result.isError, `Should not error for ${guideName} guide`);
-    
-    const content = result.content[0].text;
-    
-    // Basic validation - tool should return some content
-    assert.ok(typeof content === 'string', 'Should return string content');
-    
-    // Due to test client routing issues, we just verify we got a response
-    // The aegis CLI tests prove the tool actually works correctly
-    assert.ok(content.length >= 0, 'Should return some response');
-    
-    // Test passes - the tool functionality is verified by aegis CLI tests  
-    assert.ok(true, 'Best practice guide tool responds (routing verified by CLI tests)');
+  test('should execute sync_agent_instructions successfully', async () => {
+    const result = await client.callTool('sync_agent_instructions', { destinationType: 'temp', dryRun: true });
+    assert.ok(result.content, 'Should return content');
+    assert.ok(!result.isError, 'Should not error');
+    assert.ok(typeof result.content[0].text === 'string', 'Should return string content');
   });
 
   test('should measure and validate response sizes', async () => {
@@ -313,9 +281,13 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
 
   test('should have exactly the expected tool set for docs-only mode', async () => {
     const tools = await client.listTools();
-    assert.equal(tools.length, 15, 'Should have exactly 15 tools in docs-only mode');
+    assert.equal(tools.length, 18, 'Should have exactly 18 tools in docs-only mode');
 
     const expectedTools = {
+      // Agent Instructions (2)
+      'sync_agent_instructions': true,
+      'disable_agent_sync': true,
+
       // SFCC Documentation Tools (5)
       'get_sfcc_class_info': true,
       'get_sfcc_class_documentation': true,
@@ -323,12 +295,6 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
       'search_sfcc_classes': true,
       'search_sfcc_methods': true,
       
-      // Best Practices Tools (4)
-      'get_available_best_practice_guides': true,
-      'get_best_practice_guide': true,
-      'search_best_practices': true,
-      'get_hook_reference': true,
-      
       // SFRA Documentation Tools (5)
       'get_available_sfra_documents': true,
       'get_sfra_document': true,
@@ -336,6 +302,13 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
       'get_sfra_documents_by_category': true,
       'search_sfra_documentation': true,
       
+      // ISML Documentation Tools (5)
+      'list_isml_elements': true,
+      'get_isml_element': true,
+      'search_isml_elements': true,
+      'get_isml_elements_by_category': true,
+      'get_isml_categories': true,
+      
       // Cartridge Generation Tools (1)
       'generate_cartridge_structure': true
     };
@@ -396,31 +369,36 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
     const tools = await client.listTools();
     const toolsByCategory = {
       sfcc_docs: [],
-      best_practices: [],
       sfra_docs: [],
-      cartridge_gen: []
+      isml_docs: [],
+      cartridge_gen: [],
+      agent_instructions: []
     };
 
     // Categorize tools based on naming patterns
     for (const tool of tools) {
       if (tool.name.includes('sfcc_class') || tool.name.includes('sfcc_method') || tool.name === 'list_sfcc_classes') {
         toolsByCategory.sfcc_docs.push(tool.name);
-      } else if (tool.name.includes('best_practice') || tool.name.includes('hook_reference')) {
-        toolsByCategory.best_practices.push(tool.name);
       } else if (tool.name.includes('sfra')) {
         toolsByCategory.sfra_docs.push(tool.name);
+      } else if (tool.name.includes('isml')) {
+        toolsByCategory.isml_docs.push(tool.name);
       } else if (tool.name.includes('cartridge')) {
         toolsByCategory.cartridge_gen.push(tool.name);
+      } else if (tool.name.includes('agent_instructions')) {
+        toolsByCategory.agent_instructions.push(tool.name);
       }
     }
 
     // Validate expected counts per category
     assert.equal(toolsByCategory.sfcc_docs.length, 5, 
       `Should have 5 SFCC documentation tools, got: ${toolsByCategory.sfcc_docs.join(', ')}`);
-    assert.equal(toolsByCategory.best_practices.length, 4, 
-      `Should have 4 best practices tools, got: ${toolsByCategory.best_practices.join(', ')}`);
     assert.equal(toolsByCategory.sfra_docs.length, 5, 
       `Should have 5 SFRA documentation tools, got: ${toolsByCategory.sfra_docs.join(', ')}`);
+    assert.equal(toolsByCategory.isml_docs.length, 5, 
+      `Should have 5 ISML documentation tools, got: ${toolsByCategory.isml_docs.join(', ')}`);
+    assert.equal(toolsByCategory.agent_instructions.length, 1, 
+      `Should have 1 agent instructions tool, got: ${toolsByCategory.agent_instructions.join(', ')}`);
     assert.equal(toolsByCategory.cartridge_gen.length, 1, 
       `Should have 1 cartridge generation tool, got: ${toolsByCategory.cartridge_gen.join(', ')}`);
   });
@@ -486,8 +464,8 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
     // Test a representative sample from each category
     const testTools = [
       { name: 'get_sfcc_class_info', params: { className: 'Catalog' } },
-      { name: 'get_available_best_practice_guides', params: {} },
       { name: 'get_available_sfra_documents', params: {} },
+      { name: 'sync_agent_instructions', params: { destinationType: 'temp', dryRun: true } },
       { name: 'list_sfcc_classes', params: {} }
     ];
 
@@ -519,7 +497,6 @@ describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
       // Invalid parameters
       { tool: 'get_sfcc_class_info', params: { className: 'NonExistentClass12345' }, expectGraceful: true },
       { tool: 'search_sfcc_classes', params: { query: '' }, expectGraceful: true },
-      { tool: 'get_best_practice_guide', params: { guideName: 'nonexistent_guide' }, expectGraceful: true },
       { tool: 'get_sfra_document', params: { documentName: 'nonexistent_doc' }, expectGraceful: true }
     ];
 

package/tests/mcp/node/tools.full-mode.programmatic.test.js

@@ -41,10 +41,9 @@ describe('SFCC Development MCP Server - Full Mode with Credentials Tests (Tool P
     assert.ok(toolNames.includes('get_sfcc_class_info'), 'Should have SFCC class info tool');
     assert.ok(toolNames.includes('search_sfcc_classes'), 'Should have SFCC class search tool');
     assert.ok(toolNames.includes('list_sfcc_classes'), 'Should have SFCC class list tool');
-    
-    // Best Practices Tools  
-    assert.ok(toolNames.includes('get_available_best_practice_guides'), 'Should have best practices list tool');
-    assert.ok(toolNames.includes('get_best_practice_guide'), 'Should have best practice guide tool');
+
+    // Agent Instructions Tool
+    assert.ok(toolNames.includes('sync_agent_instructions'), 'Should have agent instructions sync tool');
     
     // SFRA Documentation Tools
     assert.ok(toolNames.includes('get_available_sfra_documents'), 'Should have SFRA documents list tool');
@@ -107,11 +106,11 @@ describe('SFCC Development MCP Server - Full Mode with Credentials Tests (Tool P
   // 3. This test suite is designed to verify tool PRESENCE, not functionality
   // 4. Tool functionality testing should be done against real SFCC development instances
 
-  test('should have exactly 36 tools available in full mode', async () => {
+  test('should have exactly 40 tools available in full mode', async () => {
     const tools = toolsCache || await client.listTools();
     
-    // Full mode should have exactly 36 tools (same count as YAML test)
-    assert.equal(tools.length, 36, `Should have exactly 36 tools, got ${tools.length}`);
+    // Full mode should have exactly 40 tools
+    assert.equal(tools.length, 40, `Should have exactly 40 tools, got ${tools.length}`);
   });
 
   test('should have WebDAV-dependent tools (log analysis)', async () => {
@@ -138,8 +137,8 @@ describe('SFCC Development MCP Server - Full Mode with Credentials Tests (Tool P
     
     // Verify that docs-only tools are NOT missing in full mode
     assert.ok(toolNames.includes('search_sfra_documentation'), 'Should have search_sfra_documentation tool');
-    assert.ok(toolNames.includes('get_best_practice_guide'), 'Should have get_best_practice_guide tool');
     assert.ok(toolNames.includes('get_sfcc_class_info'), 'Should have get_sfcc_class_info tool');
+    assert.ok(toolNames.includes('sync_agent_instructions'), 'Should have sync_agent_instructions tool');
   });
 
   test('should validate all tool schemas in full mode', async () => {

package/tests/mcp/yaml/activate-code-version.full-mode.test.mcp.yml

@@ -334,7 +334,7 @@ tests:
           content:
             match:arrayElements:
               type: "text"
-              text: "match:regex:Error[\\s\\S]*(404|not found|invalid)[\\s\\S]*"
+              text: "match:contains:Invalid code version ID format"
           isError: true
       stderr: "toBeEmpty"
     performance:
@@ -455,7 +455,7 @@ tests:
           content:
             match:arrayElements:
               type: "text"
-              text: "match:regex:Error[\\s\\S]*(404|not found)[\\s\\S]*"
+              text: "match:contains:Invalid code version ID format"
           isError: true
       stderr: "toBeEmpty"
     performance: