diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8c58845..87560bd 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -85,54 +85,73 @@ jobs:
           body: |
             ## 🚀 swagger-coverage-cli v${{ env.NEW_VERSION }}
             
-            ### ✨ Features
+            ### ✨ New Features
+            - **🌐 Multi-Protocol Support**: Native support for REST (OpenAPI/Swagger), gRPC (Protocol Buffers), and GraphQL schemas
+            - **🔄 Mixed API Analysis**: Process multiple API specifications with different protocols in a single run  
+            - **🎯 Protocol-Aware Matching**: Intelligent request matching tailored to each API protocol's characteristics
+            - **📊 Unified Reporting**: Generate consolidated HTML reports with protocol-specific insights and color coding
+            - **⚡ Universal CLI**: Single interface works across all supported protocols with consistent syntax
+            
+            ### 🎨 Enhanced Features
             - **Smart Endpoint Mapping**: Intelligent endpoint matching with status code prioritization enabled by default
             - **Enhanced Path Matching**: Improved handling of path parameters with different naming conventions
             - **Confidence Scoring**: Match quality assessment with 0.0-1.0 confidence scores
             - **Status Code Intelligence**: Prioritizes successful (2xx) codes over error codes for better coverage
-            - **Multi-API Support**: Process multiple Swagger/OpenAPI specifications in a single run
-            - **Unified Reporting**: Generate combined coverage reports with individual API metrics
-            - **Format Support**: YAML, JSON, and CSV file formats supported
-            - **Enhanced HTML Reports**: Clean, accessible reports with confidence indicators
+            - **Multi-API Support**: Process multiple API specifications in a single run
+            - **Enhanced HTML Reports**: Interactive reports with protocol identification and color coding
+            
+            ### 🎯 Protocol Support
+            
+            #### 📋 REST/OpenAPI
+            - OpenAPI v2/v3 specifications (YAML/JSON)
+            - Smart path matching with parameter variations
+            - Request body and query parameter validation
+            - Multiple status codes per operation
+            
+            #### ⚡ gRPC
+            - Protocol Buffer (.proto) file parsing
+            - Service and method extraction
+            - HTTP/2 path mapping (/package.service/method)
+            - Content-type validation (application/grpc)
             
-            ### 🚀 Smart Mapping Benefits
-            - **Improved Coverage Accuracy**: Smart mapping significantly improves coverage detection
-            - **Status Code Prioritization**: Prioritizes 2xx → 4xx → 5xx for better matching
-            - **Path Intelligence**: Handles parameter variations like `/users/{id}` vs `/users/{userId}`
-            - **Confidence Assessment**: Shows match quality to help identify reliable matches
-            - **Default Behavior**: No flags required - smart mapping works automatically
+            #### 🔀 GraphQL  
+            - GraphQL schema (.graphql/.gql) parsing
+            - Query, mutation, and subscription extraction
+            - Type system with arguments and unions
+            - Unified /graphql endpoint handling
+            
+            ### 🚀 Usage Examples
+            ```bash
+            # Single protocol APIs
+            swagger-coverage-cli api.yaml collection.json           # OpenAPI/REST
+            swagger-coverage-cli service.proto collection.json     # gRPC
+            swagger-coverage-cli schema.graphql collection.json    # GraphQL
+            
+            # Mixed protocol APIs (Enterprise-ready)
+            swagger-coverage-cli "api.yaml,service.proto,schema.graphql" collection.json
+            
+            # All existing options work across protocols
+            swagger-coverage-cli "api.yaml,service.proto" collection.json --verbose --strict-body
+            ```
             
             ### 🔧 Compatibility
             - ✅ Maintains backwards compatibility with existing workflows
-            - ✅ Node.js 14+ required
+            - ✅ Node.js 14+ required  
             - ✅ NPM package available globally
             - ✅ Smart mapping enabled by default
+            - ✅ All existing CLI options work with new protocols
             
             ### 📦 Installation
             ```bash
             npm install -g swagger-coverage-cli@${{ env.NEW_VERSION }}
             ```
             
-            ### 🎯 Usage Examples
-            ```bash
-            # Smart mapping enabled by default
-            swagger-coverage-cli api-spec.yaml collection.json
-            
-            # With verbose output to see smart mapping statistics
-            swagger-coverage-cli api-spec.yaml collection.json --verbose
-            
-            # Multiple APIs with smart mapping
-            swagger-coverage-cli api1.yaml,api2.yaml,api3.json collection.json
-            
-            # Works with Newman reports too
-            swagger-coverage-cli api-spec.yaml newman-report.json --newman
-            ```
-            
             ### 🧪 Quality Assurance
-            - **130 Tests**: Comprehensive test suite covering all smart mapping scenarios
-            - **38 Smart Mapping Tests**: Dedicated tests for status code priority, path matching, confidence scoring
+            - **147 Tests**: Comprehensive test suite covering all protocols and scenarios
+            - **19 Test Suites**: Dedicated test coverage for each protocol and integration scenarios
             - **Edge Case Coverage**: Robust handling of malformed URLs, missing data, and complex scenarios
-            - **Performance Tested**: Validated with large datasets (1000+ operations)
+            - **Performance Tested**: Validated with large datasets and mixed protocol specifications
+            - **Protocol Isolation**: Each protocol's parsing and matching logic is independently tested
             
             ---
             
@@ -165,12 +184,15 @@ jobs:
           echo "- **GitHub Release:** [v${{ env.NEW_VERSION }}](https://github.com/${{ github.repository }}/releases/tag/v${{ env.NEW_VERSION }})" >> $GITHUB_STEP_SUMMARY
           echo "" >> $GITHUB_STEP_SUMMARY
           echo "### 🎯 Key Features" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ Multi-protocol support (REST, gRPC, GraphQL)" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ Protocol-aware matching logic" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ Mixed API analysis in single run" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Smart endpoint mapping (enabled by default)" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Status code prioritization" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Enhanced path matching" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Confidence scoring" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Multi-API support" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Newman report support" >> $GITHUB_STEP_SUMMARY
-          echo "- ✅ Enhanced HTML reports" >> $GITHUB_STEP_SUMMARY
-          echo "- ✅ YAML, JSON, CSV support" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ Enhanced HTML reports with protocol identification" >> $GITHUB_STEP_SUMMARY
+          echo "- ✅ YAML, JSON, CSV, .proto, .graphql support" >> $GITHUB_STEP_SUMMARY
           echo "- ✅ Backwards compatibility" >> $GITHUB_STEP_SUMMARY
diff --git a/auto-detect-newman.html b/auto-detect-newman.html
index 86b5e29..d4d7d0e 100644
--- a/auto-detect-newman.html
+++ b/auto-detect-newman.html
@@ -384,7 +384,7 @@ <h1>Swagger Coverage Report</h1>
     &#128262; <!-- flashlight icon -->
   </button>
   <div class="meta-info">
-    <p><strong>Timestamp:</strong> 9/18/2025, 12:15:43 PM</p>
+    <p><strong>Timestamp:</strong> 9/18/2025, 2:32:58 PM</p>
     <p><strong>API Spec:</strong> Test API</p>
     
     <p><strong>Postman Collection:</strong> Test Newman Collection</p>
@@ -436,6 +436,7 @@ <h1>Swagger Coverage Report</h1>
     <thead>
       <tr>
         
+        <th onclick="sortTableBy('protocol')">Protocol</th>
         <th onclick="sortTableBy('method')">Method</th>
         <th onclick="sortTableBy('path')">Path</th>
         <th onclick="sortTableBy('name')">Name</th>
@@ -461,7 +462,7 @@ <h1>Swagger Coverage Report</h1>
   hljs.highlightAll();
 
   // coverageData from server
-  let coverageData = [{"method":"GET","path":"/users","name":"getUsers","statusCode":"200","tags":[],"expectedStatusCodes":["200"],"apiName":"Test API","sourceFile":"test-api.yaml","unmatched":false,"matchedRequests":[{"name":"Get Users","rawUrl":"https://api.example.com/users","method":"GET","testedStatusCodes":["200"],"testScripts":"// Status code is 200","confidence":0.8999999999999999}],"isPrimaryMatch":true,"matchConfidence":0.8999999999999999},{"method":"POST","path":"/users","name":"createUser","statusCode":"201","tags":[],"expectedStatusCodes":["201","400"],"apiName":"Test API","sourceFile":"test-api.yaml","unmatched":false,"matchedRequests":[{"name":"Create User","rawUrl":"https://api.example.com/users","method":"POST","testedStatusCodes":["201"],"testScripts":"// Status code is 201","confidence":0.8999999999999999}],"isPrimaryMatch":true,"matchConfidence":0.8999999999999999},{"method":"POST","path":"/users","name":"createUser","statusCode":"400","tags":[],"expectedStatusCodes":["201","400"],"apiName":"Test API","sourceFile":"test-api.yaml","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0},{"method":"GET","path":"/users/{id}","name":"getUserById","statusCode":"200","tags":[],"expectedStatusCodes":["200","404"],"apiName":"Test API","sourceFile":"test-api.yaml","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0},{"method":"GET","path":"/users/{id}","name":"getUserById","statusCode":"404","tags":[],"expectedStatusCodes":["200","404"],"apiName":"Test API","sourceFile":"test-api.yaml","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0}];
+  let coverageData = [{"method":"GET","path":"/users","name":"getUsers","statusCode":"200","tags":[],"expectedStatusCodes":["200"],"apiName":"Test API","sourceFile":"test-api.yaml","protocol":"rest","unmatched":false,"matchedRequests":[{"name":"Get Users","rawUrl":"https://api.example.com/users","method":"GET","testedStatusCodes":["200"],"testScripts":"// Status code is 200","confidence":0.8999999999999999}],"isPrimaryMatch":true,"matchConfidence":0.8999999999999999},{"method":"POST","path":"/users","name":"createUser","statusCode":"201","tags":[],"expectedStatusCodes":["201","400"],"apiName":"Test API","sourceFile":"test-api.yaml","protocol":"rest","unmatched":false,"matchedRequests":[{"name":"Create User","rawUrl":"https://api.example.com/users","method":"POST","testedStatusCodes":["201"],"testScripts":"// Status code is 201","confidence":0.8999999999999999}],"isPrimaryMatch":true,"matchConfidence":0.8999999999999999},{"method":"POST","path":"/users","name":"createUser","statusCode":"400","tags":[],"expectedStatusCodes":["201","400"],"apiName":"Test API","sourceFile":"test-api.yaml","protocol":"rest","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0},{"method":"GET","path":"/users/{id}","name":"getUserById","statusCode":"200","tags":[],"expectedStatusCodes":["200","404"],"apiName":"Test API","sourceFile":"test-api.yaml","protocol":"rest","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0},{"method":"GET","path":"/users/{id}","name":"getUserById","statusCode":"404","tags":[],"expectedStatusCodes":["200","404"],"apiName":"Test API","sourceFile":"test-api.yaml","protocol":"rest","unmatched":true,"matchedRequests":[],"isPrimaryMatch":false,"matchConfidence":0}];
   let apiCount = 1;
 
   // Merge duplicates for display only
@@ -741,6 +742,23 @@ <h1>Swagger Coverage Report</h1>
         tr.appendChild(tdApi);
       }
 
+      // Add protocol column
+      const tdProtocol = document.createElement('td');
+      tdProtocol.className = "spec-cell protocol-cell";
+      const protocol = item.protocol || 'rest';
+      tdProtocol.textContent = protocol.toUpperCase();
+      // Add styling based on protocol
+      if (protocol === 'grpc') {
+        tdProtocol.style.color = '#4caf50';
+        tdProtocol.style.fontWeight = 'bold';
+      } else if (protocol === 'graphql') {
+        tdProtocol.style.color = '#e91e63';
+        tdProtocol.style.fontWeight = 'bold';
+      } else {
+        tdProtocol.style.color = '#2196f3';
+      }
+      tr.appendChild(tdProtocol);
+
       const tdMethod = document.createElement('td');
       tdMethod.className = "spec-cell";
       tdMethod.textContent = (item.method || "").toUpperCase();
@@ -784,7 +802,7 @@ <h1>Swagger Coverage Report</h1>
         subTr.className = "matched-requests-row";
 
         const subTd = document.createElement('td');
-        subTd.colSpan = apiCount > 1 ? 5 : 4;
+        subTd.colSpan = apiCount > 1 ? 6 : 5;
 
         const pmTable = document.createElement('table');
         pmTable.className = "postman-table";
@@ -976,10 +994,20 @@ <h1>Swagger Coverage Report</h1>
     const rows = document.querySelectorAll('#specTable tbody tr.spec-row');
     
     rows.forEach(row => {
-      const method = row.querySelector('td:nth-child(1)').textContent;
-      const path = row.querySelector('td:nth-child(2)').textContent;
-      const name = row.querySelector('td:nth-child(3)').textContent;
-      const text = method + ' ' + path + ' ' + name.toLowerCase();
+      // Column indices adjust based on whether we have API column and protocol column
+      let colIndex = 1;
+      if (false) colIndex++; // API column
+      colIndex++; // Protocol column
+      
+      const method = row.querySelector(`td:nth-child(${colIndex})`).textContent;
+      const path = row.querySelector(`td:nth-child(${colIndex + 1})`).textContent;
+      const name = row.querySelector(`td:nth-child(${colIndex + 2})`).textContent;
+      
+      // Include protocol in search
+      const protocolIndex = false ? 2 : 1;
+      const protocol = row.querySelector(`td:nth-child(${protocolIndex})`).textContent;
+      
+      const text = method + ' ' + path + ' ' + name.toLowerCase() + ' ' + protocol.toLowerCase();
       
       const matchesSearch = searchText === '' || text.includes(searchText);
       const matchesFilter = (filterMode === 'all') || 
diff --git a/cli.js b/cli.js
index c7379d7..f877d4a 100755
--- a/cli.js
+++ b/cli.js
@@ -11,52 +11,81 @@ const { loadNewmanReport, extractRequestsFromNewman } = require("./lib/newman");
 const { matchOperationsDetailed } = require("./lib/match");
 const { generateHtmlReport } = require("./lib/report");
 const { loadExcelSpec } = require("./lib/excel");
+const { loadAndParseProto, extractOperationsFromProto, isProtoFile } = require("./lib/grpc");
+const { loadAndParseGraphQL, extractOperationsFromGraphQL, isGraphQLFile } = require("./lib/graphql");
 
 const program = new Command();
 
 program
   .name("swagger-coverage-cli")
   .description(
-    "CLI tool for comparing OpenAPI/Swagger specifications with a Postman collection or Newman run report, producing an enhanced HTML report"
+    "CLI tool for comparing API specifications (OpenAPI/Swagger, gRPC Protocol Buffers, GraphQL) with Postman collections or Newman run reports, producing an enhanced HTML report"
   )
-  .version("4.0.0")
-  .argument("<swaggerFiles>", "Path(s) to the Swagger/OpenAPI file(s) (JSON or YAML). Use comma-separated values for multiple files.")
+  .version("7.0.0")
+  .argument("<apiFiles>", "Path(s) to API specification file(s): OpenAPI/Swagger (JSON/YAML), gRPC (.proto), GraphQL (.graphql/.gql), or CSV. Use comma-separated values for multiple files.")
   .argument("<postmanCollectionOrNewmanReport>", "Path to the Postman collection (JSON) or Newman run report (JSON).")
   .option("-v, --verbose", "Show verbose debug info")
   .option("--strict-query", "Enable strict validation of query parameters")
   .option("--strict-body", "Enable strict validation of requestBody (JSON)")
   .option("--output <file>", "HTML report output file", "coverage-report.html")
   .option("--newman", "Treat input file as Newman run report instead of Postman collection")
-  .action(async (swaggerFiles, postmanFile, options) => {
+  .action(async (apiFiles, postmanFile, options) => {
     try {
       const { verbose, strictQuery, strictBody, output, newman } = options;
 
-      // Parse comma-separated swagger files
-      const files = swaggerFiles.includes(',') ? 
-        swaggerFiles.split(',').map(f => f.trim()) : 
-        [swaggerFiles];
+      // Parse comma-separated API files
+      const files = apiFiles.includes(',') ? 
+        apiFiles.split(',').map(f => f.trim()) : 
+        [apiFiles];
       
       let allSpecOperations = [];
       let allSpecNames = [];
       const excelExtensions = [".xlsx", ".xls", ".csv"];
 
-      // Process each swagger file
-      for (const swaggerFile of files) {
-        const ext = path.extname(swaggerFile).toLowerCase();
+      // Process each API specification file
+      for (const apiFile of files) {
+        const ext = path.extname(apiFile).toLowerCase();
         let specOperations;
         let specName;
+        let protocol;
 
         if (excelExtensions.includes(ext)) {
-          // Parse Excel
-          specOperations = loadExcelSpec(swaggerFile);
-          specName = path.basename(swaggerFile);
+          // Parse Excel/CSV
+          specOperations = loadExcelSpec(apiFile);
+          specName = path.basename(apiFile);
+          protocol = 'rest';
+        } else if (isProtoFile(apiFile)) {
+          // Parse gRPC Protocol Buffer
+          const protoRoot = await loadAndParseProto(apiFile);
+          specName = path.basename(apiFile, '.proto');
+          specOperations = extractOperationsFromProto(protoRoot, verbose);
+          protocol = 'grpc';
+          if (verbose) {
+            console.log(
+              "gRPC specification loaded successfully:",
+              specName
+            );
+          }
+        } else if (isGraphQLFile(apiFile)) {
+          // Parse GraphQL schema
+          const graphqlData = loadAndParseGraphQL(apiFile);
+          specName = path.basename(apiFile);
+          specOperations = extractOperationsFromGraphQL(graphqlData, verbose);
+          protocol = 'graphql';
+          if (verbose) {
+            console.log(
+              "GraphQL specification loaded successfully:",
+              specName
+            );
+          }
         } else {
-          // Original Swagger flow
-          const spec = await loadAndParseSpec(swaggerFile);
+          // Original OpenAPI/Swagger flow
+          const spec = await loadAndParseSpec(apiFile);
           specName = spec.info.title;
+          protocol = 'rest';
           if (verbose) {
             console.log(
-              "Specification loaded successfully:",
+              "OpenAPI specification loaded successfully:",
               specName,
               spec.info.version
             );
@@ -64,11 +93,12 @@ program
           specOperations = extractOperationsFromSpec(spec, verbose);
         }
 
-        // Add API name to each operation for identification
+        // Add API name and protocol to each operation for identification
         const operationsWithSource = specOperations.map(op => ({
           ...op,
           apiName: specName,
-          sourceFile: path.basename(swaggerFile)
+          sourceFile: path.basename(apiFile),
+          protocol: protocol
         }));
 
         allSpecOperations = allSpecOperations.concat(operationsWithSource);
diff --git a/lib/graphql.js b/lib/graphql.js
new file mode 100644
index 0000000..beeb422
--- /dev/null
+++ b/lib/graphql.js
@@ -0,0 +1,154 @@
+// graphql.js
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { buildSchema, parse, visit } = require('graphql');
+
+/**
+ * Load and parse GraphQL schema definition
+ * @param {string} filePath - Path to .graphql or .gql file
+ * @returns {Object} Parsed GraphQL schema
+ */
+function loadAndParseGraphQL(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`GraphQL file not found: ${filePath}`);
+  }
+
+  try {
+    const schemaContent = fs.readFileSync(filePath, 'utf8');
+    const schema = buildSchema(schemaContent);
+    const ast = parse(schemaContent);
+    
+    return { schema, ast, content: schemaContent };
+  } catch (err) {
+    throw new Error(`Failed to parse GraphQL schema: ${err.message}`);
+  }
+}
+
+/**
+ * Extract GraphQL operations from schema definition
+ * @param {Object} graphqlData - Object containing schema and AST
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Array} Array of GraphQL operations
+ */
+function extractOperationsFromGraphQL(graphqlData, verbose = false) {
+  const { schema, ast } = graphqlData;
+  const operations = [];
+  
+  // Extract Query operations
+  const queryType = schema.getQueryType();
+  if (queryType) {
+    const queryFields = queryType.getFields();
+    for (const [fieldName, field] of Object.entries(queryFields)) {
+      const operation = {
+        protocol: 'graphql',
+        method: 'post', // GraphQL uses HTTP POST
+        path: '/graphql',
+        operationId: `Query.${fieldName}`,
+        summary: field.description || `GraphQL query ${fieldName}`,
+        statusCode: '200',
+        tags: ['GraphQL', 'Query'],
+        expectedStatusCodes: ['200', '400'],
+        parameters: field.args ? field.args.map(arg => ({
+          name: arg.name,
+          in: 'body',
+          required: arg.type.toString().includes('!'),
+          schema: { type: arg.type.toString() }
+        })) : [],
+        requestBodyContent: ['application/json'],
+        graphqlType: 'query',
+        graphqlField: fieldName,
+        returnType: field.type.toString(),
+        arguments: field.args || []
+      };
+      
+      operations.push(operation);
+    }
+  }
+  
+  // Extract Mutation operations
+  const mutationType = schema.getMutationType();
+  if (mutationType) {
+    const mutationFields = mutationType.getFields();
+    for (const [fieldName, field] of Object.entries(mutationFields)) {
+      const operation = {
+        protocol: 'graphql',
+        method: 'post',
+        path: '/graphql',
+        operationId: `Mutation.${fieldName}`,
+        summary: field.description || `GraphQL mutation ${fieldName}`,
+        statusCode: '200',
+        tags: ['GraphQL', 'Mutation'],
+        expectedStatusCodes: ['200', '400'],
+        parameters: field.args ? field.args.map(arg => ({
+          name: arg.name,
+          in: 'body',
+          required: arg.type.toString().includes('!'),
+          schema: { type: arg.type.toString() }
+        })) : [],
+        requestBodyContent: ['application/json'],
+        graphqlType: 'mutation',
+        graphqlField: fieldName,
+        returnType: field.type.toString(),
+        arguments: field.args || []
+      };
+      
+      operations.push(operation);
+    }
+  }
+  
+  // Extract Subscription operations
+  const subscriptionType = schema.getSubscriptionType();
+  if (subscriptionType) {
+    const subscriptionFields = subscriptionType.getFields();
+    for (const [fieldName, field] of Object.entries(subscriptionFields)) {
+      const operation = {
+        protocol: 'graphql',
+        method: 'post',
+        path: '/graphql',
+        operationId: `Subscription.${fieldName}`,
+        summary: field.description || `GraphQL subscription ${fieldName}`,
+        statusCode: '200',
+        tags: ['GraphQL', 'Subscription'],
+        expectedStatusCodes: ['200', '400'],
+        parameters: field.args ? field.args.map(arg => ({
+          name: arg.name,
+          in: 'body',
+          required: arg.type.toString().includes('!'),
+          schema: { type: arg.type.toString() }
+        })) : [],
+        requestBodyContent: ['application/json'],
+        graphqlType: 'subscription',
+        graphqlField: fieldName,
+        returnType: field.type.toString(),
+        arguments: field.args || []
+      };
+      
+      operations.push(operation);
+    }
+  }
+  
+  if (verbose) {
+    console.log(`Extracted GraphQL operations from schema: ${operations.length}`);
+  }
+  
+  return operations;
+}
+
+/**
+ * Check if a file is a GraphQL schema file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if it's a GraphQL file
+ */
+function isGraphQLFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === '.graphql' || ext === '.gql';
+}
+
+module.exports = {
+  loadAndParseGraphQL,
+  extractOperationsFromGraphQL,
+  isGraphQLFile
+};
\ No newline at end of file
diff --git a/lib/grpc.js b/lib/grpc.js
new file mode 100644
index 0000000..a227caf
--- /dev/null
+++ b/lib/grpc.js
@@ -0,0 +1,98 @@
+// grpc.js
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const protobuf = require('protobufjs');
+
+/**
+ * Load and parse gRPC Protocol Buffer definition
+ * @param {string} filePath - Path to .proto file
+ * @returns {Object} Parsed protobuf root
+ */
+async function loadAndParseProto(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Proto file not found: ${filePath}`);
+  }
+
+  try {
+    const root = await protobuf.load(filePath);
+    return root;
+  } catch (err) {
+    throw new Error(`Failed to parse proto file: ${err.message}`);
+  }
+}
+
+/**
+ * Extract gRPC operations from protobuf definition
+ * @param {Object} root - Protobuf root object
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Array} Array of gRPC operations
+ */
+function extractOperationsFromProto(root, verbose = false) {
+  const operations = [];
+  
+  function traverseNamespace(namespace, namespacePath = '') {
+    if (namespace.nested) {
+      for (const [name, nested] of Object.entries(namespace.nested)) {
+        const fullPath = namespacePath ? `${namespacePath}.${name}` : name;
+        
+        if (nested instanceof protobuf.Service) {
+          // Found a gRPC service
+          const service = nested;
+          
+          for (const [methodName, method] of Object.entries(service.methods)) {
+            const operation = {
+              protocol: 'grpc',
+              method: 'post', // gRPC uses HTTP/2 POST
+              path: `/${fullPath}/${methodName}`,
+              operationId: `${fullPath}.${methodName}`,
+              summary: method.comment || `gRPC method ${methodName}`,
+              statusCode: '200', // Default successful response for gRPC
+              tags: ['gRPC', fullPath],
+              expectedStatusCodes: ['200', '400', '500'], // Common gRPC status codes
+              parameters: [],
+              requestBodyContent: ['application/grpc'],
+              grpcService: fullPath,
+              grpcMethod: methodName,
+              requestType: method.requestType,
+              responseType: method.responseType,
+              requestStream: method.requestStream || false,
+              responseStream: method.responseStream || false
+            };
+            
+            operations.push(operation);
+          }
+        } else if (nested.nested) {
+          // Recursively traverse nested namespaces
+          traverseNamespace(nested, fullPath);
+        }
+      }
+    }
+  }
+  
+  traverseNamespace(root);
+  
+  if (verbose) {
+    console.log(`Extracted gRPC operations from proto: ${operations.length}`);
+  }
+  
+  return operations;
+}
+
+/**
+ * Check if a file is a protobuf file
+ * @param {string} filePath - Path to check
+ * @returns {boolean} True if it's a proto file
+ */
+function isProtoFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === '.proto';
+}
+
+module.exports = {
+  loadAndParseProto,
+  extractOperationsFromProto,
+  isProtoFile
+};
\ No newline at end of file
diff --git a/lib/match.js b/lib/match.js
index 11a60ba..b7bfed9 100644
--- a/lib/match.js
+++ b/lib/match.js
@@ -95,12 +95,13 @@ function matchOperationsDetailed(specOps, postmanReqs, { verbose, strictQuery, s
         expectedStatusCodes: specOp.expectedStatusCodes || [],
         apiName: specOp.apiName || "",
         sourceFile: specOp.sourceFile || "",
+        protocol: specOp.protocol || "rest",
         unmatched: true,
         matchedRequests: []
       };
 
       for (const pmReq of postmanReqs) {
-        if (doesMatch(specOp, pmReq, { strictQuery, strictBody })) {
+        if (doesMatchProtocolAware(specOp, pmReq, { strictQuery, strictBody })) {
           coverageItem.unmatched = false;
           coverageItem.matchedRequests.push({
             name: pmReq.name,
@@ -387,7 +388,7 @@ function findSmartMatches(operations, postmanReqs, { strictQuery, strictBody })
   const matchingRequests = [];
   for (const pmReq of postmanReqs) {
     // Check if this request could match any operation in the group
-    if (operations.some(op => doesMatchBasic(op, pmReq, { strictQuery, strictBody }))) {
+    if (operations.some(op => doesMatchBasicProtocolAware(op, pmReq, { strictQuery, strictBody }))) {
       matchingRequests.push(pmReq);
     }
   }
@@ -404,6 +405,7 @@ function findSmartMatches(operations, postmanReqs, { strictQuery, strictBody })
       expectedStatusCodes: specOp.expectedStatusCodes || [],
       apiName: specOp.apiName || "",
       sourceFile: specOp.sourceFile || "",
+      protocol: specOp.protocol || "rest",
       unmatched: true,
       matchedRequests: [],
       isPrimaryMatch: false,
@@ -491,7 +493,7 @@ function doesMatchWithConfidence(specOp, pmReq, { strictQuery, strictBody }) {
   let confidence = 0;
   
   // Basic match first
-  if (!doesMatchBasic(specOp, pmReq, { strictQuery, strictBody })) {
+  if (!doesMatchBasicProtocolAware(specOp, pmReq, { strictQuery, strictBody })) {
     return { matches: false, confidence: 0 };
   }
   
@@ -533,6 +535,186 @@ function isSuccessStatusCode(statusCode) {
   return code >= 200 && code < 300;
 }
 
+/**
+ * Protocol-aware URL matching for gRPC and GraphQL
+ */
+function urlMatchesPath(postmanUrl, specPath, protocol) {
+  if (protocol === 'grpc') {
+    return urlMatchesGrpcPath(postmanUrl, specPath);
+  } else if (protocol === 'graphql') {
+    return urlMatchesGraphQLPath(postmanUrl, specPath);
+  } else {
+    // Default to OpenAPI/REST matching
+    return urlMatchesSwaggerPath(postmanUrl, specPath);
+  }
+}
+
+/**
+ * gRPC path matching - gRPC services are accessed via HTTP/2 POST to service/method
+ */
+function urlMatchesGrpcPath(postmanUrl, grpcPath) {
+  if (!postmanUrl || !grpcPath) {
+    return false;
+  }
+  
+  // Clean the Postman URL
+  let cleaned = postmanUrl.replace(/^(https?:\/\/)?{{.*?}}/, "");
+  cleaned = cleaned.replace(/^https?:\/\/[^/]+/, "");
+  cleaned = cleaned.split("?")[0];
+  cleaned = cleaned.replace(/\/+$/, "");
+  if (!cleaned) cleaned = "/";
+  
+  // gRPC paths are in format /package.service/method
+  // Match exact paths or allow flexible service matching
+  return cleaned === grpcPath || cleaned.endsWith(grpcPath);
+}
+
+/**
+ * GraphQL path matching - GraphQL typically uses a single endpoint /graphql
+ */
+function urlMatchesGraphQLPath(postmanUrl, graphqlPath) {
+  if (!postmanUrl || !graphqlPath) {
+    return false;
+  }
+  
+  // Clean the Postman URL
+  let cleaned = postmanUrl.replace(/^(https?:\/\/)?{{.*?}}/, "");
+  cleaned = cleaned.replace(/^https?:\/\/[^/]+/, "");
+  cleaned = cleaned.split("?")[0];
+  cleaned = cleaned.replace(/\/+$/, "");
+  if (!cleaned) cleaned = "/";
+  
+  // GraphQL typically uses /graphql endpoint
+  return cleaned === graphqlPath || 
+         cleaned === '/graphql' || 
+         cleaned.endsWith('/graphql');
+}
+
+/**
+ * Protocol-aware request body matching
+ */
+function matchesRequestBody(postmanReq, specOp) {
+  const protocol = specOp.protocol || 'rest';
+  
+  if (protocol === 'grpc') {
+    // gRPC uses protobuf or gRPC-specific content types
+    const contentType = postmanReq.bodyInfo?.contentType || '';
+    return contentType.includes('grpc') || 
+           contentType.includes('protobuf') ||
+           contentType.includes('application/grpc');
+  } else if (protocol === 'graphql') {
+    // GraphQL uses JSON with query/mutation/subscription
+    const contentType = postmanReq.bodyInfo?.contentType || '';
+    const body = postmanReq.bodyInfo?.raw || '';
+    
+    return contentType.includes('json') && 
+           (body.includes('query') || body.includes('mutation') || body.includes('subscription'));
+  } else {
+    // Default REST/OpenAPI matching
+    return true; // Use existing logic
+  }
+}
+
+/**
+ * Enhanced doesMatch function with protocol awareness
+ */
+function doesMatchProtocolAware(specOp, pmReq, { strictQuery, strictBody }) {
+  const protocol = specOp.protocol || 'rest';
+  
+  // 1. Method - gRPC and GraphQL typically use POST
+  if (protocol === 'grpc' || protocol === 'graphql') {
+    if (pmReq.method.toLowerCase() !== 'post') {
+      return false;
+    }
+  } else {
+    if (pmReq.method.toLowerCase() !== specOp.method.toLowerCase()) {
+      return false;
+    }
+  }
+
+  // 2. Protocol-aware path matching
+  if (!urlMatchesPath(pmReq.rawUrl, specOp.path, protocol)) {
+    return false;
+  }
+
+  // 3. Status code check (same for all protocols)
+  if (specOp.statusCode) {
+    const specStatusCode = specOp.statusCode.toString();
+    if (!pmReq.testedStatusCodes.includes(specStatusCode)) {
+      return false;
+    }
+  }
+
+  // 4. Protocol-aware body matching
+  if (strictBody && (protocol === 'grpc' || protocol === 'graphql')) {
+    if (!matchesRequestBody(pmReq, specOp)) {
+      return false;
+    }
+  } else if (strictBody) {
+    // Use existing REST body validation
+    if (!checkRequestBodyStrict(specOp, pmReq)) {
+      return false;
+    }
+  }
+
+  // 5. Query parameters (mainly for REST APIs)
+  if (strictQuery && protocol === 'rest') {
+    if (!checkQueryParamsStrict(specOp, pmReq)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Protocol-aware basic matching without status code requirement (for grouping)
+ */
+function doesMatchBasicProtocolAware(specOp, pmReq, { strictQuery, strictBody }) {
+  const protocol = specOp.protocol || 'rest';
+  
+  // Handle missing methods
+  if (!pmReq.method || !specOp.method) {
+    return false;
+  }
+
+  // 1. Method - protocol aware
+  if (protocol === 'grpc' || protocol === 'graphql') {
+    if (pmReq.method.toLowerCase() !== 'post') {
+      return false;
+    }
+  } else {
+    if (pmReq.method.toLowerCase() !== specOp.method.toLowerCase()) {
+      return false;
+    }
+  }
+
+  // 2. Protocol-aware path matching
+  if (!urlMatchesPath(pmReq.rawUrl, specOp.path, protocol)) {
+    return false;
+  }
+
+  // 3. Strict Query (mainly for REST)
+  if (strictQuery && protocol === 'rest') {
+    if (!checkQueryParamsStrict(specOp, pmReq)) {
+      return false;
+    }
+  }
+
+  // 4. Strict Body (protocol aware)
+  if (strictBody && (protocol === 'grpc' || protocol === 'graphql')) {
+    if (!matchesRequestBody(pmReq, specOp)) {
+      return false;
+    }
+  } else if (strictBody) {
+    if (!checkRequestBodyStrict(specOp, pmReq)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 module.exports = {
   matchOperationsDetailed,
   urlMatchesSwaggerPath,
@@ -541,5 +723,11 @@ module.exports = {
   groupOperationsByMethodAndPath,
   findSmartMatches,
   isSuccessStatusCode,
-  calculatePathSimilarity
+  calculatePathSimilarity,
+  urlMatchesPath,
+  urlMatchesGrpcPath,
+  urlMatchesGraphQLPath,
+  doesMatchProtocolAware,
+  doesMatchBasicProtocolAware,
+  matchesRequestBody
 };
diff --git a/lib/report.js b/lib/report.js
index 99a3601..a91076e 100644
--- a/lib/report.js
+++ b/lib/report.js
@@ -479,6 +479,7 @@ function generateHtmlReport({ coverage, coverageItems, meta }) {
     <thead>
       <tr>
         ${apiCount > 1 ? '<th onclick="sortTableBy(\'apiName\')">API</th>' : ''}
+        <th onclick="sortTableBy('protocol')">Protocol</th>
         <th onclick="sortTableBy('method')">Method</th>
         <th onclick="sortTableBy('path')">Path</th>
         <th onclick="sortTableBy('name')">Name</th>
@@ -784,6 +785,23 @@ function generateHtmlReport({ coverage, coverageItems, meta }) {
         tr.appendChild(tdApi);
       }
 
+      // Add protocol column
+      const tdProtocol = document.createElement('td');
+      tdProtocol.className = "spec-cell protocol-cell";
+      const protocol = item.protocol || 'rest';
+      tdProtocol.textContent = protocol.toUpperCase();
+      // Add styling based on protocol
+      if (protocol === 'grpc') {
+        tdProtocol.style.color = '#4caf50';
+        tdProtocol.style.fontWeight = 'bold';
+      } else if (protocol === 'graphql') {
+        tdProtocol.style.color = '#e91e63';
+        tdProtocol.style.fontWeight = 'bold';
+      } else {
+        tdProtocol.style.color = '#2196f3';
+      }
+      tr.appendChild(tdProtocol);
+
       const tdMethod = document.createElement('td');
       tdMethod.className = "spec-cell";
       tdMethod.textContent = (item.method || "").toUpperCase();
@@ -827,7 +845,7 @@ function generateHtmlReport({ coverage, coverageItems, meta }) {
         subTr.className = "matched-requests-row";
 
         const subTd = document.createElement('td');
-        subTd.colSpan = apiCount > 1 ? 5 : 4;
+        subTd.colSpan = apiCount > 1 ? 6 : 5;
 
         const pmTable = document.createElement('table');
         pmTable.className = "postman-table";
@@ -1019,10 +1037,20 @@ function generateHtmlReport({ coverage, coverageItems, meta }) {
     const rows = document.querySelectorAll('#specTable tbody tr.spec-row');
     
     rows.forEach(row => {
-      const method = row.querySelector('td:nth-child(1)').textContent;
-      const path = row.querySelector('td:nth-child(2)').textContent;
-      const name = row.querySelector('td:nth-child(3)').textContent;
-      const text = method + ' ' + path + ' ' + name.toLowerCase();
+      // Column indices adjust based on whether we have API column and protocol column
+      let colIndex = 1;
+      if (${apiCount > 1}) colIndex++; // API column
+      colIndex++; // Protocol column
+      
+      const method = row.querySelector(\`td:nth-child(\${colIndex})\`).textContent;
+      const path = row.querySelector(\`td:nth-child(\${colIndex + 1})\`).textContent;
+      const name = row.querySelector(\`td:nth-child(\${colIndex + 2})\`).textContent;
+      
+      // Include protocol in search
+      const protocolIndex = ${apiCount > 1} ? 2 : 1;
+      const protocol = row.querySelector(\`td:nth-child(\${protocolIndex})\`).textContent;
+      
+      const text = method + ' ' + path + ' ' + name.toLowerCase() + ' ' + protocol.toLowerCase();
       
       const matchesSearch = searchText === '' || text.includes(searchText);
       const matchesFilter = (filterMode === 'all') || 
diff --git a/package-lock.json b/package-lock.json
index a474968..be934bb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,7 +13,9 @@
         "@apidevtools/swagger-parser": "^10.1.1",
         "ajv": "^8.17.1",
         "commander": "^13.0.0",
+        "graphql": "^16.11.0",
         "js-yaml": "^4.1.0",
+        "protobufjs": "^7.5.4",
         "xlsx": "^0.18.5"
       },
       "bin": {
@@ -915,6 +917,70 @@
       "resolved": "https://registry.npmjs.org/@jsdevtools/ono/-/ono-7.1.3.tgz",
       "integrity": "sha512-4JQNk+3mVzK3xh2rqd6RB4J46qUR19azEHBneZyTZM+c456qOrbbM/5xcR8huNCCcbVt7+UmizG6GuUvPvKUYg=="
     },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/@sinclair/typebox": {
       "version": "0.27.8",
       "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
@@ -1022,7 +1088,6 @@
       "version": "22.10.7",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.7.tgz",
       "integrity": "sha512-V09KvXxFiutGp6B7XkpaDXlNadZxrzajcY50EuoLIpQ6WWYCSvf19lVIazzfIzQvhUN2HjX12spLojTnhuKlGg==",
-      "dev": true,
       "dependencies": {
         "undici-types": "~6.20.0"
       }
@@ -1891,6 +1956,15 @@
       "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
       "dev": true
     },
+    "node_modules/graphql": {
+      "version": "16.11.0",
+      "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.11.0.tgz",
+      "integrity": "sha512-mS1lbMsxgQj6hge1XZ6p7GPhbrtFwUFYi3wRzXAC/FmYnyXMTvvI3td3rjmQ2u8ewXueaSvRPWaEcgVVOT9Jnw==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0"
+      }
+    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -2771,6 +2845,12 @@
         "node": ">=8"
       }
     },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -3111,6 +3191,30 @@
         "node": ">= 6"
       }
     },
+    "node_modules/protobufjs": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
+      "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/pure-rand": {
       "version": "6.1.0",
       "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",
@@ -3448,8 +3552,7 @@
     "node_modules/undici-types": {
       "version": "6.20.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz",
-      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==",
-      "dev": true
+      "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="
     },
     "node_modules/update-browserslist-db": {
       "version": "1.1.2",
diff --git a/package.json b/package.json
index ca3eea8..f0ffddf 100644
--- a/package.json
+++ b/package.json
@@ -56,7 +56,9 @@
     "@apidevtools/swagger-parser": "^10.1.1",
     "ajv": "^8.17.1",
     "commander": "^13.0.0",
+    "graphql": "^16.11.0",
     "js-yaml": "^4.1.0",
+    "protobufjs": "^7.5.4",
     "xlsx": "^0.18.5"
   },
   "devDependencies": {
diff --git a/readme.md b/readme.md
index 4aa345f..ceea06a 100644
--- a/readme.md
+++ b/readme.md
@@ -1,58 +1,122 @@
-![Postman](https://img.shields.io/badge/Postman-FF6C37?logo=postman&logoColor=white) ![OpenAPI](https://img.shields.io/badge/OpenAPI-5392CE?logo=openapi&logoColor=white) ![Swagger](https://img.shields.io/badge/Swagger-85EA2D?logo=swagger&logoColor=white) ![Tests](https://github.com/dreamquality/swagger-coverage-cli/actions/workflows/test.yml/badge.svg) ![CSV](https://img.shields.io/badge/CSV-1DA598?logo=csv&logoColor=white) ![npm](https://img.shields.io/npm/v/swagger-coverage-cli?color=blue&label=npm&logo=npm)
+![Postman](https://img.shields.io/badge/Postman-FF6C37?logo=postman&logoColor=white) ![OpenAPI](https://img.shields.io/badge/OpenAPI-5392CE?logo=openapi&logoColor=white) ![Swagger](https://img.shields.io/badge/Swagger-85EA2D?logo=swagger&logoColor=white) ![gRPC](https://img.shields.io/badge/gRPC-4caf50?logo=grpc&logoColor=white) ![GraphQL](https://img.shields.io/badge/GraphQL-e91e63?logo=graphql&logoColor=white) ![Tests](https://github.com/dreamquality/swagger-coverage-cli/actions/workflows/test.yml/badge.svg) ![CSV](https://img.shields.io/badge/CSV-1DA598?logo=csv&logoColor=white) ![npm](https://img.shields.io/npm/v/swagger-coverage-cli?color=blue&label=npm&logo=npm)
  
 
 # Swagger Coverage CLI
 
-> **A command-line utility to compare your OpenAPI/Swagger specification with a Postman collection and calculate **API test coverage**. Generates a human-readable HTML report. 
+> **A comprehensive command-line utility to analyze API test coverage across **multiple protocols**: OpenAPI/Swagger (REST), gRPC Protocol Buffers, and GraphQL schemas. Generates unified HTML reports with protocol-specific insights.**
 Check out the [Example!](https://dreamquality.github.io/swagger-coverage-cli)**
 
 ## Table of Contents
 
 1. [Introduction](#introduction)
-2. [Features](#features)
-3. [How It Works (Diagram)](#how-it-works-diagram)
-4. [Installation & Requirements](#installation--requirements)
-5. [Getting Started](#getting-started)
+2. [Multi-Protocol Support](#multi-protocol-support)
+3. [Features](#features)
+4. [How It Works (Diagram)](#how-it-works-diagram)
+5. [Installation & Requirements](#installation--requirements)
+6. [Getting Started](#getting-started)
 
    - [1. Prepare Your Files](#1-prepare-your-files)
    - [2. Run the CLI](#2-run-the-cli)
    - [3. Check the Coverage Report](#3-check-the-coverage-report)
 
-6. [Detailed Matching Logic](#detailed-matching-logic)
-7. [Smart Endpoint Mapping](#smart-endpoint-mapping)
-8. [Supported File Formats](#supported-file-formats)
+7. [Protocol-Specific Usage](#protocol-specific-usage)
+8. [Detailed Matching Logic](#detailed-matching-logic)
+9. [Smart Endpoint Mapping](#smart-endpoint-mapping)
+10. [Supported File Formats](#supported-file-formats)
 
 - [Using CSV for Documentation](#using-csv-for-documentation)
 
-9. [Contributing](#contributing)
-10. [License](#license)
+11. [Contributing](#contributing)
+12. [License](#license)
 
 ---
 
 ## Introduction
 
-**swagger-coverage-cli** is a tool that helps you **measure how much of your OpenAPI/Swagger-documented API is actually covered by your Postman tests**. It reads inputs from:
+**swagger-coverage-cli** is a comprehensive tool that helps you **measure API test coverage across multiple protocols**. It analyzes how much of your documented APIs are actually covered by your Postman tests. The tool supports:
 
-1. **Single or Multiple OpenAPI/Swagger** specifications (version 2 or 3) in either JSON or YAML format, or **CSV** files containing API documentation.
-2. A **Postman** collection (JSON) that contains requests and test scripts, **OR** a **Newman run report** (JSON) that contains actual execution results.
+### 🚀 Supported API Protocols
 
-The tool supports processing **multiple API specifications in a single run**, making it ideal for organizations managing multiple APIs or microservices. Using this information, the CLI **calculates a unified coverage percentage** and produces a **detailed HTML report** indicating which endpoints and status codes are validated across all APIs, and which are missing tests.
+- **📋 REST APIs**: OpenAPI/Swagger specifications (v2/v3) in JSON or YAML format
+- **⚡ gRPC APIs**: Protocol Buffer (`.proto`) files with service definitions
+- **🔀 GraphQL APIs**: GraphQL schema (`.graphql`, `.gql`) files with queries, mutations, and subscriptions
+- **📊 CSV APIs**: Custom CSV format for flexible API documentation
+
+### 🎯 Input Sources
+
+1. **API Specifications**: Single or multiple API files in supported formats
+2. **Test Collections**: Postman collections (JSON) with requests and test scripts
+3. **Execution Reports**: Newman run reports (JSON) with actual test execution results
+
+The tool supports processing **multiple API specifications in a single run**, making it ideal for organizations managing microservices with diverse protocols. It **calculates unified coverage percentages** and produces **detailed HTML reports** with protocol-specific insights.
+
+---
+
+## Multi-Protocol Support
+
+**swagger-coverage-cli** provides comprehensive support for modern API ecosystems with multiple protocols, enabling unified coverage analysis across your entire technology stack.
+
+### 🌐 Universal CLI Interface
+
+```bash
+# Single protocol APIs
+swagger-coverage-cli api.yaml collection.json           # OpenAPI/REST
+swagger-coverage-cli service.proto collection.json     # gRPC
+swagger-coverage-cli schema.graphql collection.json    # GraphQL
+swagger-coverage-cli api-docs.csv collection.json      # CSV
+
+# Mixed protocol APIs (Enterprise-ready)
+swagger-coverage-cli "api.yaml,service.proto,schema.graphql" collection.json
+
+# All existing options work across protocols
+swagger-coverage-cli "api.yaml,service.proto" collection.json --verbose --strict-body
+```
+
+### 🎯 Protocol-Specific Features
+
+#### 📋 REST/OpenAPI Support
+- **OpenAPI v2/v3**: Full specification support
+- **Smart Path Matching**: Handles parameter variations (`/users/{id}` vs `/users/{userId}`)
+- **Status Code Intelligence**: Prioritizes 2xx → 4xx → 5xx responses
+- **Request Body Validation**: JSON schema validation with strict mode
+
+#### ⚡ gRPC Support  
+- **Protocol Buffer Parsing**: Automatic `.proto` file analysis
+- **Service Discovery**: Extracts all services, methods, and message types
+- **Path Generation**: Maps to HTTP/2 paths (`/package.service/method`)
+- **Content-Type Validation**: Supports `application/grpc` and variants
+
+#### 🔀 GraphQL Support
+- **Schema Analysis**: Parses `.graphql` and `.gql` files
+- **Operation Extraction**: Identifies queries, mutations, and subscriptions
+- **Type System**: Full support for arguments, unions, and interfaces
+- **Endpoint Unification**: Maps all operations to `/graphql` endpoint
+
+### 📊 Unified Reporting
+
+- **Protocol Column**: Color-coded identification (🟢 gRPC, 🔴 GraphQL, 🔵 REST)
+- **Mixed Statistics**: Combined coverage metrics across all protocols
+- **Individual Breakdown**: Per-API and per-protocol insights
+- **Smart Search**: Protocol-aware filtering and search functionality
 
 ---
 
 ## Features
 
-- **Easy to Use**: Simple CLI interface with just two main arguments (the Swagger file and the Postman collection or Newman report).
-- **Multiple Input Types**: Supports both Postman collections and Newman run reports for maximum flexibility.
-- **Auto-Detection**: Automatically detects Newman report format even without explicit flags.
-- **Multiple API Support**: Process multiple Swagger/OpenAPI specifications in a single run for comprehensive API portfolio management.
-- **Unified Reporting**: Generate consolidated reports that show coverage across all APIs while maintaining individual API identification.
-- **Smart Endpoint Mapping**: Intelligent endpoint matching with status code prioritization and enhanced path matching for improved coverage accuracy.
-- **Strict Matching (Optional)**: Enforce strict checks for query parameters, request bodies, and more.
-- **HTML Reports**: Generates `coverage-report.html` that shows which endpoints are covered and which are not.
-- **Extensible**: Modular code structure (Node.js) allows customization of matching logic, query parameter checks, status code detection, etc.
-- **CSV Support**: Allows API documentation to be provided in a CSV format for flexibility and ease of use.
-- **Unit Tested**: Includes Jest tests for the core functions that match endpoints to Postman requests.
+- **🌐 Multi-Protocol Support**: Native support for REST (OpenAPI/Swagger), gRPC (Protocol Buffers), and GraphQL schemas
+- **🔄 Mixed API Analysis**: Process multiple API specifications with different protocols in a single run
+- **🎯 Protocol-Aware Matching**: Intelligent request matching tailored to each API protocol's characteristics
+- **📊 Unified Reporting**: Generate consolidated HTML reports with protocol-specific insights and color coding
+- **⚡ Easy to Use**: Simple CLI interface works across all supported protocols with consistent syntax
+- **🔍 Multiple Input Types**: Supports Postman collections and Newman run reports for maximum flexibility
+- **🤖 Auto-Detection**: Automatically detects API file types and Newman report formats
+- **🏗️ Enterprise Ready**: Perfect for microservices architectures using diverse API protocols
+- **🎨 Smart Endpoint Mapping**: Intelligent endpoint matching with status code prioritization and enhanced path matching
+- **🔒 Strict Matching (Optional)**: Enforce strict checks for query parameters, request bodies, and more
+- **📈 Enhanced HTML Reports**: Generates interactive `coverage-report.html` with protocol identification
+- **🧩 Extensible**: Modular code structure allows customization of matching logic and protocol support
+- **📋 CSV Support**: Flexible API documentation format for teams preferring spreadsheet-based docs
+- **✅ Unit Tested**: Comprehensive Jest test suite covering all protocols and edge cases
 
 ---
 
@@ -236,6 +300,140 @@ Unmatched operations:
 
 ---
 
+## Protocol-Specific Usage
+
+### 🌐 OpenAPI/REST APIs
+
+Use standard OpenAPI/Swagger files in YAML or JSON format:
+
+```bash
+# Single OpenAPI specification
+swagger-coverage-cli api-spec.yaml collection.json
+
+# Multiple REST APIs
+swagger-coverage-cli "api-v1.yaml,api-v2.yaml,legacy.json" collection.json
+
+# With strict validation
+swagger-coverage-cli openapi.yaml collection.json --strict-query --strict-body
+```
+
+**Supported OpenAPI features:**
+- Path parameters (`/users/{id}`, `/users/{userId}`)
+- Query parameters with schema validation
+- Request body validation (JSON, form-data, etc.)
+- Multiple response status codes per operation
+- OpenAPI v2 and v3 specifications
+
+### ⚡ gRPC APIs
+
+Analyze Protocol Buffer service definitions:
+
+```bash
+# Single gRPC service
+swagger-coverage-cli user-service.proto collection.json
+
+# Multiple gRPC services
+swagger-coverage-cli "user.proto,order.proto,payment.proto" collection.json
+
+# Mixed with OpenAPI
+swagger-coverage-cli "rest-api.yaml,grpc-service.proto" collection.json
+```
+
+**gRPC-specific features:**
+- Service and method extraction from `.proto` files
+- HTTP/2 path mapping (`/package.service/method`)
+- Content-type validation (`application/grpc`, `application/grpc+proto`)
+- Nested package support (`company.api.v1.UserService`)
+
+**Example Postman request for gRPC:**
+```json
+{
+  "method": "POST",
+  "url": "{{grpcUrl}}/user.v1.UserService/GetUser",
+  "header": [
+    { "key": "Content-Type", "value": "application/grpc" }
+  ],
+  "body": {
+    "mode": "raw",
+    "raw": "{\"user_id\": \"123\"}"
+  }
+}
+```
+
+### 🔀 GraphQL APIs
+
+Analyze GraphQL schema definitions:
+
+```bash
+# Single GraphQL API
+swagger-coverage-cli schema.graphql collection.json
+
+# Multiple GraphQL schemas  
+swagger-coverage-cli "user-schema.gql,product-schema.graphql" collection.json
+
+# Full stack coverage
+swagger-coverage-cli "api.yaml,service.proto,schema.graphql" collection.json
+```
+
+**GraphQL-specific features:**
+- Query, mutation, and subscription extraction
+- Argument analysis with type information
+- Union and interface type support
+- Nested type relationship mapping
+
+**Example Postman request for GraphQL:**
+```json
+{
+  "method": "POST", 
+  "url": "{{apiUrl}}/graphql",
+  "header": [
+    { "key": "Content-Type", "value": "application/json" }
+  ],
+  "body": {
+    "mode": "raw",
+    "raw": "{\"query\": \"query GetUser($id: ID!) { user(id: $id) { id name email } }\", \"variables\": {\"id\": \"123\"}}"
+  }
+}
+```
+
+### 📊 CSV Documentation
+
+Use CSV format for flexible API documentation:
+
+```bash
+# CSV-based API documentation
+swagger-coverage-cli api-docs.csv collection.json
+
+# Mixed with other formats
+swagger-coverage-cli "api.yaml,docs.csv,service.proto" collection.json
+```
+
+**CSV format columns:**
+- `method`: HTTP method (GET, POST, etc.)
+- `path`: API endpoint path
+- `statusCode`: Expected response status code
+- `description`: Operation description
+- `tags`: Comma-separated tags for grouping
+
+### 🏗️ Enterprise Scenarios
+
+**Microservices Architecture:**
+```bash
+# Complete microservices stack
+swagger-coverage-cli "gateway.yaml,user-service.proto,analytics.graphql,docs.csv" tests.json
+
+# Per-team analysis
+swagger-coverage-cli "team-a-api.yaml,team-b-service.proto" team-tests.json
+```
+
+**CI/CD Integration:**
+```bash
+# Production coverage check
+swagger-coverage-cli "$(find apis -name '*.yaml' -o -name '*.proto' -o -name '*.graphql' | tr '\n' ',')" collection.json --output coverage-$(date +%Y%m%d).html
+```
+
+---
+
 ## Coverage Calculation Formulas
 
 **swagger-coverage-cli** uses precise mathematical formulas to calculate API test coverage. Understanding these formulas helps you interpret coverage reports and set appropriate coverage targets.
diff --git a/test/comprehensive-protocol.test.js b/test/comprehensive-protocol.test.js
new file mode 100644
index 0000000..26fbbb3
--- /dev/null
+++ b/test/comprehensive-protocol.test.js
@@ -0,0 +1,444 @@
+// comprehensive-protocol.test.js
+const { loadAndParseProto, extractOperationsFromProto } = require('../lib/grpc');
+const { loadAndParseGraphQL, extractOperationsFromGraphQL } = require('../lib/graphql');
+const { matchOperationsDetailed } = require('../lib/match');
+const { loadPostmanCollection, extractRequestsFromPostman } = require('../lib/postman');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+describe('Comprehensive Protocol Support Tests', () => {
+  const fixturesDir = path.resolve(__dirname, 'fixtures');
+
+  describe('gRPC Advanced Features', () => {
+    test('should handle streaming gRPC methods', async () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const root = await loadAndParseProto(protoPath);
+      const operations = extractOperationsFromProto(root);
+      
+      // Check for different operation types
+      expect(operations.length).toBe(5);
+      
+      operations.forEach(op => {
+        expect(op.protocol).toBe('grpc');
+        expect(op.method).toBe('post');
+        expect(op.path).toMatch(/^\/user\.v1\.UserService\/.+/);
+        expect(op.tags).toContain('gRPC');
+        expect(op.tags).toContain('user.v1.UserService');
+      });
+    });
+
+    test('should handle nested gRPC services', () => {
+      // Create a more complex proto for testing
+      const complexProto = `
+syntax = "proto3";
+
+package company.api.v1;
+
+service UserService {
+  rpc GetUser(GetUserRequest) returns (GetUserResponse);
+  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
+}
+
+service AdminService {
+  rpc GetAdminUser(GetAdminUserRequest) returns (GetAdminUserResponse);
+}
+
+message GetUserRequest {
+  string user_id = 1;
+}
+
+message GetUserResponse {
+  User user = 1;
+}
+
+message CreateUserRequest {
+  string name = 1;
+  string email = 2;
+}
+
+message CreateUserResponse {
+  User user = 1;
+}
+
+message GetAdminUserRequest {
+  string admin_id = 1;
+}
+
+message GetAdminUserResponse {
+  AdminUser admin = 1;
+}
+
+message User {
+  string id = 1;
+  string name = 2;
+  string email = 3;
+}
+
+message AdminUser {
+  string id = 1;
+  string name = 2;
+  string permissions = 3;
+}`;
+
+      const tempProtoPath = path.resolve(fixturesDir, 'complex-service.proto');
+      fs.writeFileSync(tempProtoPath, complexProto);
+
+      return loadAndParseProto(tempProtoPath).then(root => {
+        const operations = extractOperationsFromProto(root);
+        
+        expect(operations.length).toBe(3);
+        
+        const userServiceOps = operations.filter(op => op.grpcService === 'company.api.v1.UserService');
+        const adminServiceOps = operations.filter(op => op.grpcService === 'company.api.v1.AdminService');
+        
+        expect(userServiceOps.length).toBe(2);
+        expect(adminServiceOps.length).toBe(1);
+        
+        // Cleanup
+        fs.unlinkSync(tempProtoPath);
+      });
+    });
+
+    test('should handle gRPC error responses', async () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const root = await loadAndParseProto(protoPath);
+      const operations = extractOperationsFromProto(root);
+      
+      operations.forEach(op => {
+        expect(op.expectedStatusCodes).toContain('200');
+        expect(op.expectedStatusCodes).toContain('400');
+        expect(op.expectedStatusCodes).toContain('500');
+      });
+    });
+  });
+
+  describe('GraphQL Advanced Features', () => {
+    test('should handle GraphQL field arguments', () => {
+      const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const graphqlData = loadAndParseGraphQL(schemaPath);
+      const operations = extractOperationsFromGraphQL(graphqlData);
+      
+      const userQuery = operations.find(op => op.graphqlField === 'user');
+      expect(userQuery).toBeDefined();
+      expect(userQuery.parameters).toHaveLength(1);
+      expect(userQuery.parameters[0].name).toBe('id');
+      expect(userQuery.parameters[0].required).toBe(true);
+    });
+
+    test('should categorize GraphQL operations correctly', () => {
+      const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const graphqlData = loadAndParseGraphQL(schemaPath);
+      const operations = extractOperationsFromGraphQL(graphqlData);
+      
+      const queries = operations.filter(op => op.graphqlType === 'query');
+      const mutations = operations.filter(op => op.graphqlType === 'mutation');
+      const subscriptions = operations.filter(op => op.graphqlType === 'subscription');
+      
+      expect(queries.length).toBeGreaterThan(0);
+      expect(mutations.length).toBeGreaterThan(0);
+      expect(subscriptions.length).toBeGreaterThan(0);
+      
+      // Check tags
+      queries.forEach(q => expect(q.tags).toContain('Query'));
+      mutations.forEach(m => expect(m.tags).toContain('Mutation'));
+      subscriptions.forEach(s => expect(s.tags).toContain('Subscription'));
+    });
+
+    test('should handle complex GraphQL types', () => {
+      const complexSchema = `
+type Query {
+  users(filter: UserFilter, pagination: PaginationInput): UserConnection!
+  posts(authorId: ID): [Post!]!
+}
+
+type Mutation {
+  createUser(input: CreateUserInput!): CreateUserResult!
+  updateUser(id: ID!, input: UpdateUserInput!): UpdateUserResult!
+}
+
+input UserFilter {
+  name: String
+  email: String
+  isActive: Boolean
+}
+
+input PaginationInput {
+  limit: Int = 10
+  offset: Int = 0
+}
+
+input CreateUserInput {
+  name: String!
+  email: String!
+  profile: UserProfileInput
+}
+
+input UpdateUserInput {
+  name: String
+  email: String
+}
+
+input UserProfileInput {
+  bio: String
+  website: String
+}
+
+type UserConnection {
+  nodes: [User!]!
+  totalCount: Int!
+}
+
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  posts: [Post!]!
+}
+
+type Post {
+  id: ID!
+  title: String!
+  content: String!
+  author: User!
+}
+
+union CreateUserResult = User | ValidationError
+union UpdateUserResult = User | ValidationError
+
+type ValidationError {
+  message: String!
+  field: String!
+}`;
+
+      const tempSchemaPath = path.resolve(fixturesDir, 'complex-schema.graphql');
+      fs.writeFileSync(tempSchemaPath, complexSchema);
+
+      const graphqlData = loadAndParseGraphQL(tempSchemaPath);
+      const operations = extractOperationsFromGraphQL(graphqlData);
+      
+      expect(operations.length).toBe(4); // 2 queries + 2 mutations
+      
+      const usersQuery = operations.find(op => op.graphqlField === 'users');
+      expect(usersQuery).toBeDefined();
+      expect(usersQuery.parameters.length).toBe(2); // filter and pagination
+      
+      // Cleanup
+      fs.unlinkSync(tempSchemaPath);
+    });
+  });
+
+  describe('Mixed Protocol Scenarios', () => {
+    test('should handle enterprise-scale mixed API portfolio', async () => {
+      const openApiPath = path.resolve(fixturesDir, 'sample-api.yaml');
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const graphqlPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+
+      const result = execSync(
+        `node cli.js "${openApiPath},${protoPath},${graphqlPath}" "${collectionPath}" --verbose`,
+        { encoding: 'utf8', cwd: process.cwd() }
+      );
+
+      expect(result).toContain('OpenAPI specification loaded successfully');
+      expect(result).toContain('gRPC specification loaded successfully');
+      expect(result).toContain('GraphQL specification loaded successfully');
+      expect(result).toContain('APIs analyzed:');
+      expect(result).toContain('Total operations in spec(s): 33');
+      
+      // Check protocol-specific statistics
+      expect(result).toContain('Smart mapping:');
+    });
+
+    test('should generate accurate coverage statistics for mixed protocols', () => {
+      const csvPath = path.resolve(fixturesDir, 'analytics-api.csv');
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const collectionPath = path.resolve(fixturesDir, 'test-collection.json');
+
+      const result = execSync(
+        `node cli.js "${csvPath},${protoPath}" "${collectionPath}"`,
+        { encoding: 'utf8', cwd: process.cwd() }
+      );
+
+      expect(result).toContain('APIs analyzed:');
+      expect(result).toContain('Coverage:');
+      expect(result).toContain('HTML report saved to:');
+    });
+
+    test('should maintain protocol separation in reports', () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const graphqlPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+
+      execSync(
+        `node cli.js "${protoPath},${graphqlPath}" "${collectionPath}" --output protocol-separation-report.html`,
+        { cwd: process.cwd() }
+      );
+
+      const reportPath = path.resolve(process.cwd(), 'protocol-separation-report.html');
+      expect(fs.existsSync(reportPath)).toBe(true);
+      
+      const reportContent = fs.readFileSync(reportPath, 'utf8');
+      expect(reportContent).toContain('"protocol":"grpc"');
+      expect(reportContent).toContain('"protocol":"graphql"');
+      
+      // Cleanup
+      fs.unlinkSync(reportPath);
+    });
+  });
+
+  describe('Protocol-Specific Matching Edge Cases', () => {
+    test('should handle gRPC with different content types', async () => {
+      const grpcCollection = {
+        info: { name: "gRPC Test Collection" },
+        item: [
+          {
+            name: "gRPC with protobuf content type",
+            request: {
+              method: "POST",
+              header: [{ key: "Content-Type", value: "application/grpc+proto" }],
+              url: { raw: "http://api.example.com/user.v1.UserService/GetUser" },
+              body: { mode: "raw", raw: '{"user_id": "123"}' }
+            },
+            event: [
+              {
+                listen: "test",
+                script: { exec: ["pm.test('Status', () => pm.response.to.have.status(200));"] }
+              }
+            ]
+          }
+        ]
+      };
+
+      const tempCollectionPath = path.resolve(fixturesDir, 'grpc-content-type-collection.json');
+      fs.writeFileSync(tempCollectionPath, JSON.stringify(grpcCollection, null, 2));
+
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      
+      const result = execSync(
+        `node cli.js "${protoPath}" "${tempCollectionPath}"`,
+        { encoding: 'utf8', cwd: process.cwd() }
+      );
+
+      expect(result).toContain('Coverage:');
+      
+      // Cleanup
+      fs.unlinkSync(tempCollectionPath);
+    });
+
+    test('should handle GraphQL with variables', () => {
+      const graphqlCollection = {
+        info: { name: "GraphQL Variables Test" },
+        item: [
+          {
+            name: "GraphQL with Variables",
+            request: {
+              method: "POST",
+              header: [{ key: "Content-Type", value: "application/json" }],
+              url: { raw: "http://api.example.com/graphql" },
+              body: {
+                mode: "raw",
+                raw: JSON.stringify({
+                  query: "query GetUser($id: ID!) { user(id: $id) { id name email } }",
+                  variables: { id: "123" }
+                })
+              }
+            },
+            event: [
+              {
+                listen: "test",
+                script: { exec: ["pm.test('Status', () => pm.response.to.have.status(200));"] }
+              }
+            ]
+          }
+        ]
+      };
+
+      const tempCollectionPath = path.resolve(fixturesDir, 'graphql-variables-collection.json');
+      fs.writeFileSync(tempCollectionPath, JSON.stringify(graphqlCollection, null, 2));
+
+      const graphqlPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      
+      const result = execSync(
+        `node cli.js "${graphqlPath}" "${tempCollectionPath}"`,
+        { encoding: 'utf8', cwd: process.cwd() }
+      );
+
+      expect(result).toContain('Coverage:');
+      
+      // Cleanup
+      fs.unlinkSync(tempCollectionPath);
+    });
+
+    test('should handle protocol mismatches gracefully', () => {
+      // Try to use REST collection with gRPC spec
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const restCollectionPath = path.resolve(fixturesDir, 'test-collection.json');
+      
+      const result = execSync(
+        `node cli.js "${protoPath}" "${restCollectionPath}"`,
+        { encoding: 'utf8', cwd: process.cwd() }
+      );
+
+      expect(result).toContain('Coverage:');
+      expect(result).toContain('Unmatched Spec operations:');
+    });
+  });
+
+  describe('Performance and Scalability', () => {
+    test('should handle large multi-protocol specifications efficiently', async () => {
+      const startTime = Date.now();
+      
+      const openApiPath = path.resolve(fixturesDir, 'sample-api.yaml');
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const graphqlPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const csvPath = path.resolve(fixturesDir, 'analytics-api.csv');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+
+      execSync(
+        `node cli.js "${openApiPath},${protoPath},${graphqlPath},${csvPath}" "${collectionPath}"`,
+        { cwd: process.cwd() }
+      );
+      
+      const executionTime = Date.now() - startTime;
+      expect(executionTime).toBeLessThan(10000); // Should complete within 10 seconds
+    });
+
+    test('should maintain memory efficiency with multiple protocols', () => {
+      const initialMemory = process.memoryUsage().heapUsed;
+      
+      const openApiPath = path.resolve(fixturesDir, 'sample-api.yaml');
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const graphqlPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+
+      execSync(
+        `node cli.js "${openApiPath},${protoPath},${graphqlPath}" "${collectionPath}"`,
+        { cwd: process.cwd() }
+      );
+      
+      const finalMemory = process.memoryUsage().heapUsed;
+      const memoryIncrease = finalMemory - initialMemory;
+      
+      // Memory increase should be reasonable (less than 100MB)
+      expect(memoryIncrease).toBeLessThan(100 * 1024 * 1024);
+    });
+  });
+
+  afterEach(() => {
+    // Clean up any generated reports
+    const reportFiles = [
+      'coverage-report.html',
+      'protocol-separation-report.html',
+      'debug-report.html',
+      'debug-report2.html'
+    ];
+    
+    reportFiles.forEach(file => {
+      const filePath = path.resolve(process.cwd(), file);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    });
+  });
+});
\ No newline at end of file
diff --git a/test/fixtures/multi-protocol-collection.json b/test/fixtures/multi-protocol-collection.json
new file mode 100644
index 0000000..f94980d
--- /dev/null
+++ b/test/fixtures/multi-protocol-collection.json
@@ -0,0 +1,180 @@
+{
+  "info": {
+    "name": "Multi-Protocol API Tests",
+    "description": "Tests for REST, gRPC, and GraphQL APIs",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "REST API Tests",
+      "item": [
+        {
+          "name": "Get User",
+          "request": {
+            "method": "GET",
+            "header": [],
+            "url": {
+              "raw": "{{baseUrl}}/users/123",
+              "host": ["{{baseUrl}}"],
+              "path": ["users", "123"]
+            }
+          },
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});"
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "gRPC API Tests",
+      "item": [
+        {
+          "name": "GetUser gRPC",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/grpc"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"user_id\": \"123\"}"
+            },
+            "url": {
+              "raw": "{{grpcUrl}}/user.v1.UserService/GetUser",
+              "host": ["{{grpcUrl}}"],
+              "path": ["user.v1.UserService", "GetUser"]
+            }
+          },
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});"
+                ]
+              }
+            }
+          ]
+        },
+        {
+          "name": "CreateUser gRPC",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/grpc"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}"
+            },
+            "url": {
+              "raw": "{{grpcUrl}}/user.v1.UserService/CreateUser",
+              "host": ["{{grpcUrl}}"],
+              "path": ["user.v1.UserService", "CreateUser"]
+            }
+          },
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});"
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "name": "GraphQL API Tests",
+      "item": [
+        {
+          "name": "Get User Query",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"query\": \"query GetUser($id: ID!) { user(id: $id) { id name email createdAt } }\", \"variables\": {\"id\": \"123\"}}"
+            },
+            "url": {
+              "raw": "{{graphqlUrl}}/graphql",
+              "host": ["{{graphqlUrl}}"],
+              "path": ["graphql"]
+            }
+          },
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});"
+                ]
+              }
+            }
+          ]
+        },
+        {
+          "name": "Create User Mutation",
+          "request": {
+            "method": "POST",
+            "header": [
+              {
+                "key": "Content-Type",
+                "value": "application/json"
+              }
+            ],
+            "body": {
+              "mode": "raw",
+              "raw": "{\"query\": \"mutation CreateUser($input: CreateUserInput!) { createUser(input: $input) { user { id name email } errors } }\", \"variables\": {\"input\": {\"name\": \"Jane Doe\", \"email\": \"jane@example.com\"}}}"
+            },
+            "url": {
+              "raw": "{{graphqlUrl}}/graphql",
+              "host": ["{{graphqlUrl}}"],
+              "path": ["graphql"]
+            }
+          },
+          "event": [
+            {
+              "listen": "test",
+              "script": {
+                "exec": [
+                  "pm.test('Status code is 200', function () {",
+                  "    pm.response.to.have.status(200);",
+                  "});"
+                ]
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/test/fixtures/user-schema.graphql b/test/fixtures/user-schema.graphql
new file mode 100644
index 0000000..2e81c17
--- /dev/null
+++ b/test/fixtures/user-schema.graphql
@@ -0,0 +1,91 @@
+type Query {
+  # Get user by ID
+  user(id: ID!): User
+  
+  # List all users
+  users(limit: Int, offset: Int): [User!]!
+  
+  # Search users by name
+  searchUsers(query: String!): [User!]!
+  
+  # Get user profile
+  userProfile(userId: ID!): UserProfile
+}
+
+type Mutation {
+  # Create a new user
+  createUser(input: CreateUserInput!): CreateUserPayload!
+  
+  # Update existing user
+  updateUser(id: ID!, input: UpdateUserInput!): UpdateUserPayload!
+  
+  # Delete user
+  deleteUser(id: ID!): DeleteUserPayload!
+  
+  # Update user profile
+  updateUserProfile(userId: ID!, input: UserProfileInput!): UserProfilePayload!
+}
+
+type Subscription {
+  # Subscribe to user updates
+  userUpdated(userId: ID!): User!
+  
+  # Subscribe to new user registrations
+  userRegistered: User!
+}
+
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  createdAt: String!
+  updatedAt: String!
+  profile: UserProfile
+}
+
+type UserProfile {
+  id: ID!
+  userId: ID!
+  bio: String
+  avatar: String
+  website: String
+  location: String
+}
+
+input CreateUserInput {
+  name: String!
+  email: String!
+  profile: UserProfileInput
+}
+
+input UpdateUserInput {
+  name: String
+  email: String
+}
+
+input UserProfileInput {
+  bio: String
+  avatar: String
+  website: String
+  location: String
+}
+
+type CreateUserPayload {
+  user: User!
+  errors: [String!]
+}
+
+type UpdateUserPayload {
+  user: User!
+  errors: [String!]
+}
+
+type DeleteUserPayload {
+  success: Boolean!
+  errors: [String!]
+}
+
+type UserProfilePayload {
+  profile: UserProfile!
+  errors: [String!]
+}
\ No newline at end of file
diff --git a/test/fixtures/user-service.proto b/test/fixtures/user-service.proto
new file mode 100644
index 0000000..a7f9c63
--- /dev/null
+++ b/test/fixtures/user-service.proto
@@ -0,0 +1,72 @@
+syntax = "proto3";
+
+package user.v1;
+
+service UserService {
+  // Get user by ID
+  rpc GetUser(GetUserRequest) returns (GetUserResponse);
+  
+  // Create a new user
+  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
+  
+  // Update existing user
+  rpc UpdateUser(UpdateUserRequest) returns (UpdateUserResponse);
+  
+  // Delete user
+  rpc DeleteUser(DeleteUserRequest) returns (DeleteUserResponse);
+  
+  // List users with pagination
+  rpc ListUsers(ListUsersRequest) returns (ListUsersResponse);
+}
+
+message GetUserRequest {
+  string user_id = 1;
+}
+
+message GetUserResponse {
+  User user = 1;
+}
+
+message CreateUserRequest {
+  string name = 1;
+  string email = 2;
+}
+
+message CreateUserResponse {
+  User user = 1;
+}
+
+message UpdateUserRequest {
+  string user_id = 1;
+  string name = 2;
+  string email = 3;
+}
+
+message UpdateUserResponse {
+  User user = 1;
+}
+
+message DeleteUserRequest {
+  string user_id = 1;
+}
+
+message DeleteUserResponse {
+  bool success = 1;
+}
+
+message ListUsersRequest {
+  int32 page = 1;
+  int32 page_size = 2;
+}
+
+message ListUsersResponse {
+  repeated User users = 1;
+  int32 total_count = 2;
+}
+
+message User {
+  string id = 1;
+  string name = 2;
+  string email = 3;
+  int64 created_at = 4;
+}
\ No newline at end of file
diff --git a/test/grpc-graphql.test.js b/test/grpc-graphql.test.js
new file mode 100644
index 0000000..965fda3
--- /dev/null
+++ b/test/grpc-graphql.test.js
@@ -0,0 +1,178 @@
+// grpc-graphql.test.js
+
+const { loadAndParseProto, extractOperationsFromProto, isProtoFile } = require('../lib/grpc');
+const { loadAndParseGraphQL, extractOperationsFromGraphQL, isGraphQLFile } = require('../lib/graphql');
+const { matchOperationsDetailed } = require('../lib/match');
+const { loadPostmanCollection, extractRequestsFromPostman } = require('../lib/postman');
+const path = require('path');
+
+describe('gRPC and GraphQL Support', () => {
+  const fixturesDir = path.resolve(__dirname, 'fixtures');
+  
+  describe('gRPC Protocol Buffer Support', () => {
+    test('should identify proto files correctly', () => {
+      expect(isProtoFile('test.proto')).toBe(true);
+      expect(isProtoFile('test.yaml')).toBe(false);
+      expect(isProtoFile('test.json')).toBe(false);
+    });
+
+    test('should load and parse proto file', async () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const root = await loadAndParseProto(protoPath);
+      
+      expect(root).toBeDefined();
+      expect(root.nested).toBeDefined();
+      expect(root.nested.user).toBeDefined();
+      expect(root.nested.user.nested.v1).toBeDefined();
+    });
+
+    test('should extract gRPC operations from proto', async () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const root = await loadAndParseProto(protoPath);
+      const operations = extractOperationsFromProto(root, true);
+      
+      expect(operations.length).toBeGreaterThan(0);
+      
+      // Find specific operations
+      const getUserOp = operations.find(op => op.grpcMethod === 'GetUser');
+      const createUserOp = operations.find(op => op.grpcMethod === 'CreateUser');
+      
+      expect(getUserOp).toBeDefined();
+      expect(getUserOp.protocol).toBe('grpc');
+      expect(getUserOp.method).toBe('post');
+      expect(getUserOp.path).toBe('/user.v1.UserService/GetUser');
+      expect(getUserOp.grpcService).toBe('user.v1.UserService');
+      
+      expect(createUserOp).toBeDefined();
+      expect(createUserOp.protocol).toBe('grpc');
+      expect(createUserOp.path).toBe('/user.v1.UserService/CreateUser');
+    });
+
+    test('should handle proto files that do not exist', async () => {
+      await expect(loadAndParseProto('nonexistent.proto')).rejects.toThrow('Proto file not found');
+    });
+  });
+
+  describe('GraphQL Schema Support', () => {
+    test('should identify GraphQL files correctly', () => {
+      expect(isGraphQLFile('schema.graphql')).toBe(true);
+      expect(isGraphQLFile('schema.gql')).toBe(true);
+      expect(isGraphQLFile('schema.yaml')).toBe(false);
+      expect(isGraphQLFile('schema.json')).toBe(false);
+    });
+
+    test('should load and parse GraphQL schema', () => {
+      const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const graphqlData = loadAndParseGraphQL(schemaPath);
+      
+      expect(graphqlData.schema).toBeDefined();
+      expect(graphqlData.ast).toBeDefined();
+      expect(graphqlData.content).toBeDefined();
+    });
+
+    test('should extract GraphQL operations from schema', () => {
+      const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const graphqlData = loadAndParseGraphQL(schemaPath);
+      const operations = extractOperationsFromGraphQL(graphqlData, true);
+      
+      expect(operations.length).toBeGreaterThan(0);
+      
+      // Find specific operations
+      const getUserQuery = operations.find(op => op.graphqlField === 'user' && op.graphqlType === 'query');
+      const createUserMutation = operations.find(op => op.graphqlField === 'createUser' && op.graphqlType === 'mutation');
+      const userSubscription = operations.find(op => op.graphqlField === 'userUpdated' && op.graphqlType === 'subscription');
+      
+      expect(getUserQuery).toBeDefined();
+      expect(getUserQuery.protocol).toBe('graphql');
+      expect(getUserQuery.method).toBe('post');
+      expect(getUserQuery.path).toBe('/graphql');
+      expect(getUserQuery.tags).toContain('GraphQL');
+      expect(getUserQuery.tags).toContain('Query');
+      
+      expect(createUserMutation).toBeDefined();
+      expect(createUserMutation.protocol).toBe('graphql');
+      expect(createUserMutation.tags).toContain('Mutation');
+      
+      expect(userSubscription).toBeDefined();
+      expect(userSubscription.tags).toContain('Subscription');
+    });
+
+    test('should handle GraphQL files that do not exist', () => {
+      expect(() => loadAndParseGraphQL('nonexistent.graphql')).toThrow('GraphQL file not found');
+    });
+  });
+
+  describe('Multi-Protocol Matching', () => {
+    test('should match gRPC operations with Postman requests', async () => {
+      const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+      
+      // Load gRPC operations
+      const root = await loadAndParseProto(protoPath);
+      const grpcOps = extractOperationsFromProto(root).map(op => ({
+        ...op,
+        apiName: 'User gRPC Service',
+        sourceFile: 'user-service.proto'
+      }));
+      
+      // Load Postman requests
+      const collection = loadPostmanCollection(collectionPath);
+      const postmanReqs = extractRequestsFromPostman(collection);
+      
+      // Match operations
+      const coverageItems = matchOperationsDetailed(grpcOps, postmanReqs, {
+        verbose: true,
+        strictQuery: false,
+        strictBody: false
+      });
+      
+      expect(coverageItems.length).toBe(grpcOps.length);
+      
+      // Check for specific matches
+      const getUserCoverage = coverageItems.find(item => item.name.includes('GetUser'));
+      const createUserCoverage = coverageItems.find(item => item.name.includes('CreateUser'));
+      
+      // Should find matches for gRPC requests
+      expect(getUserCoverage).toBeDefined();
+      expect(createUserCoverage).toBeDefined();
+    });
+
+    test('should match GraphQL operations with Postman requests', () => {
+      const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+      const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+      
+      // Load GraphQL operations
+      const graphqlData = loadAndParseGraphQL(schemaPath);
+      const graphqlOps = extractOperationsFromGraphQL(graphqlData).map(op => ({
+        ...op,
+        apiName: 'User GraphQL API',
+        sourceFile: 'user-schema.graphql'
+      }));
+      
+      // Load Postman requests
+      const collection = loadPostmanCollection(collectionPath);
+      const postmanReqs = extractRequestsFromPostman(collection);
+      
+      // Match operations
+      const coverageItems = matchOperationsDetailed(graphqlOps, postmanReqs, {
+        verbose: true,
+        strictQuery: false,
+        strictBody: false
+      });
+      
+      expect(coverageItems.length).toBe(graphqlOps.length);
+      
+      // Check for specific matches
+      const userQueryCoverage = coverageItems.find(item => 
+        item.name.includes('Query.user')
+      );
+      const createUserMutationCoverage = coverageItems.find(item => 
+        item.name.includes('Mutation.createUser')
+      );
+      
+      // Should find matches for GraphQL requests
+      expect(userQueryCoverage).toBeDefined();
+      expect(createUserMutationCoverage).toBeDefined();
+    });
+  });
+});
\ No newline at end of file
diff --git a/test/multi-protocol-cli.test.js b/test/multi-protocol-cli.test.js
new file mode 100644
index 0000000..3c14bb3
--- /dev/null
+++ b/test/multi-protocol-cli.test.js
@@ -0,0 +1,175 @@
+// multi-protocol-cli.test.js
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+describe('Multi-Protocol CLI Integration', () => {
+  const fixturesDir = path.resolve(__dirname, 'fixtures');
+  
+  beforeEach(() => {
+    // Clean up any existing reports
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    if (fs.existsSync(reportPath)) {
+      fs.unlinkSync(reportPath);
+    }
+  });
+
+  test('should handle gRPC proto file via CLI', () => {
+    const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+    const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+    
+    const result = execSync(
+      `node cli.js "${protoPath}" "${collectionPath}" --verbose`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('gRPC specification loaded successfully');
+    expect(result).toContain('Extracted gRPC operations from proto: 5');
+    expect(result).toContain('Coverage:');
+    expect(result).toContain('HTML report saved to: coverage-report.html');
+    
+    // Verify HTML report was generated
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    expect(fs.existsSync(reportPath)).toBe(true);
+    
+    // Check report contains protocol information
+    const reportContent = fs.readFileSync(reportPath, 'utf8');
+    expect(reportContent).toContain('Protocol');
+    expect(reportContent).toContain('"protocol":"grpc"'); // Check data contains protocol
+  });
+
+  test('should handle GraphQL schema file via CLI', () => {
+    const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+    const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+    
+    const result = execSync(
+      `node cli.js "${schemaPath}" "${collectionPath}" --verbose`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('GraphQL specification loaded successfully');
+    expect(result).toContain('Extracted GraphQL operations from schema: 10');
+    expect(result).toContain('Coverage:');
+    expect(result).toContain('HTML report saved to: coverage-report.html');
+    
+    // Verify HTML report was generated
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    expect(fs.existsSync(reportPath)).toBe(true);
+    
+    // Check report contains protocol information
+    const reportContent = fs.readFileSync(reportPath, 'utf8');
+    expect(reportContent).toContain('Protocol');
+    expect(reportContent).toContain('"protocol":"graphql"');
+  });
+
+  test('should handle mixed protocol APIs via CLI', () => {
+    const openApiPath = path.resolve(fixturesDir, 'sample-api.yaml');
+    const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+    const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+    const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+    
+    const result = execSync(
+      `node cli.js "${openApiPath},${protoPath},${schemaPath}" "${collectionPath}" --verbose`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('OpenAPI specification loaded successfully');
+    expect(result).toContain('gRPC specification loaded successfully');
+    expect(result).toContain('GraphQL specification loaded successfully');
+    expect(result).toContain('APIs analyzed:');
+    expect(result).toContain('Total operations in spec(s): 33');
+    expect(result).toContain('Coverage:');
+    
+    // Verify HTML report was generated
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    expect(fs.existsSync(reportPath)).toBe(true);
+    
+    // Check report contains all protocol information
+    const reportContent = fs.readFileSync(reportPath, 'utf8');
+    expect(reportContent).toContain('Protocol');
+    expect(reportContent).toContain('"protocol":"rest"');
+    expect(reportContent).toContain('"protocol":"grpc"');
+    expect(reportContent).toContain('"protocol":"graphql"');
+  });
+
+  test('should handle verbose output for all protocols', () => {
+    const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+    const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+    
+    const result = execSync(
+      `node cli.js "${protoPath}" "${collectionPath}" --verbose`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('Extracted gRPC operations from proto: 5');
+    expect(result).toContain('gRPC specification loaded successfully');
+    expect(result).toContain('Operations mapped:');
+    expect(result).toContain('Smart mapping:');
+  });
+
+  test('should maintain backward compatibility with OpenAPI files', () => {
+    const openApiPath = path.resolve(fixturesDir, 'sample-api.yaml');
+    const collectionPath = path.resolve(fixturesDir, 'test-collection.json');
+    
+    const result = execSync(
+      `node cli.js "${openApiPath}" "${collectionPath}" --verbose`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('OpenAPI specification loaded successfully');
+    expect(result).toContain('Coverage:');
+    expect(result).toContain('HTML report saved to: coverage-report.html');
+    
+    // Verify the report contains REST protocol
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    expect(fs.existsSync(reportPath)).toBe(true);
+    
+    const reportContent = fs.readFileSync(reportPath, 'utf8');
+    expect(reportContent).toContain('Protocol');
+    expect(reportContent).toContain('"protocol":"rest"');
+  });
+
+  test('should show correct protocol identification in unmatched operations', () => {
+    const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+    const schemaPath = path.resolve(fixturesDir, 'user-schema.graphql');
+    const collectionPath = path.resolve(fixturesDir, 'test-collection.json'); // Collection that doesn't match gRPC/GraphQL
+    
+    const result = execSync(
+      `node cli.js "${protoPath},${schemaPath}" "${collectionPath}"`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain('Unmatched Spec operations:');
+    expect(result).toContain('[POST] /user.v1.UserService/'); // gRPC operations
+    expect(result).toContain('[POST] /graphql'); // GraphQL operations
+  });
+
+  test('should handle custom output file with protocol support', () => {
+    const protoPath = path.resolve(fixturesDir, 'user-service.proto');
+    const collectionPath = path.resolve(fixturesDir, 'multi-protocol-collection.json');
+    const customOutput = 'grpc-test-report.html';
+    
+    const result = execSync(
+      `node cli.js "${protoPath}" "${collectionPath}" --output "${customOutput}"`,
+      { encoding: 'utf8', cwd: process.cwd() }
+    );
+    
+    expect(result).toContain(`HTML report saved to: ${customOutput}`);
+    
+    // Verify custom output file was created
+    const reportPath = path.resolve(process.cwd(), customOutput);
+    expect(fs.existsSync(reportPath)).toBe(true);
+    
+    // Clean up custom file
+    fs.unlinkSync(reportPath);
+  });
+
+  afterEach(() => {
+    // Clean up test reports
+    const reportPath = path.resolve(process.cwd(), 'coverage-report.html');
+    if (fs.existsSync(reportPath)) {
+      fs.unlinkSync(reportPath);
+    }
+  });
+});
\ No newline at end of file