sfcc-dev-mcp 1.0.19 → 1.0.21

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

@@ -1,515 +0,0 @@
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('SFCC Development MCP Server - Documentation-Only Mode', () => {
-  let client;
-
-  before(async () => {
-    client = await connect('./aegis.config.docs-only.json');
-  });
-
-  after(async () => {
-    if (client?.connected) {
-      await client.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    // CRITICAL: Clear all buffers to prevent leaking into next tests
-    client.clearAllBuffers(); // Recommended - comprehensive protection
-  });
-
-  test('should successfully connect to server', async () => {
-    assert.ok(client.connected, 'Client should be connected');
-  });
-
-  test('should list available tools', async () => {
-    const tools = await client.listTools();
-    assert.ok(Array.isArray(tools), 'Tools should be an array');
-    assert.ok(tools.length > 0, 'Should have at least one tool');
-  });
-
-  test('should have all expected documentation tools', async () => {
-    const tools = await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // SFCC Documentation Tools
-    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('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');
-
-    // 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');
-    assert.ok(toolNames.includes('get_sfra_document'), 'Should have SFRA document tool');
-    assert.ok(toolNames.includes('search_sfra_documentation'), 'Should have SFRA search tool');
-    assert.ok(toolNames.includes('get_sfra_documents_by_category'), 'Should have SFRA category tool');
-    assert.ok(toolNames.includes('get_sfra_categories'), 'Should have SFRA categories tool');
-    
-    // Cartridge Generation Tools
-    assert.ok(toolNames.includes('generate_cartridge_structure'), 'Should have cartridge generation tool');
-  });
-
-  test('should NOT have log analysis tools in documentation-only mode', async () => {
-    const tools = await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // These tools should NOT be available without credentials
-    assert.ok(!toolNames.includes('get_latest_error'), 'Should NOT have log error tool');
-    assert.ok(!toolNames.includes('get_latest_info'), 'Should NOT have log info tool');
-    assert.ok(!toolNames.includes('get_latest_warn'), 'Should NOT have log warn tool');
-    assert.ok(!toolNames.includes('get_latest_debug'), 'Should NOT have log debug tool');
-    assert.ok(!toolNames.includes('summarize_logs'), 'Should NOT have log summary tool');
-    assert.ok(!toolNames.includes('search_logs'), 'Should NOT have log search tool');
-  });
-
-  test('should NOT have OCAPI tools in documentation-only mode', async () => {
-    const tools = await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // These tools should NOT be available without credentials
-    assert.ok(!toolNames.includes('get_system_object_definitions'), 'Should NOT have system object definitions tool');
-    assert.ok(!toolNames.includes('get_system_object_definition'), 'Should NOT have system object definition tool');
-    assert.ok(!toolNames.includes('search_system_object_attribute_definitions'), 'Should NOT have system object attribute search tool');
-    assert.ok(!toolNames.includes('get_code_versions'), 'Should NOT have code versions tool');
-    assert.ok(!toolNames.includes('activate_code_version'), 'Should NOT have code version activation tool');
-  });
-
-  test('should NOT have job log tools in documentation-only mode', async () => {
-    const tools = await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // These tools should NOT be available without credentials
-    assert.ok(!toolNames.includes('get_latest_job_log_files'), 'Should NOT have job log files tool');
-    assert.ok(!toolNames.includes('get_job_log_entries'), 'Should NOT have job log entries tool');
-    assert.ok(!toolNames.includes('search_job_logs'), 'Should NOT have job log search tool');
-    assert.ok(!toolNames.includes('get_job_execution_summary'), 'Should NOT have job execution summary tool');
-  });
-
-  test('should execute get_sfcc_class_info successfully', async () => {
-    const result = await client.callTool('get_sfcc_class_info', { 
-      className: 'Catalog'
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('Catalog'), 'Should contain catalog information');
-  });
-
-  test('should execute search_sfcc_classes successfully', async () => {
-    const result = await client.callTool('search_sfcc_classes', { 
-      query: 'product'
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('classes found') || result.content[0].text.includes('Product'), 'Should contain search results');
-  });
-
-  test('should execute get_available_sfra_documents successfully', async () => {
-    const result = await client.callTool('get_available_sfra_documents', {});
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('server'), 'Should contain server document name');
-  });
-
-  test('should execute get_sfra_document successfully', async () => {
-    const result = await client.callTool('get_sfra_document', { 
-      documentName: 'server'
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    assert.ok(result.content[0].text.includes('Server'), 'Should contain server documentation');
-  });
-
-  test('should execute generate_cartridge_structure successfully', async () => {
-    const result = await client.callTool('generate_cartridge_structure', { 
-      cartridgeName: 'test_cartridge',
-      targetPath: '/tmp/test-cartridge-output',
-      fullProjectSetup: false
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not be an error');
-    const responseText = result.content[0].text;
-    const parsedResponse = JSON.parse(responseText);
-    assert.equal(parsedResponse.success, true, 'Should indicate successful cartridge creation');
-  });
-
-  test('should handle invalid tool call gracefully', async () => {
-    const result = await client.callTool('invalid_tool_name', {});
-    assert.ok(result.isError, 'Should be marked as error');
-    assert.ok(result.content[0].text.includes('Unknown tool'), 'Should provide meaningful error message');
-  });
-
-  test('should handle missing required parameters gracefully', async () => {
-    const result = await client.callTool('get_sfcc_class_info', {}); // Missing className
-    assert.ok(result.isError, 'Should be marked as error');
-    assert.ok(result.content[0].text.includes('className'), 'Should indicate missing className parameter');
-  });
-
-  test('should validate tool schemas', async () => {
-    const tools = await client.listTools();
-    
-    for (const tool of tools) {
-      assert.ok(tool.name, 'Tool should have a name');
-      assert.ok(tool.description, 'Tool should have a description');
-      assert.ok(tool.inputSchema, 'Tool should have an input schema');
-      assert.equal(tool.inputSchema.type, 'object', 'Tool input schema should be object type');
-    }
-  });
-
-  // Advanced Node.js-specific test scenarios
-  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 = [];
-    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');
-      assert.ok(!result.isError, 'No concurrent call should error');
-    }
-
-    // Verify specific content for each call (more flexible checks)
-    assert.ok(results[0].content[0].text.includes('Catalog'), 'First call should return Catalog info');
-    assert.ok(results[1].content[0].text.includes('Product'), 'Second call should return Product info');
-    assert.ok(results[2].content[0].text.length > 100, 'Third call should return substantial search results');
-  });
-
-  test('should validate JSON structure of complex responses', async () => {
-    // Test SFRA search which returns complex JSON structure
-    const result = await client.callTool('search_sfra_documentation', { query: 'render' });
-    assert.ok(result.content, 'Should return content');
-    
-    const responseText = result.content[0].text;
-    
-    // Basic validation that response is parseable and structured
-    assert.ok(responseText.length > 0, 'Should have response content');
-    assert.ok(!result.isError, 'Should not have errors');
-    
-    // Try to parse as JSON - if it fails, that's the real issue
-    try {
-      const parsedResponse = JSON.parse(responseText);
-      assert.ok(parsedResponse, 'Should be parseable JSON');
-      assert.ok(Array.isArray(parsedResponse) || typeof parsedResponse === 'object', 'Should return structured data');
-    } catch {
-      // If it's not JSON, at least check it contains useful content
-      assert.ok(responseText.includes('render') || responseText.includes('sfra'), 'Response should be relevant to query');
-    }
-  });
-
-  test('should validate cartridge generation response structure', async () => {
-    const result = await client.callTool('generate_cartridge_structure', { 
-      cartridgeName: 'advanced_test_cartridge',
-      targetPath: '/tmp/advanced-test-output',
-      fullProjectSetup: false // Use false for more reliable testing
-    });
-    
-    assert.ok(result.content, 'Should return content');
-    assert.ok(!result.isError, 'Should not have errors');
-    
-    const responseText = result.content[0].text;
-    
-    // Basic validation - tool should return some content (test infrastructure has issues but tool works)
-    assert.ok(responseText.length > 0, 'Should have response 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(typeof responseText === 'string', 'Should return string content');
-    
-    // Test passes - the tool functionality is verified by aegis CLI tests
-    assert.ok(true, 'Cartridge generation tool responds (routing verified by CLI tests)');
-  });
-
-  test('should handle edge cases in search queries', async () => {
-    // Test empty query
-    const emptyResult = await client.callTool('search_sfcc_classes', { query: '' });
-    assert.ok(emptyResult.content, 'Should handle empty query gracefully');
-    
-    // Test special characters
-    const specialCharResult = await client.callTool('search_sfcc_classes', { query: '!@#$%' });
-    assert.ok(specialCharResult.content, 'Should handle special characters gracefully');
-    
-    // Test very long query
-    const longQuery = 'a'.repeat(1000);
-    const longQueryResult = await client.callTool('search_sfcc_classes', { query: longQuery });
-    assert.ok(longQueryResult.content, 'Should handle long queries gracefully');
-  });
-
-  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 () => {
-    const result = await client.callTool('list_sfcc_classes', {});
-    const responseSize = JSON.stringify(result).length;
-    
-    // Adjusted based on actual testing - SFCC class list is large but not as huge as initially expected
-    assert.ok(responseSize > 1000, 'SFCC class list should be substantial (>1KB)');
-    assert.ok(responseSize < 10000000, 'Response should be reasonable size (<10MB)');
-    
-    // Test that large responses are still valid JSON
-    assert.ok(result.content, 'Large response should still have valid structure');
-    assert.ok(result.content[0].text, 'Large response should contain text content');
-    
-    // Verify the response contains expected SFCC class information
-    const responseText = result.content[0].text;
-    assert.ok(responseText.includes('dw.'), 'Should contain SFCC dw.* classes');
-  });
-
-  // ==================================================================================
-  // COMPREHENSIVE TOOL SET VALIDATION TESTS (Focus on High-Level Tool Validation)
-  // ==================================================================================
-
-  test('should have exactly the expected tool set for docs-only mode', async () => {
-    const tools = await client.listTools();
-    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,
-      'list_sfcc_classes': true,
-      'search_sfcc_classes': true,
-      'search_sfcc_methods': true,
-      
-      // SFRA Documentation Tools (5)
-      'get_available_sfra_documents': true,
-      'get_sfra_document': true,
-      'get_sfra_categories': true,
-      '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
-    };
-
-    // Verify all expected tools are present
-    const toolNames = tools.map(tool => tool.name);
-    for (const expectedTool of Object.keys(expectedTools)) {
-      assert.ok(toolNames.includes(expectedTool), 
-        `Expected tool '${expectedTool}' should be available in docs-only mode`);
-    }
-
-    // Verify no unexpected tools are present
-    for (const actualTool of toolNames) {
-      assert.ok(expectedTools[actualTool], 
-        `Unexpected tool '${actualTool}' found in docs-only mode`);
-    }
-  });
-
-  test('should validate tool schemas have proper structure', async () => {
-    const tools = await client.listTools();
-    
-    for (const tool of tools) {
-      // Basic schema validation
-      assert.ok(tool.name, `Tool should have a name: ${JSON.stringify(tool)}`);
-      assert.ok(tool.description, `Tool '${tool.name}' should have a description`);
-      assert.ok(tool.inputSchema, `Tool '${tool.name}' should have an inputSchema`);
-      assert.equal(tool.inputSchema.type, 'object', `Tool '${tool.name}' inputSchema should be object type`);
-      
-      // Validate description provides usage guidance (flexible patterns)
-      const description = tool.description.toLowerCase();
-      const hasUsageGuidance = description.includes('use this when') || 
-                               description.includes('use this to') ||
-                               description.includes('use this for') ||
-                               description.includes('get a list') ||
-                               description.includes('get all') ||
-                               description.includes('retrieve') ||
-                               description.includes('search') ||
-                               description.includes('generate') ||
-                               description.length > 50; // Substantial description
-      assert.ok(hasUsageGuidance, 
-        `Tool '${tool.name}' should provide meaningful description or usage guidance. Got: "${tool.description}"`);
-
-      // Validate properties structure if present
-      if (tool.inputSchema.properties) {
-        assert.ok(typeof tool.inputSchema.properties === 'object',
-          `Tool '${tool.name}' properties should be an object`);
-      }
-
-      // Validate required array if present
-      if (tool.inputSchema.required) {
-        assert.ok(Array.isArray(tool.inputSchema.required),
-          `Tool '${tool.name}' required should be an array`);
-      }
-    }
-  });
-
-  test('should validate tool categorization and organization', async () => {
-    const tools = await client.listTools();
-    const toolsByCategory = {
-      sfcc_docs: [],
-      sfra_docs: [],
-      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('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.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(', ')}`);
-  });
-
-  test('should validate tool parameter schemas for consistency', async () => {
-    const tools = await client.listTools();
-    
-    // Group tools by common parameter patterns
-    const toolsWithQuery = tools.filter(tool => 
-      tool.inputSchema.properties?.query || tool.inputSchema.properties?.searchQuery);
-    const toolsWithClassName = tools.filter(tool => 
-      tool.inputSchema.properties?.className);
-
-    // Validate search/query tools have consistent schema patterns
-    for (const tool of toolsWithQuery) {
-      const queryProp = tool.inputSchema.properties?.query || tool.inputSchema.properties?.searchQuery;
-      assert.equal(queryProp.type, 'string', 
-        `Tool '${tool.name}' query parameter should be string type`);
-      assert.ok(queryProp.description, 
-        `Tool '${tool.name}' query parameter should have description`);
-    }
-
-    // Validate className tools have consistent patterns
-    for (const tool of toolsWithClassName) {
-      const classNameProp = tool.inputSchema.properties.className;
-      assert.equal(classNameProp.type, 'string', 
-        `Tool '${tool.name}' className parameter should be string type`);
-      assert.ok(classNameProp.description.includes('class'), 
-        `Tool '${tool.name}' className description should mention 'class'`);
-    }
-  });
-
-  test('should validate tools exclude unsupported functionality in docs-only mode', async () => {
-    const tools = await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // Tools that should NOT be available in docs-only mode
-    const excludedTools = [
-      // Log analysis tools (require WebDAV)
-      'get_latest_error', 'get_latest_warn', 'get_latest_info', 'get_latest_debug',
-      'search_logs', 'list_log_files', 'get_log_file_contents', 'summarize_logs',
-      
-      // Job log tools (require WebDAV)
-      'get_latest_job_log_files', 'get_job_log_entries', 'search_job_logs', 
-      'search_job_logs_by_name', 'get_job_execution_summary',
-      
-      // System object tools (require OCAPI)
-      'get_system_object_definitions', 'get_system_object_definition',
-      'search_system_object_attribute_definitions', 'search_system_object_attribute_groups',
-      'search_site_preferences', 'search_custom_object_attribute_definitions',
-      
-      // Code version tools (require OCAPI)
-      'get_code_versions', 'activate_code_version'
-    ];
-
-    for (const excludedTool of excludedTools) {
-      assert.ok(!toolNames.includes(excludedTool), 
-        `Tool '${excludedTool}' should NOT be available in docs-only mode`);
-    }
-  });
-
-  test('should validate MCP response format compliance across all tools', async () => {
-    // Test a representative sample from each category
-    const testTools = [
-      { name: 'get_sfcc_class_info', params: { className: 'Catalog' } },
-      { name: 'get_available_sfra_documents', params: {} },
-      { name: 'sync_agent_instructions', params: { destinationType: 'temp', dryRun: true } },
-      { name: 'list_sfcc_classes', params: {} }
-    ];
-
-    for (const toolTest of testTools) {
-      const result = await client.callTool(toolTest.name, toolTest.params);
-      
-      // Validate MCP response structure
-      assert.ok(typeof result === 'object', `${toolTest.name} should return object`);
-      assert.ok('content' in result, `${toolTest.name} should have content property`);
-      assert.ok(Array.isArray(result.content), `${toolTest.name} content should be array`);
-      assert.ok(result.content.length > 0, `${toolTest.name} should have content items`);
-      
-      // Validate content structure
-      const firstContent = result.content[0];
-      assert.ok('text' in firstContent, `${toolTest.name} should have text in content`);
-      assert.ok('type' in firstContent, `${toolTest.name} should have type in content`);
-      assert.equal(firstContent.type, 'text', `${toolTest.name} should have text type`);
-      
-      // Validate response is meaningful
-      assert.ok(typeof firstContent.text === 'string', 
-        `${toolTest.name} text should be string`);
-      assert.ok(firstContent.text.length > 0, 
-        `${toolTest.name} should return non-empty text`);
-    }
-  });
-
-  test('should validate error handling consistency across tool categories', async () => {
-    const errorTests = [
-      // Invalid parameters
-      { tool: 'get_sfcc_class_info', params: { className: 'NonExistentClass12345' }, expectGraceful: true },
-      { tool: 'search_sfcc_classes', params: { query: '' }, expectGraceful: true },
-      { tool: 'get_sfra_document', params: { documentName: 'nonexistent_doc' }, expectGraceful: true }
-    ];
-
-    for (const errorTest of errorTests) {
-      const result = await client.callTool(errorTest.tool, errorTest.params);
-      
-      // Should return meaningful response, not crash
-      assert.ok(result.content, `${errorTest.tool} should handle invalid input gracefully`);
-      assert.ok(result.content[0].text, `${errorTest.tool} should return meaningful error message`);
-      assert.ok(typeof result.content[0].text === 'string', 
-        `${errorTest.tool} error response should be string`);
-      assert.ok(result.content[0].text.length > 0, 
-        `${errorTest.tool} should return non-empty error response`);
-    }
-  });
-});

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

@@ -1,154 +0,0 @@
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('SFCC Development MCP Server - Full Mode with Credentials Tests (Tool Presence Only)', () => {
-  let client;
-  let toolsCache;
-
-  before(async () => {
-    client = await connect('./aegis.config.with-dw.json');
-  });
-
-  after(async () => {
-    if (client?.connected) {
-      await client.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    // CRITICAL: Clear all buffers to prevent leaking into next tests
-    client.clearAllBuffers(); // Recommended - comprehensive protection
-  });
-
-  test('should successfully connect to server with credentials', async () => {
-    assert.ok(client.connected, 'Client should be connected');
-  });
-
-  test('should list all available tools in full mode', async () => {
-    const tools = await client.listTools();
-    toolsCache = tools; // Cache for other tests
-    
-    assert.ok(Array.isArray(tools), 'Tools should be an array');
-    assert.ok(tools.length > 15, 'Should have more tools than documentation-only mode');
-  });
-
-  test('should have all documentation tools available', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // SFCC Documentation Tools
-    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');
-
-    // 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');
-    assert.ok(toolNames.includes('get_sfra_document'), 'Should have SFRA document tool');
-    
-    // Cartridge Generation Tools
-    assert.ok(toolNames.includes('generate_cartridge_structure'), 'Should have cartridge generation tool');
-  });
-
-  test('should have log analysis tools in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // Log analysis tools should be available with credentials
-    assert.ok(toolNames.includes('get_latest_error'), 'Should have log error tool');
-    assert.ok(toolNames.includes('get_latest_info'), 'Should have log info tool');
-    assert.ok(toolNames.includes('get_latest_warn'), 'Should have log warn tool');
-    assert.ok(toolNames.includes('get_latest_debug'), 'Should have log debug tool');
-    assert.ok(toolNames.includes('summarize_logs'), 'Should have log summary tool');
-    assert.ok(toolNames.includes('search_logs'), 'Should have log search tool');
-    assert.ok(toolNames.includes('list_log_files'), 'Should have log file listing tool');
-  });
-
-  test('should have OCAPI system object tools in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // System object tools should be available with credentials
-    assert.ok(toolNames.includes('get_system_object_definitions'), 'Should have system object definitions tool');
-    assert.ok(toolNames.includes('get_system_object_definition'), 'Should have system object definition tool');
-    assert.ok(toolNames.includes('search_system_object_attribute_definitions'), 'Should have system object attribute search tool');
-    assert.ok(toolNames.includes('search_system_object_attribute_groups'), 'Should have system object attribute groups search tool');
-    assert.ok(toolNames.includes('search_site_preferences'), 'Should have site preferences search tool');
-  });
-
-  test('should have code version tools in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // Code version tools should be available with credentials
-    assert.ok(toolNames.includes('get_code_versions'), 'Should have code versions tool');
-    assert.ok(toolNames.includes('activate_code_version'), 'Should have code version activation tool');
-  });
-
-  test('should have job log tools in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // Job log tools should be available with credentials
-    assert.ok(toolNames.includes('get_latest_job_log_files'), 'Should have job log files tool');
-    assert.ok(toolNames.includes('get_job_log_entries'), 'Should have job log entries tool');
-    assert.ok(toolNames.includes('search_job_logs'), 'Should have job log search tool');
-    assert.ok(toolNames.includes('search_job_logs_by_name'), 'Should have job log search by name tool');
-    assert.ok(toolNames.includes('get_job_execution_summary'), 'Should have job execution summary tool');
-  });
-
-  // NOTE: We intentionally do NOT test tool execution in full mode because:
-  // 1. The test credentials are not real SFCC instances
-  // 2. Tools would fail with authentication/connection errors  
-  // 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 40 tools available in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    
-    // 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 () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // WebDAV-dependent tools should be available
-    assert.ok(toolNames.includes('summarize_logs'), 'Should have summarize_logs tool');
-    assert.ok(toolNames.includes('get_log_file_contents'), 'Should have get_log_file_contents tool');
-  });
-
-  test('should have OCAPI-dependent tools (system objects)', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // OCAPI-dependent tools should be available
-    assert.ok(toolNames.includes('search_site_preferences'), 'Should have search_site_preferences tool');
-    assert.ok(toolNames.includes('search_custom_object_attribute_definitions'), 'Should have search_custom_object_attribute_definitions tool');
-  });
-
-  test('should include all docs-only tools in full mode', async () => {
-    const tools = toolsCache || await client.listTools();
-    const toolNames = tools.map(tool => tool.name);
-    
-    // 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_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 () => {
-    const tools = toolsCache || await client.listTools();
-    
-    for (const tool of tools) {
-      assert.ok(tool.name, `Tool should have a name: ${JSON.stringify(tool, null, 2)}`);
-      assert.ok(tool.description, `Tool ${tool.name} should have a description`);
-      assert.ok(tool.inputSchema, `Tool ${tool.name} should have an input schema`);
-      assert.equal(tool.inputSchema.type, 'object', `Tool ${tool.name} input schema should be object type`);
-    }
-  });
-});