@anyshift/mcp-proxy 0.6.7 → 0.6.8

package/dist/fileWriter/writer.js

@@ -1,5 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
+import Papa from 'papaparse';
 import { generateToolId } from '../utils/filename.js';
 import { generateQueryAssistSchema, generateJsonlQueryAssistSchema } from './schema.js';
 import { parseDynatraceDqlResponse, isDynatraceDqlTool, } from './dynatrace.js';
@@ -10,18 +11,85 @@ const FILE_WRITTEN_MESSAGE = `To read this file, use the "mcp__file_query__execu
 
 IMPORTANT for supporting facts: This tool_id CANNOT be used as the proxy_tool_id in your output's supporting_facts evidence. You must read the file using one of the tools above and use THAT tool's tool_id as the proxy_tool_id to support facts in your output.`;
 /**
- * Detect whether content is JSON, JSONL, or plain text
+ * Detect if content is CSV and convert to JSONL using papaparse
+ * Handles: auto-delimiter detection, header detection, quoted fields, etc.
+ */
+function detectAndConvertCsv(content) {
+    const trimmed = content.trim();
+    // Skip if empty
+    if (!trimmed) {
+        return { isCsv: false, hasHeaders: false };
+    }
+    // Skip if it looks like JSON
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return { isCsv: false, hasHeaders: false };
+    }
+    // First, try parsing WITH headers
+    const resultWithHeaders = Papa.parse(trimmed, {
+        header: true,
+        skipEmptyLines: true,
+        dynamicTyping: false,
+    });
+    // Check if parsing was successful and looks like valid CSV
+    const hasFields = resultWithHeaders.meta.fields && resultWithHeaders.meta.fields.length > 0;
+    const hasData = resultWithHeaders.data.length > 0;
+    const hasDelimiter = resultWithHeaders.meta.delimiter !== undefined;
+    if (!hasFields || !hasData || !hasDelimiter) {
+        return { isCsv: false, hasHeaders: false };
+    }
+    // Check if headers look valid (not numeric, reasonable length)
+    const fields = resultWithHeaders.meta.fields;
+    const looksLikeHeaders = fields.every(h => {
+        const cleaned = h.trim();
+        return (cleaned.length > 0 &&
+            cleaned.length < 100 &&
+            !/^[\d.]+$/.test(cleaned) // Not purely numeric
+        );
+    });
+    if (looksLikeHeaders) {
+        // Use header mode - convert to JSONL with objects
+        const jsonLines = resultWithHeaders.data.map(row => JSON.stringify(row));
+        return {
+            isCsv: true,
+            jsonlContent: jsonLines.join('\n'),
+            headers: fields,
+            rowCount: jsonLines.length,
+            hasHeaders: true,
+            delimiter: resultWithHeaders.meta.delimiter,
+        };
+    }
+    else {
+        // Headers don't look valid - parse without headers (as arrays)
+        const resultNoHeaders = Papa.parse(trimmed, {
+            header: false,
+            skipEmptyLines: true,
+            dynamicTyping: false,
+        });
+        const jsonLines = resultNoHeaders.data.map(row => JSON.stringify(row));
+        return {
+            isCsv: true,
+            jsonlContent: jsonLines.join('\n'),
+            headers: undefined,
+            rowCount: jsonLines.length,
+            hasHeaders: false,
+            delimiter: resultNoHeaders.meta.delimiter,
+        };
+    }
+}
+/**
+ * Detect whether content is JSON, JSONL, CSV, or plain text
+ * Returns format and CSV conversion result (if applicable) to avoid double parsing
  */
 function detectContentFormat(content) {
     const trimmed = content.trim();
     // Empty content
     if (!trimmed)
-        return 'text';
+        return { format: 'text' };
     // Try parsing as single JSON object/array
     if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
         try {
             JSON.parse(trimmed);
-            return 'json';
+            return { format: 'json' };
         }
         catch {
             // Could be JSONL starting with {
@@ -42,10 +110,15 @@ function detectContentFormat(content) {
             }
         });
         if (allSampledLinesAreJson) {
-            return 'jsonl';
+            return { format: 'jsonl' };
         }
     }
-    return 'text';
+    // Check for CSV format - store result to avoid re-parsing later
+    const csvResult = detectAndConvertCsv(trimmed);
+    if (csvResult.isCsv) {
+        return { format: 'csv', csvConversion: csvResult };
+    }
+    return { format: 'text' };
 }
 /**
  * Get file extension based on content format
@@ -353,24 +426,66 @@ export async function handleToolResponse(config, toolName, args, responseData) {
     // Success case: write to file
     try {
         // Detect content format for appropriate extension and schema
-        const format = detectContentFormat(contentToWrite);
-        const extension = getFileExtension(format);
+        // This also returns CSV conversion result if applicable, to avoid double parsing
+        const detection = detectContentFormat(contentToWrite);
+        // Handle format conversion to JSONL for non-JSON formats
+        let finalContent = contentToWrite;
+        let finalFormat = detection.format;
+        let conversionWarning;
+        if (detection.format === 'csv' && detection.csvConversion) {
+            // CSV: Use the already-converted JSONL from detection
+            const csvResult = detection.csvConversion;
+            if (csvResult.jsonlContent) {
+                finalContent = csvResult.jsonlContent;
+                finalFormat = 'jsonl';
+                const delimiterName = csvResult.delimiter === '\t' ? 'tab' :
+                    csvResult.delimiter === ';' ? 'semicolon' :
+                        csvResult.delimiter === '|' ? 'pipe' : 'comma';
+                if (csvResult.hasHeaders) {
+                    conversionWarning = `NOTE: Original data was CSV/DSV format (${delimiterName}-delimited). ` +
+                        `Converted to JSONL assuming first row was the header. ` +
+                        `Headers detected: [${csvResult.headers?.join(', ')}]. ` +
+                        `Rows converted: ${csvResult.rowCount}. ` +
+                        `If the data looks incorrect, the first row may not have been a header.`;
+                }
+                else {
+                    conversionWarning = `NOTE: Original data was CSV/DSV format (${delimiterName}-delimited) without detectable headers. ` +
+                        `Converted to JSONL as arrays (one array per row). ` +
+                        `Each row is: ["field1", "field2", ...]. ` +
+                        `Rows converted: ${csvResult.rowCount}. ` +
+                        `Access fields by index: .[0], .[1], etc.`;
+                }
+            }
+        }
+        else if (detection.format === 'text') {
+            // Plain text/markdown/other: Wrap each line as JSON object for jq compatibility
+            const lines = contentToWrite.split('\n');
+            const jsonLines = lines
+                .map((line, index) => JSON.stringify({ line_number: index + 1, content: line }));
+            finalContent = jsonLines.join('\n');
+            finalFormat = 'jsonl';
+            conversionWarning = `NOTE: Original data was plain text (not JSON/CSV). ` +
+                `Artificially converted to JSONL to make it accessible to the jq tool. ` +
+                `Each line is wrapped as: {"line_number": N, "content": "original line text"}. ` +
+                `Total lines: ${lines.length}.`;
+        }
+        const extension = getFileExtension(finalFormat);
         const filename = `${tool_id}${extension}`;
         const filepath = path.join(config.outputPath, filename);
         // Ensure output directory exists
         await fs.mkdir(config.outputPath, { recursive: true });
-        // Write the exact content we counted
-        await fs.writeFile(filepath, contentToWrite);
+        // Write the content (converted if CSV)
+        await fs.writeFile(filepath, finalContent);
         // Generate query-assist schema based on format
         let fileSchema;
-        if (format === 'jsonl') {
+        if (finalFormat === 'jsonl') {
             // JSONL format: sample multiple records for schema
-            const lines = contentToWrite.trim().split('\n').filter(l => l.trim());
+            const lines = finalContent.trim().split('\n').filter(l => l.trim());
             fileSchema = generateJsonlQueryAssistSchema(lines, {
                 maxDepth: config.schemaMaxDepth ?? 2,
                 maxPaths: config.schemaMaxPaths ?? 20,
                 maxKeys: config.schemaMaxKeys ?? 50,
-                dataSize: contentLength,
+                dataSize: finalContent.length,
                 totalLines: lines.length,
                 sampleSize: 5
             });
@@ -388,12 +503,16 @@ export async function handleToolResponse(config, toolName, args, responseData) {
                 dataSize: contentLength
             });
         }
+        // Build message with optional conversion warning
+        const message = conversionWarning
+            ? `${conversionWarning}\n\n${FILE_WRITTEN_MESSAGE}`
+            : FILE_WRITTEN_MESSAGE;
         return {
             tool_id,
             wroteToFile: true,
             filePath: filepath,
             fileSchema,
-            message: FILE_WRITTEN_MESSAGE,
+            message,
         };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyshift/mcp-proxy",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Generic MCP proxy that adds truncation, file writing, and JQ capabilities to any MCP server",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.24.0",
     "glob": "^13.0.0",
+    "papaparse": "^5.5.3",
     "zod": "^3.24.2"
   },
   "devDependencies": {
@@ -22,6 +23,7 @@
     "@types/glob": "^9.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.0.0",
+    "@types/papaparse": "^5.5.2",
     "jest": "^30.2.0",
     "ts-jest": "^29.4.5",
     "tsx": "^4.7.0",