Implemented tsvValidate

Author: VisLab

package-lock.json

@@ -16,10 +16,10 @@ import {
   ValidateHedStringArgs 
 } from "./tools/validateHedString.js";
 import {
-  validateHedSidecar,
-  handleValidateHedSidecar,
-  ValidateHedSidecarArgs
-} from "./tools/validateHedSidecar.js";
+  parseHedSidecar,
+  handleParseHedSidecar,
+  ParseHedSidecarArgs
+} from "./tools/parseHedSidecar.js";
 import {
   validateHedTsv,
   handleValidateHedTsv,
@@ -64,7 +64,7 @@ class HEDMCPServer {
     // List available tools
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
-        tools: [validateHedString, validateHedSidecar, validateHedTsv],
+        tools: [validateHedString, parseHedSidecar, validateHedTsv],
       };
     });
 
@@ -84,8 +84,8 @@ class HEDMCPServer {
             ],
           };
 
-        case "validateHedSidecar":
-          const sidecarResult = await handleValidateHedSidecar(args as ValidateHedSidecarArgs);
+        case "parseHedSidecar":
+          const sidecarResult = await handleParseHedSidecar(args as ParseHedSidecarArgs);
           return {
             content: [
               {

src/server.ts

@@ -0,0 +1,93 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import * as path from "path";
+import { FormattedIssue, ParseHedSidecarResult } from "../types/index.js";
+import { formatIssue, formatIssues, separateIssuesBySeverity } from "../utils/issueFormatter.js";
+import { readFileFromPath } from "../utils/fileReader.js";
+import { schemaCache } from '../utils/schemaCache.js';
+import { mcpToZod } from '../utils/mcpToZod.js';
+
+// Import HED validation functions
+import { buildSchemasFromVersion, BidsSidecar } from "hed-validator";
+
+// Define the MCP inputSchema first
+const parseHedSidecarInputSchema = {
+  type: "object" as const,
+  properties: {
+    filePath: {
+      type: "string" as const,
+      description: "The absolute path to the sidecar file to parse"
+    },
+    hedVersion: {
+      type: "string" as const,
+      description: "The HED schema version to use (e.g., 8.4.0 or lang_1.1.0, score_2.1.0)"
+    },
+    checkForWarnings: {
+      type: "boolean" as const,
+      description: "Whether to check for warnings in addition to errors",
+      default: false
+    },
+    fileData: {
+      type: "string" as const,
+      description: "Optional JSON string containing the sidecar data to use instead of reading from filePath"
+    }
+  },
+  required: ["filePath", "hedVersion"]
+};
+
+// Generate Zod schema from MCP schema
+const ParseHedSidecarSchema = mcpToZod(parseHedSidecarInputSchema);
+
+export type ParseHedSidecarArgs = z.infer<typeof ParseHedSidecarSchema>;
+
+/**
+ * Tool definition for parsing HED sidecar files
+ */
+export const parseHedSidecar: Tool = {
+  name: "parseHedSidecar",
+  description: "Parses a HED sidecar file using the specified HED schema version",
+  inputSchema: parseHedSidecarInputSchema
+};
+
+/**
+ * Parse a HED sidecar file using the specified HED schema version.
+ */
+export async function handleParseHedSidecar(args: ParseHedSidecarArgs): Promise<ParseHedSidecarResult> {
+  const { filePath, hedVersion, checkForWarnings = false, fileData } = args;
+
+  try {
+    // Use schema cache to get or create the HED schemas
+    const hedSchemas = await schemaCache.getOrCreateSchema(hedVersion);
+
+    // Get the file data if not provided
+    let data = fileData;
+    if (!data) {
+        data = await readFileFromPath(filePath);
+    }
+
+    // Parse JSON data (fileData is always a string now)
+    const jsonData = JSON.parse(data);
+   
+    const fileName = path.basename(filePath) || "sidecar.json"; // Properly extract filename using path.basename
+    const sidecar = new BidsSidecar(fileName, { path: filePath, name: fileName }, jsonData);
+    const validationIssues = sidecar.validate(hedSchemas);
+    
+    // Format all validation issues
+    const allFormattedIssues = formatIssues(validationIssues);
+    
+    // Separate issues by severity
+    const { errors: formattedErrors, others: formattedWarnings } = separateIssuesBySeverity(allFormattedIssues);
+    
+    // Only include warnings if checkForWarnings is true
+    const finalWarnings = checkForWarnings ? formattedWarnings : [];
+
+    return {
+      parsedHedSidecar: JSON.stringify(jsonData),
+      errors: formattedErrors,
+      warnings: finalWarnings
+    };
+
+  } catch (error) {
+    return {parsedHedSidecar: "", errors: [formatIssue(error)], warnings: []};
+  }
+}

src/tools/parseHedSidecar.ts

@@ -1,7 +1,7 @@
 import { Tool } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { FormattedIssue, HedValidationResult } from "../types/index.js";
-import { formatIssues, separateIssuesBySeverity } from "../utils/issueFormatter.js";
+import { formatIssue, formatIssues, separateIssuesBySeverity } from "../utils/issueFormatter.js";
 import { schemaCache } from '../utils/schemaCache.js';
 import { createDefinitionManager } from '../utils/definitionProcessor.js';
 import { mcpToZod } from '../utils/mcpToZod.js';
@@ -67,11 +67,7 @@ export async function handleValidateHedString(args: ValidateHedStringArgs): Prom
 
     // If there are errors in definition processing, return them immediately
     if (definitionResult.errors.length > 0) {
-      return {
-        isValid: false,
-        errors: definitionResult.errors,
-        warnings: checkForWarnings ? definitionResult.warnings : []
-      };
+      return {errors: definitionResult.errors, warnings: checkForWarnings ? definitionResult.warnings : []};
     }
 
     const defManager = definitionResult.definitionManager;
@@ -87,30 +83,13 @@ export async function handleValidateHedString(args: ValidateHedStringArgs): Prom
 
     // For HED string validation, errors and warnings come pre-separated from parseStandaloneString
     // But we could also use separateIssuesBySeverity if we had mixed issues
-    const isValid = allErrors.length === 0;
 
     // Combine definition warnings with HED string warnings (only if checkForWarnings is true)
     const finalWarnings = checkForWarnings ? [...definitionWarnings, ...allWarnings] : [];
 
-    return {
-      isValid: isValid,
-      errors: allErrors,
-      warnings: finalWarnings
-    };
+    return { errors: allErrors, warnings: finalWarnings}; 
 
   } catch (error) {
-    return {
-      isValid: false,
-      errors: [{
-        code: "INTERNAL_ERROR",
-        detailedCode: "unExpectedErrorDuringValidation",
-        severity: "error",
-        message: `Validation failed: ${error && typeof error === "object" && "message" in error ? error.message : error instanceof Error ? error.message : 'Unknown error'}`,
-        line: "",
-        column: "",
-        location: ""
-      } as FormattedIssue],
-      warnings: []
-    };
+    return { errors: [formatIssue(error)], warnings: []};
   }
 }