json-explorer-mcp 1.0.2 → 1.0.4

package/README.md

@@ -110,6 +110,80 @@ Retrieve the value at a specific path. Large values are automatically truncated.
 json_get(file: "/path/to/data.json", path: "$.users[0]")
 ```
 
+### json_set
+
+Set a value at a specific JSONPath with optional schema validation.
+
+```typescript
+json_set(
+  file: "/path/to/data.json",
+  path: "$.users[0].name",
+  value: "New Name"
+)
+```
+
+With schema validation (validates before writing):
+
+```typescript
+json_set(
+  file: "/path/to/data.json",
+  path: "$.users[0]",
+  value: { id: 1, name: "Alice", email: "alice@example.com" },
+  schema: "/path/to/user-schema.json"
+)
+```
+
+With inferred schema (infers type from existing value):
+
+```typescript
+json_set(
+  file: "/path/to/data.json",
+  path: "$.config.maxRetries",
+  value: 5,
+  inferSchema: true  // Will reject if new value type doesn't match existing
+)
+```
+
+With dry run (validates without writing):
+
+```typescript
+json_set(
+  file: "/path/to/data.json",
+  path: "$.config.enabled",
+  value: true,
+  dryRun: true,      // Returns result without modifying file
+  outputFile: "/path/to/output.json"  // Or write to different file
+)
+```
+
+Returns:
+
+```json
+{
+  "success": true,
+  "path": "$.config.enabled",
+  "previousValue": false,
+  "newValue": true,
+  "dryRun": false,
+  "outputFile": "/path/to/data.json"
+}
+```
+
+On validation failure:
+
+```json
+{
+  "success": false,
+  "path": "$.config.maxRetries",
+  "previousValue": 3,
+  "newValue": "not a number",
+  "validationErrors": [
+    { "path": "$", "message": "must be integer" }
+  ],
+  "dryRun": true
+}
+```
+
 ### json_schema
 
 Infer the JSON schema/structure at a path. For arrays, samples items to determine the item schema.
@@ -144,6 +218,7 @@ Validate JSON data against a JSON Schema. Schema can be provided inline or as a
 **Features:**
 - Automatic resolution of local file `$ref` references
 - Optional network `$ref` resolution (disabled by default)
+- Schema registry for pre-registering schemas by URI (map remote refs to local files)
 - Validates that referenced files are actual JSON Schemas
 - Error limiting (default 10) to avoid huge error lists
 
@@ -177,6 +252,33 @@ json_validate(
 )
 ```
 
+With pre-registered schemas (for complex `$ref` scenarios):
+
+```typescript
+json_validate(
+  file: "/path/to/data.json",
+  schema: "/path/to/schema.json",
+  schemas: {
+    // Map URIs to local files or inline schemas
+    "https://example.com/schemas/user.json": "/local/path/to/user-schema.json",
+    "https://example.com/schemas/address.json": { type: "object", properties: { ... } }
+  }
+)
+```
+
+With schema directory (loads all schemas by their `$id`):
+
+```typescript
+json_validate(
+  file: "/path/to/data.json",
+  schema: {},  // Not needed when using schemaDir+schemaId
+  schemaDir: "/path/to/schemas/",   // Directory with .json schema files
+  schemaId: "main-schema"           // $id of the entrypoint schema
+)
+```
+
+This is useful when you have a directory of interconnected schemas that reference each other by `$id`. All `.json` files in the directory are loaded and registered by their `$id` (or filename if no `$id` is present).
+
 Returns:
 
 ```json

package/dist/index.js

@@ -3,11 +3,11 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { jsonInspect, jsonSchema, jsonValidate } from "./tools/structure.js";
-import { jsonKeys, jsonGet } from "./tools/navigation.js";
+import { jsonKeys, jsonGet, jsonSet } from "./tools/navigation.js";
 import { jsonSearch, jsonSample, jsonStats } from "./tools/query.js";
 const server = new McpServer({
     name: "json-explorer",
-    version: "1.0.0",
+    version: "1.0.4",
 });
 // Tool: json_inspect - Get file overview
 server.tool("json_inspect", "Get an overview of a JSON file including size, structure type, and a depth-limited preview. Use this first to understand what you're working with.", {
@@ -94,6 +94,44 @@ server.tool("json_get", "Retrieve the value at a specific path. Large values are
         };
     }
 });
+// Tool: json_set - Set value at path with optional schema validation
+server.tool("json_set", "Set a value at a specific JSONPath. Supports schema validation (inline, file, or inferred from existing data) and dry-run mode. Can write to the source file or a different output file.", {
+    file: z.string().describe("Absolute path to the JSON file to modify"),
+    path: z.string().describe("JSONPath where to set the value (e.g., '$.users[0].name', 'config.enabled')"),
+    value: z.unknown().describe("The value to set at the path"),
+    schema: z.union([z.string(), z.object({}).passthrough()]).optional().describe("JSON Schema to validate value against (inline object or path to schema file)"),
+    inferSchema: z.boolean().optional().describe("If true, infers schema from existing value at path and validates against it. Defaults to false."),
+    dryRun: z.boolean().optional().describe("If true, validates and returns result without writing to file. Defaults to false."),
+    outputFile: z.string().optional().describe("Output file path. If not provided, writes to the source file."),
+}, { readOnlyHint: false }, async ({ file, path, value, schema, inferSchema, dryRun, outputFile }) => {
+    try {
+        const result = await jsonSet(file, path, value, {
+            schema,
+            inferSchema,
+            dryRun,
+            outputFile,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
 // Tool: json_schema - Infer structure
 server.tool("json_schema", "Infer the JSON schema/structure at a path. For arrays, samples items to determine the item schema.", {
     file: z.string().describe("Absolute path to the JSON file"),
@@ -123,19 +161,25 @@ server.tool("json_schema", "Infer the JSON schema/structure at a path. For array
     }
 });
 // Tool: json_validate - Validate against JSON Schema
-server.tool("json_validate", "Validate JSON data against a JSON Schema. Schema can be provided inline or as a path to a schema file. Automatically resolves local file $refs. Use resolveNetworkRefs to also fetch remote schemas.", {
+server.tool("json_validate", "Validate JSON data against a JSON Schema. Schema can be provided inline, as a file path, or loaded from a directory by $id. Automatically resolves local file $refs. Use schemas to pre-register schemas by URI, or schemaDir+schemaId to load all schemas from a directory.", {
     file: z.string().describe("Absolute path to the JSON file to validate"),
-    schema: z.union([z.string(), z.object({}).passthrough()]).describe("JSON Schema object or path to schema file"),
+    schema: z.union([z.string(), z.object({}).passthrough()]).optional().describe("JSON Schema object or path to schema file. Optional if using schemaDir+schemaId."),
     path: z.string().optional().describe("JSONPath to validate. Defaults to root."),
     errorLimit: z.number().optional().describe("Maximum number of errors to return. Defaults to 10."),
     resolveLocalRefs: z.boolean().optional().describe("Resolve $ref to local files. Defaults to true."),
     resolveNetworkRefs: z.boolean().optional().describe("Resolve $ref to HTTP URLs. Defaults to false for security."),
-}, { readOnlyHint: true }, async ({ file, schema, path, errorLimit, resolveLocalRefs, resolveNetworkRefs }) => {
+    schemas: z.record(z.union([z.string(), z.object({}).passthrough()])).optional().describe("Pre-register schemas by URI. Map of URI to schema file path or inline schema object."),
+    schemaDir: z.string().optional().describe("Directory containing schema files. All .json files will be loaded and registered by their $id."),
+    schemaId: z.string().optional().describe("When using schemaDir, the $id of the schema to use as entrypoint."),
+}, { readOnlyHint: true }, async ({ file, schema, path, errorLimit, resolveLocalRefs, resolveNetworkRefs, schemas, schemaDir, schemaId }) => {
     try {
-        const result = await jsonValidate(file, schema, path, {
+        const result = await jsonValidate(file, schema ?? {}, path, {
             errorLimit,
             resolveLocalRefs,
             resolveNetworkRefs,
+            schemas,
+            schemaDir,
+            schemaId,
         });
         return {
             content: [
@@ -220,7 +264,7 @@ server.tool("json_sample", "Get sample items from an array. Supports first, last
     }
 });
 // Tool: json_stats - Aggregate statistics for arrays
-server.tool("json_stats", "Get aggregate statistics for array fields. If no path provided, discovers all arrays in the file. With a path, returns counts, min/max/avg for numbers, value distributions for strings.", {
+server.tool("json_stats", "Get aggregate statistics for arrays. Supports arrays of objects (field-level stats), strings (length distribution), numbers (min/max/avg/median/stdDev/percentiles), and mixed types. If no path provided, discovers and analyzes all arrays in the file.", {
     file: z.string().describe("Absolute path to the JSON file"),
     path: z.string().optional().describe("JSONPath to the array. If omitted, discovers and lists all arrays in the file."),
     fields: z.array(z.string()).optional().describe("Specific fields to analyze. If not provided, analyzes all top-level fields."),

package/dist/tools/navigation.d.ts

@@ -19,3 +19,26 @@ export interface GetResult {
     originalSize?: number;
 }
 export declare function jsonGet(filePath: string, path: string, maxSize?: number): Promise<GetResult>;
+export interface SetOptions {
+    /** JSON Schema to validate against (inline object or file path) */
+    schema?: object | string;
+    /** Infer schema from existing value at path. Defaults to false. */
+    inferSchema?: boolean;
+    /** If true, only validate without writing. Returns the modified JSON. */
+    dryRun?: boolean;
+    /** Output file path. If not provided, writes to the source file. */
+    outputFile?: string;
+}
+export interface SetResult {
+    success: boolean;
+    path: string;
+    previousValue?: unknown;
+    newValue: unknown;
+    validationErrors?: Array<{
+        path: string;
+        message: string;
+    }>;
+    outputFile?: string;
+    dryRun: boolean;
+}
+export declare function jsonSet(filePath: string, path: string, value: unknown, options?: SetOptions): Promise<SetResult>;

package/dist/tools/navigation.js

@@ -1,5 +1,6 @@
 import { loadJson, getValueType, truncateValue, getValuePreview } from "../utils/json-parser.js";
-import { getValueAtPath, getKeysAtPath, buildPathTo } from "../utils/path-helpers.js";
+import { getValueAtPath, getKeysAtPath, buildPathTo, setValueAtPath } from "../utils/path-helpers.js";
+import { writeFile } from "fs/promises";
 export async function jsonKeys(filePath, path, limit = 50) {
     const data = await loadJson(filePath);
     const targetPath = path || "$";
@@ -95,3 +96,107 @@ export async function jsonGet(filePath, path, maxSize = 5000) {
         ...(truncated && { originalSize }),
     };
 }
+// Dynamic import for ajv (ESM/CJS compat)
+async function getAjv() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const ajvModule = await import("ajv");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const formatsModule = await import("ajv-formats");
+    const Ajv = ajvModule.default || ajvModule;
+    const addFormats = formatsModule.default || formatsModule;
+    return { Ajv, addFormats };
+}
+// Infer a simple JSON Schema from a value
+function inferSimpleSchema(value) {
+    if (value === null) {
+        return { type: "null" };
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return { type: "array" };
+        }
+        // Sample first item for items schema
+        return { type: "array", items: inferSimpleSchema(value[0]) };
+    }
+    if (typeof value === "object") {
+        const properties = {};
+        for (const [key, val] of Object.entries(value)) {
+            properties[key] = inferSimpleSchema(val);
+        }
+        return { type: "object", properties };
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? { type: "integer" } : { type: "number" };
+    }
+    return { type: typeof value };
+}
+export async function jsonSet(filePath, path, value, options = {}) {
+    const { schema, inferSchema: shouldInferSchema = false, dryRun = false, outputFile, } = options;
+    // Load the JSON file
+    const data = await loadJson(filePath);
+    // Deep clone to avoid mutating cached data
+    const clonedData = JSON.parse(JSON.stringify(data));
+    // Get previous value at path (may be undefined if path doesn't exist yet)
+    const previousValue = getValueAtPath(clonedData, path);
+    // Determine schema for validation
+    let schemaToValidate;
+    if (schema) {
+        if (typeof schema === "string") {
+            // Load schema from file
+            schemaToValidate = (await loadJson(schema));
+        }
+        else {
+            schemaToValidate = schema;
+        }
+    }
+    else if (shouldInferSchema && previousValue !== undefined) {
+        // Infer schema from existing value
+        schemaToValidate = inferSimpleSchema(previousValue);
+    }
+    // Validate the new value against schema
+    if (schemaToValidate) {
+        const { Ajv, addFormats } = await getAjv();
+        const ajv = new Ajv({ allErrors: true });
+        addFormats(ajv);
+        const validate = ajv.compile(schemaToValidate);
+        const valid = validate(value);
+        if (!valid) {
+            const errors = (validate.errors || []).map((err) => ({
+                path: err.instancePath || "$",
+                message: err.message || "Unknown error",
+            }));
+            return {
+                success: false,
+                path,
+                previousValue,
+                newValue: value,
+                validationErrors: errors,
+                dryRun: true, // Force dryRun on validation failure
+            };
+        }
+    }
+    // Set the value at path
+    const modifiedData = setValueAtPath(clonedData, path, value);
+    // If dry run, return the modified data without writing
+    if (dryRun) {
+        return {
+            success: true,
+            path,
+            previousValue,
+            newValue: value,
+            dryRun: true,
+        };
+    }
+    // Write to file
+    const targetFile = outputFile || filePath;
+    const jsonOutput = JSON.stringify(modifiedData, null, 2) + "\n";
+    await writeFile(targetFile, jsonOutput, "utf-8");
+    return {
+        success: true,
+        path,
+        previousValue,
+        newValue: value,
+        outputFile: targetFile,
+        dryRun: false,
+    };
+}

package/dist/tools/structure.d.ts

@@ -35,6 +35,12 @@ export interface ValidateOptions {
     errorLimit?: number;
     resolveLocalRefs?: boolean;
     resolveNetworkRefs?: boolean;
+    /** Pre-register schemas by URI. Value can be inline schema object or path to schema file. */
+    schemas?: Record<string, object | string>;
+    /** Directory containing schema files. All .json files will be loaded and registered by their $id. */
+    schemaDir?: string;
+    /** When using schemaDir, specify the $id of the schema to use as entrypoint (instead of schema param). */
+    schemaId?: string;
 }
 export declare function jsonValidate(filePath: string, schema: object | string, path?: string, options?: ValidateOptions | number): Promise<ValidateResult>;
 export {};

package/dist/tools/structure.js

@@ -1,6 +1,7 @@
 import { loadJson, getFileInfo, formatBytes, getValueType } from "../utils/json-parser.js";
 import { getDepthPreview, getValueAtPath } from "../utils/path-helpers.js";
-import { dirname, resolve, isAbsolute } from "path";
+import { dirname, resolve, isAbsolute, join } from "path";
+import { readdir } from "fs/promises";
 // Dynamic import for ajv (ESM/CJS compat)
 async function getAjv() {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -213,6 +214,34 @@ function isValidJsonSchema(obj) {
     const isEmpty = Object.keys(schema).length === 0;
     return hasSchemaKeyword || isEmpty;
 }
+// Load all JSON schema files from a directory, returning map of $id -> schema
+async function loadSchemasFromDir(dir) {
+    const schemas = new Map();
+    const files = await readdir(dir);
+    const jsonFiles = files.filter(f => f.endsWith(".json"));
+    for (const file of jsonFiles) {
+        const filePath = join(dir, file);
+        try {
+            const schema = await loadJson(filePath);
+            if (!isValidJsonSchema(schema)) {
+                continue; // Skip non-schema JSON files
+            }
+            const schemaRecord = schema;
+            const id = schemaRecord.$id;
+            if (id) {
+                schemas.set(id, { schema, file: filePath });
+            }
+            else {
+                // Use filename as fallback id
+                schemas.set(file, { schema, file: filePath });
+            }
+        }
+        catch {
+            // Skip files that can't be loaded
+        }
+    }
+    return schemas;
+}
 // Fetch a schema from a URL
 async function fetchNetworkSchema(url) {
     const response = await fetch(url);
@@ -238,24 +267,36 @@ export async function jsonValidate(filePath, schema, path, options = {}) {
         : options;
     // Environment variable can completely disable network refs for security
     const networkRefsDisabled = process.env.JSON_EXPLORER_NO_NETWORK === "1";
-    const { errorLimit = 10, resolveLocalRefs = true, resolveNetworkRefs = false, } = opts;
+    const { errorLimit = 10, resolveLocalRefs = true, resolveNetworkRefs = false, schemas = {}, schemaDir, schemaId, } = opts;
     const effectiveResolveNetworkRefs = resolveNetworkRefs && !networkRefsDisabled;
     const data = await loadJson(filePath);
     const targetData = path ? getValueAtPath(data, path) : data;
     if (targetData === undefined) {
         throw new Error(`Path not found: ${path}`);
     }
-    // Load schema from file if it's a string path
+    // Load schema - from schemaDir+schemaId, file path, or inline
     let schemaObj;
-    let schemaDir;
-    if (typeof schema === "string") {
+    let schemaBaseDir;
+    let dirSchemas;
+    if (schemaDir && schemaId) {
+        // Load all schemas from directory and use schemaId as entrypoint
+        dirSchemas = await loadSchemasFromDir(schemaDir);
+        const entry = dirSchemas.get(schemaId);
+        if (!entry) {
+            const availableIds = Array.from(dirSchemas.keys()).join(", ");
+            throw new Error(`Schema with $id "${schemaId}" not found in ${schemaDir}. Available: ${availableIds}`);
+        }
+        schemaObj = entry.schema;
+        schemaBaseDir = schemaDir;
+    }
+    else if (typeof schema === "string") {
         schemaObj = (await loadJson(schema));
-        schemaDir = dirname(resolve(schema));
+        schemaBaseDir = dirname(resolve(schema));
     }
     else {
         schemaObj = schema;
         // For inline schemas, use current working directory
-        schemaDir = process.cwd();
+        schemaBaseDir = process.cwd();
     }
     const { Ajv, addFormats } = await getAjv();
     // Configure ajv options
@@ -272,10 +313,41 @@ export async function jsonValidate(filePath, schema, path, options = {}) {
     }
     const ajv = new Ajv(ajvOptions);
     addFormats(ajv);
-    // Pre-load local refs if enabled
+    // Pre-register user-provided schemas
     const resolvedRefs = [];
-    if (resolveLocalRefs) {
-        const localRefs = await loadLocalRefs(schemaObj, schemaDir);
+    for (const [uri, schemaValue] of Object.entries(schemas)) {
+        let schemaToAdd;
+        if (typeof schemaValue === "string") {
+            // Load from file
+            const loaded = await loadJson(schemaValue);
+            if (!isValidJsonSchema(loaded)) {
+                throw new Error(`Schema file ${schemaValue} is not a valid JSON Schema`);
+            }
+            schemaToAdd = loaded;
+            resolvedRefs.push(schemaValue);
+        }
+        else {
+            // Inline schema object
+            if (!isValidJsonSchema(schemaValue)) {
+                throw new Error(`Inline schema for "${uri}" is not a valid JSON Schema`);
+            }
+            schemaToAdd = schemaValue;
+        }
+        ajv.addSchema(schemaToAdd, uri);
+    }
+    // Register all schemas from schemaDir (if provided)
+    if (dirSchemas) {
+        for (const [id, { schema: dirSchema, file }] of dirSchemas) {
+            // Don't re-register the entrypoint schema
+            if (id !== schemaId) {
+                ajv.addSchema(dirSchema, id);
+                resolvedRefs.push(file);
+            }
+        }
+    }
+    // Pre-load local refs if enabled (skip if using schemaDir since all schemas are already loaded)
+    if (resolveLocalRefs && !dirSchemas) {
+        const localRefs = await loadLocalRefs(schemaObj, schemaBaseDir);
         for (const [refPath, refSchema] of localRefs) {
             // If schema has $id, ajv will use that for resolution
             // Otherwise we add it by its relative filename

package/dist/utils/path-helpers.d.ts

@@ -3,4 +3,10 @@ export declare function normalizeToJsonPath(path: string): string;
 export declare function getKeysAtPath(data: unknown, path: string): string[];
 export declare function buildPathTo(basePath: string, key: string): string;
 export declare function findPaths(data: unknown, predicate: (value: unknown, path: string) => boolean, currentPath?: string, maxResults?: number): string[];
+/**
+ * Set a value at a specific JSONPath in the data.
+ * Mutates the data in place and returns the modified data.
+ * Throws if the path doesn't exist (parent must exist).
+ */
+export declare function setValueAtPath(data: unknown, path: string, value: unknown): unknown;
 export declare function getDepthPreview(data: unknown, maxDepth?: number, currentDepth?: number): unknown;

package/dist/utils/path-helpers.js

@@ -70,6 +70,115 @@ export function findPaths(data, predicate, currentPath = "$", maxResults = 100)
     traverse(data, currentPath);
     return results;
 }
+/**
+ * Parse a JSONPath into segments for traversal.
+ * Returns array of keys/indices to traverse.
+ */
+function parsePathSegments(path) {
+    const normalized = normalizeToJsonPath(path);
+    if (normalized === "$")
+        return [];
+    const segments = [];
+    // Remove leading $
+    const pathWithoutRoot = normalized.slice(1);
+    // Match either .key (including $-prefixed keys like $id), [index], or ["key"]
+    // Keys can start with letter, underscore, or $ and contain alphanumeric, underscore, or $
+    const regex = /\.([a-zA-Z_$][a-zA-Z0-9_$]*)|\.?(\[(\d+)\])|\.?\["([^"]+)"\]|\.?\['([^']+)'\]/g;
+    let match;
+    let lastIndex = 0;
+    while ((match = regex.exec(pathWithoutRoot)) !== null) {
+        // Check for gaps in parsing (unmatched content)
+        if (match.index > lastIndex) {
+            const unmatched = pathWithoutRoot.slice(lastIndex, match.index);
+            if (unmatched && unmatched !== ".") {
+                throw new Error(`Invalid path segment: could not parse "${unmatched}" in path "${path}"`);
+            }
+        }
+        lastIndex = regex.lastIndex;
+        if (match[1] !== undefined) {
+            // .key format
+            segments.push(match[1]);
+        }
+        else if (match[3] !== undefined) {
+            // [index] format
+            segments.push(parseInt(match[3], 10));
+        }
+        else if (match[4] !== undefined) {
+            // ["key"] format
+            segments.push(match[4]);
+        }
+        else if (match[5] !== undefined) {
+            // ['key'] format
+            segments.push(match[5]);
+        }
+    }
+    // Check for trailing unmatched content
+    if (lastIndex < pathWithoutRoot.length) {
+        const unmatched = pathWithoutRoot.slice(lastIndex);
+        if (unmatched && unmatched !== ".") {
+            throw new Error(`Invalid path segment: could not parse "${unmatched}" in path "${path}"`);
+        }
+    }
+    // Safety check: if path has content but no segments were parsed, something is wrong
+    if (pathWithoutRoot.length > 0 && segments.length === 0) {
+        throw new Error(`Failed to parse path "${path}": no valid segments found`);
+    }
+    return segments;
+}
+/**
+ * Set a value at a specific JSONPath in the data.
+ * Mutates the data in place and returns the modified data.
+ * Throws if the path doesn't exist (parent must exist).
+ */
+export function setValueAtPath(data, path, value) {
+    const segments = parsePathSegments(path);
+    if (segments.length === 0) {
+        // Setting root - just return the new value
+        return value;
+    }
+    // Traverse to parent
+    let current = data;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const segment = segments[i];
+        if (current === null || typeof current !== "object") {
+            throw new Error(`Cannot traverse path: parent at segment "${segment}" is not an object or array`);
+        }
+        if (Array.isArray(current)) {
+            if (typeof segment !== "number") {
+                throw new Error(`Cannot use string key "${segment}" on array`);
+            }
+            if (segment < 0 || segment >= current.length) {
+                throw new Error(`Array index ${segment} out of bounds (length: ${current.length})`);
+            }
+            current = current[segment];
+        }
+        else {
+            const key = String(segment);
+            if (!(key in current)) {
+                throw new Error(`Key "${key}" not found in object`);
+            }
+            current = current[key];
+        }
+    }
+    // Set the value at the final segment
+    const finalSegment = segments[segments.length - 1];
+    if (current === null || typeof current !== "object") {
+        throw new Error(`Cannot set value: parent is not an object or array`);
+    }
+    if (Array.isArray(current)) {
+        if (typeof finalSegment !== "number") {
+            throw new Error(`Cannot use string key "${finalSegment}" on array`);
+        }
+        if (finalSegment < 0 || finalSegment >= current.length) {
+            throw new Error(`Array index ${finalSegment} out of bounds (length: ${current.length})`);
+        }
+        current[finalSegment] = value;
+    }
+    else {
+        current[String(finalSegment)] = value;
+    }
+    return data;
+}
 export function getDepthPreview(data, maxDepth = 2, currentDepth = 0) {
     if (currentDepth >= maxDepth) {
         if (data === null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-explorer-mcp",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "MCP server for efficiently exploring large JSON files",
   "type": "module",
   "main": "dist/index.js",